
(FPCore (x y z t a) :precision binary64 (- (+ x y) (/ (* (- z t) y) (- a t))))
double code(double x, double y, double z, double t, double a) {
return (x + y) - (((z - t) * y) / (a - t));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (x + y) - (((z - t) * y) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return (x + y) - (((z - t) * y) / (a - t));
}
def code(x, y, z, t, a): return (x + y) - (((z - t) * y) / (a - t))
function code(x, y, z, t, a) return Float64(Float64(x + y) - Float64(Float64(Float64(z - t) * y) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = (x + y) - (((z - t) * y) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(N[(x + y), $MachinePrecision] - N[(N[(N[(z - t), $MachinePrecision] * y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x + y\right) - \frac{\left(z - t\right) \cdot y}{a - t}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (- (+ x y) (/ (* (- z t) y) (- a t))))
double code(double x, double y, double z, double t, double a) {
return (x + y) - (((z - t) * y) / (a - t));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (x + y) - (((z - t) * y) / (a - t))
end function
public static double code(double x, double y, double z, double t, double a) {
return (x + y) - (((z - t) * y) / (a - t));
}
def code(x, y, z, t, a): return (x + y) - (((z - t) * y) / (a - t))
function code(x, y, z, t, a) return Float64(Float64(x + y) - Float64(Float64(Float64(z - t) * y) / Float64(a - t))) end
function tmp = code(x, y, z, t, a) tmp = (x + y) - (((z - t) * y) / (a - t)); end
code[x_, y_, z_, t_, a_] := N[(N[(x + y), $MachinePrecision] - N[(N[(N[(z - t), $MachinePrecision] * y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x + y\right) - \frac{\left(z - t\right) \cdot y}{a - t}
\end{array}
(FPCore (x y z t a)
:precision binary64
(if (<= t -1.05e+121)
(+ x (* a (- (* y (/ z (* t a))) (/ y t))))
(if (<= t 1.6e+18)
(fma (- z t) (/ y (- t a)) (+ x y))
(+ x (* y (- (/ z t) (/ a t)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -1.05e+121) {
tmp = x + (a * ((y * (z / (t * a))) - (y / t)));
} else if (t <= 1.6e+18) {
tmp = fma((z - t), (y / (t - a)), (x + y));
} else {
tmp = x + (y * ((z / t) - (a / t)));
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (t <= -1.05e+121) tmp = Float64(x + Float64(a * Float64(Float64(y * Float64(z / Float64(t * a))) - Float64(y / t)))); elseif (t <= 1.6e+18) tmp = fma(Float64(z - t), Float64(y / Float64(t - a)), Float64(x + y)); else tmp = Float64(x + Float64(y * Float64(Float64(z / t) - Float64(a / t)))); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -1.05e+121], N[(x + N[(a * N[(N[(y * N[(z / N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.6e+18], N[(N[(z - t), $MachinePrecision] * N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision] + N[(x + y), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(z / t), $MachinePrecision] - N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.05 \cdot 10^{+121}:\\
\;\;\;\;x + a \cdot \left(y \cdot \frac{z}{t \cdot a} - \frac{y}{t}\right)\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{+18}:\\
\;\;\;\;\mathsf{fma}\left(z - t, \frac{y}{t - a}, x + y\right)\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \left(\frac{z}{t} - \frac{a}{t}\right)\\
\end{array}
\end{array}
if t < -1.0500000000000001e121Initial program 63.0%
sub-neg63.0%
+-commutative63.0%
distribute-frac-neg63.0%
distribute-rgt-neg-out63.0%
associate-/l*65.5%
fma-define66.1%
distribute-frac-neg66.1%
distribute-neg-frac266.1%
sub-neg66.1%
distribute-neg-in66.1%
remove-double-neg66.1%
+-commutative66.1%
sub-neg66.1%
Simplified66.1%
Taylor expanded in t around inf 66.4%
associate--l+66.4%
associate-+r+81.7%
distribute-rgt1-in81.7%
metadata-eval81.7%
mul0-lft81.7%
associate-/l*84.9%
associate-/l*92.5%
Simplified92.5%
Taylor expanded in a around inf 86.5%
associate-/l*92.8%
*-commutative92.8%
Simplified92.8%
if -1.0500000000000001e121 < t < 1.6e18Initial program 93.5%
sub-neg93.5%
+-commutative93.5%
distribute-frac-neg93.5%
distribute-rgt-neg-out93.5%
associate-/l*93.9%
fma-define94.0%
distribute-frac-neg94.0%
distribute-neg-frac294.0%
sub-neg94.0%
distribute-neg-in94.0%
remove-double-neg94.0%
+-commutative94.0%
sub-neg94.0%
Simplified94.0%
if 1.6e18 < t Initial program 53.9%
sub-neg53.9%
+-commutative53.9%
distribute-frac-neg53.9%
distribute-rgt-neg-out53.9%
associate-/l*66.4%
fma-define66.3%
distribute-frac-neg66.3%
distribute-neg-frac266.3%
sub-neg66.3%
distribute-neg-in66.3%
remove-double-neg66.3%
+-commutative66.3%
sub-neg66.3%
Simplified66.3%
Taylor expanded in t around inf 67.7%
associate--l+67.7%
associate-+r+76.5%
distribute-rgt1-in76.5%
metadata-eval76.5%
mul0-lft76.5%
associate-/l*84.0%
associate-/l*88.9%
Simplified88.9%
Taylor expanded in y around 0 90.5%
Final simplification93.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- x (/ (* y (- a z)) t))))
(if (<= a -1.8e+82)
(+ x y)
(if (<= a -7e-83)
(* z (/ y (- t a)))
(if (<= a 2.6e-142)
t_1
(if (<= a 2.6e-103)
(/ z (/ (- t a) y))
(if (<= a 1450000.0) t_1 (+ x y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y * (a - z)) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -7e-83) {
tmp = z * (y / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 1450000.0) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x - ((y * (a - z)) / t)
if (a <= (-1.8d+82)) then
tmp = x + y
else if (a <= (-7d-83)) then
tmp = z * (y / (t - a))
else if (a <= 2.6d-142) then
tmp = t_1
else if (a <= 2.6d-103) then
tmp = z / ((t - a) / y)
else if (a <= 1450000.0d0) then
tmp = t_1
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x - ((y * (a - z)) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -7e-83) {
tmp = z * (y / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 1450000.0) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x - ((y * (a - z)) / t) tmp = 0 if a <= -1.8e+82: tmp = x + y elif a <= -7e-83: tmp = z * (y / (t - a)) elif a <= 2.6e-142: tmp = t_1 elif a <= 2.6e-103: tmp = z / ((t - a) / y) elif a <= 1450000.0: tmp = t_1 else: tmp = x + y return tmp
function code(x, y, z, t, a) t_1 = Float64(x - Float64(Float64(y * Float64(a - z)) / t)) tmp = 0.0 if (a <= -1.8e+82) tmp = Float64(x + y); elseif (a <= -7e-83) tmp = Float64(z * Float64(y / Float64(t - a))); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = Float64(z / Float64(Float64(t - a) / y)); elseif (a <= 1450000.0) tmp = t_1; else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x - ((y * (a - z)) / t); tmp = 0.0; if (a <= -1.8e+82) tmp = x + y; elseif (a <= -7e-83) tmp = z * (y / (t - a)); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = z / ((t - a) / y); elseif (a <= 1450000.0) tmp = t_1; else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x - N[(N[(y * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.8e+82], N[(x + y), $MachinePrecision], If[LessEqual[a, -7e-83], N[(z * N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.6e-142], t$95$1, If[LessEqual[a, 2.6e-103], N[(z / N[(N[(t - a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1450000.0], t$95$1, N[(x + y), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x - \frac{y \cdot \left(a - z\right)}{t}\\
\mathbf{if}\;a \leq -1.8 \cdot 10^{+82}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;a \leq -7 \cdot 10^{-83}:\\
\;\;\;\;z \cdot \frac{y}{t - a}\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-142}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-103}:\\
\;\;\;\;\frac{z}{\frac{t - a}{y}}\\
\mathbf{elif}\;a \leq 1450000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -1.80000000000000007e82 or 1.45e6 < a Initial program 81.1%
Taylor expanded in a around inf 78.5%
+-commutative78.5%
Simplified78.5%
if -1.80000000000000007e82 < a < -7.00000000000000061e-83Initial program 76.6%
sub-neg76.6%
+-commutative76.6%
distribute-frac-neg76.6%
distribute-rgt-neg-out76.6%
associate-/l*81.1%
fma-define81.6%
distribute-frac-neg81.6%
distribute-neg-frac281.6%
sub-neg81.6%
distribute-neg-in81.6%
remove-double-neg81.6%
+-commutative81.6%
sub-neg81.6%
Simplified81.6%
Taylor expanded in z around inf 50.7%
*-commutative50.7%
*-un-lft-identity50.7%
times-frac62.2%
Applied egg-rr62.2%
if -7.00000000000000061e-83 < a < 2.6e-142 or 2.59999999999999996e-103 < a < 1.45e6Initial program 79.0%
Taylor expanded in t around inf 83.1%
associate--l+83.1%
distribute-lft-out--83.1%
div-sub85.0%
mul-1-neg85.0%
unsub-neg85.0%
*-commutative85.0%
distribute-lft-out--85.0%
Simplified85.0%
if 2.6e-142 < a < 2.59999999999999996e-103Initial program 99.2%
sub-neg99.2%
+-commutative99.2%
distribute-frac-neg99.2%
distribute-rgt-neg-out99.2%
associate-/l*99.0%
fma-define99.0%
distribute-frac-neg99.0%
distribute-neg-frac299.0%
sub-neg99.0%
distribute-neg-in99.0%
remove-double-neg99.0%
+-commutative99.0%
sub-neg99.0%
Simplified99.0%
Taylor expanded in z around inf 93.9%
*-commutative93.9%
*-un-lft-identity93.9%
times-frac93.7%
Applied egg-rr93.7%
Taylor expanded in z around 0 93.9%
*-commutative93.9%
*-rgt-identity93.9%
times-frac83.9%
/-rgt-identity83.9%
associate-/r/94.5%
Simplified94.5%
Final simplification79.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* y z) t))))
(if (<= a -1.8e+82)
(+ x y)
(if (<= a -8.5e-81)
(* y (/ z (- t a)))
(if (<= a 2.6e-142)
t_1
(if (<= a 2.6e-103)
(/ z (/ (- t a) y))
(if (<= a 0.21) t_1 (+ x y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y * z) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = y * (z / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 0.21) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((y * z) / t)
if (a <= (-1.8d+82)) then
tmp = x + y
else if (a <= (-8.5d-81)) then
tmp = y * (z / (t - a))
else if (a <= 2.6d-142) then
tmp = t_1
else if (a <= 2.6d-103) then
tmp = z / ((t - a) / y)
else if (a <= 0.21d0) then
tmp = t_1
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y * z) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = y * (z / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 0.21) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y * z) / t) tmp = 0 if a <= -1.8e+82: tmp = x + y elif a <= -8.5e-81: tmp = y * (z / (t - a)) elif a <= 2.6e-142: tmp = t_1 elif a <= 2.6e-103: tmp = z / ((t - a) / y) elif a <= 0.21: tmp = t_1 else: tmp = x + y return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y * z) / t)) tmp = 0.0 if (a <= -1.8e+82) tmp = Float64(x + y); elseif (a <= -8.5e-81) tmp = Float64(y * Float64(z / Float64(t - a))); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = Float64(z / Float64(Float64(t - a) / y)); elseif (a <= 0.21) tmp = t_1; else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y * z) / t); tmp = 0.0; if (a <= -1.8e+82) tmp = x + y; elseif (a <= -8.5e-81) tmp = y * (z / (t - a)); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = z / ((t - a) / y); elseif (a <= 0.21) tmp = t_1; else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.8e+82], N[(x + y), $MachinePrecision], If[LessEqual[a, -8.5e-81], N[(y * N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.6e-142], t$95$1, If[LessEqual[a, 2.6e-103], N[(z / N[(N[(t - a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 0.21], t$95$1, N[(x + y), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y \cdot z}{t}\\
\mathbf{if}\;a \leq -1.8 \cdot 10^{+82}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;a \leq -8.5 \cdot 10^{-81}:\\
\;\;\;\;y \cdot \frac{z}{t - a}\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-142}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-103}:\\
\;\;\;\;\frac{z}{\frac{t - a}{y}}\\
\mathbf{elif}\;a \leq 0.21:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -1.80000000000000007e82 or 0.209999999999999992 < a Initial program 81.1%
Taylor expanded in a around inf 78.5%
+-commutative78.5%
Simplified78.5%
if -1.80000000000000007e82 < a < -8.5000000000000001e-81Initial program 76.6%
sub-neg76.6%
+-commutative76.6%
distribute-frac-neg76.6%
distribute-rgt-neg-out76.6%
associate-/l*81.1%
fma-define81.6%
distribute-frac-neg81.6%
distribute-neg-frac281.6%
sub-neg81.6%
distribute-neg-in81.6%
remove-double-neg81.6%
+-commutative81.6%
sub-neg81.6%
Simplified81.6%
Taylor expanded in z around inf 50.7%
associate-/l*62.1%
Simplified62.1%
if -8.5000000000000001e-81 < a < 2.6e-142 or 2.59999999999999996e-103 < a < 0.209999999999999992Initial program 79.0%
sub-neg79.0%
+-commutative79.0%
distribute-frac-neg79.0%
distribute-rgt-neg-out79.0%
associate-/l*78.3%
fma-define78.4%
distribute-frac-neg78.4%
distribute-neg-frac278.4%
sub-neg78.4%
distribute-neg-in78.4%
remove-double-neg78.4%
+-commutative78.4%
sub-neg78.4%
Simplified78.4%
Taylor expanded in t around inf 74.2%
associate--l+74.2%
associate-+r+83.1%
distribute-rgt1-in83.1%
metadata-eval83.1%
mul0-lft83.1%
associate-/l*80.4%
associate-/l*78.6%
Simplified78.6%
Taylor expanded in a around 0 82.5%
if 2.6e-142 < a < 2.59999999999999996e-103Initial program 99.2%
sub-neg99.2%
+-commutative99.2%
distribute-frac-neg99.2%
distribute-rgt-neg-out99.2%
associate-/l*99.0%
fma-define99.0%
distribute-frac-neg99.0%
distribute-neg-frac299.0%
sub-neg99.0%
distribute-neg-in99.0%
remove-double-neg99.0%
+-commutative99.0%
sub-neg99.0%
Simplified99.0%
Taylor expanded in z around inf 93.9%
*-commutative93.9%
*-un-lft-identity93.9%
times-frac93.7%
Applied egg-rr93.7%
Taylor expanded in z around 0 93.9%
*-commutative93.9%
*-rgt-identity93.9%
times-frac83.9%
/-rgt-identity83.9%
associate-/r/94.5%
Simplified94.5%
Final simplification78.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ x (/ (* y z) t))))
(if (<= a -1.8e+82)
(+ x y)
(if (<= a -8.5e-81)
(* z (/ y (- t a)))
(if (<= a 2.6e-142)
t_1
(if (<= a 2.6e-103)
(/ z (/ (- t a) y))
(if (<= a 0.048) t_1 (+ x y))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y * z) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = z * (y / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 0.048) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = x + ((y * z) / t)
if (a <= (-1.8d+82)) then
tmp = x + y
else if (a <= (-8.5d-81)) then
tmp = z * (y / (t - a))
else if (a <= 2.6d-142) then
tmp = t_1
else if (a <= 2.6d-103) then
tmp = z / ((t - a) / y)
else if (a <= 0.048d0) then
tmp = t_1
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = x + ((y * z) / t);
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = z * (y / (t - a));
} else if (a <= 2.6e-142) {
tmp = t_1;
} else if (a <= 2.6e-103) {
tmp = z / ((t - a) / y);
} else if (a <= 0.048) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = x + ((y * z) / t) tmp = 0 if a <= -1.8e+82: tmp = x + y elif a <= -8.5e-81: tmp = z * (y / (t - a)) elif a <= 2.6e-142: tmp = t_1 elif a <= 2.6e-103: tmp = z / ((t - a) / y) elif a <= 0.048: tmp = t_1 else: tmp = x + y return tmp
function code(x, y, z, t, a) t_1 = Float64(x + Float64(Float64(y * z) / t)) tmp = 0.0 if (a <= -1.8e+82) tmp = Float64(x + y); elseif (a <= -8.5e-81) tmp = Float64(z * Float64(y / Float64(t - a))); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = Float64(z / Float64(Float64(t - a) / y)); elseif (a <= 0.048) tmp = t_1; else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = x + ((y * z) / t); tmp = 0.0; if (a <= -1.8e+82) tmp = x + y; elseif (a <= -8.5e-81) tmp = z * (y / (t - a)); elseif (a <= 2.6e-142) tmp = t_1; elseif (a <= 2.6e-103) tmp = z / ((t - a) / y); elseif (a <= 0.048) tmp = t_1; else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.8e+82], N[(x + y), $MachinePrecision], If[LessEqual[a, -8.5e-81], N[(z * N[(y / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.6e-142], t$95$1, If[LessEqual[a, 2.6e-103], N[(z / N[(N[(t - a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 0.048], t$95$1, N[(x + y), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y \cdot z}{t}\\
\mathbf{if}\;a \leq -1.8 \cdot 10^{+82}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;a \leq -8.5 \cdot 10^{-81}:\\
\;\;\;\;z \cdot \frac{y}{t - a}\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-142}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.6 \cdot 10^{-103}:\\
\;\;\;\;\frac{z}{\frac{t - a}{y}}\\
\mathbf{elif}\;a \leq 0.048:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -1.80000000000000007e82 or 0.048000000000000001 < a Initial program 81.1%
Taylor expanded in a around inf 78.5%
+-commutative78.5%
Simplified78.5%
if -1.80000000000000007e82 < a < -8.5000000000000001e-81Initial program 76.6%
sub-neg76.6%
+-commutative76.6%
distribute-frac-neg76.6%
distribute-rgt-neg-out76.6%
associate-/l*81.1%
fma-define81.6%
distribute-frac-neg81.6%
distribute-neg-frac281.6%
sub-neg81.6%
distribute-neg-in81.6%
remove-double-neg81.6%
+-commutative81.6%
sub-neg81.6%
Simplified81.6%
Taylor expanded in z around inf 50.7%
*-commutative50.7%
*-un-lft-identity50.7%
times-frac62.2%
Applied egg-rr62.2%
if -8.5000000000000001e-81 < a < 2.6e-142 or 2.59999999999999996e-103 < a < 0.048000000000000001Initial program 79.0%
sub-neg79.0%
+-commutative79.0%
distribute-frac-neg79.0%
distribute-rgt-neg-out79.0%
associate-/l*78.3%
fma-define78.4%
distribute-frac-neg78.4%
distribute-neg-frac278.4%
sub-neg78.4%
distribute-neg-in78.4%
remove-double-neg78.4%
+-commutative78.4%
sub-neg78.4%
Simplified78.4%
Taylor expanded in t around inf 74.2%
associate--l+74.2%
associate-+r+83.1%
distribute-rgt1-in83.1%
metadata-eval83.1%
mul0-lft83.1%
associate-/l*80.4%
associate-/l*78.6%
Simplified78.6%
Taylor expanded in a around 0 82.5%
if 2.6e-142 < a < 2.59999999999999996e-103Initial program 99.2%
sub-neg99.2%
+-commutative99.2%
distribute-frac-neg99.2%
distribute-rgt-neg-out99.2%
associate-/l*99.0%
fma-define99.0%
distribute-frac-neg99.0%
distribute-neg-frac299.0%
sub-neg99.0%
distribute-neg-in99.0%
remove-double-neg99.0%
+-commutative99.0%
sub-neg99.0%
Simplified99.0%
Taylor expanded in z around inf 93.9%
*-commutative93.9%
*-un-lft-identity93.9%
times-frac93.7%
Applied egg-rr93.7%
Taylor expanded in z around 0 93.9%
*-commutative93.9%
*-rgt-identity93.9%
times-frac83.9%
/-rgt-identity83.9%
associate-/r/94.5%
Simplified94.5%
Final simplification78.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (+ x y) (* y (/ z a)))))
(if (<= a -4.45e-23)
t_1
(if (<= a 3.2e-174)
(+ x (* z (/ y t)))
(if (or (<= a 1.05e-89) (not (<= a 0.084)))
t_1
(- x (/ (* y (- a z)) t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (x + y) - (y * (z / a));
double tmp;
if (a <= -4.45e-23) {
tmp = t_1;
} else if (a <= 3.2e-174) {
tmp = x + (z * (y / t));
} else if ((a <= 1.05e-89) || !(a <= 0.084)) {
tmp = t_1;
} else {
tmp = x - ((y * (a - z)) / t);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (x + y) - (y * (z / a))
if (a <= (-4.45d-23)) then
tmp = t_1
else if (a <= 3.2d-174) then
tmp = x + (z * (y / t))
else if ((a <= 1.05d-89) .or. (.not. (a <= 0.084d0))) then
tmp = t_1
else
tmp = x - ((y * (a - z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (x + y) - (y * (z / a));
double tmp;
if (a <= -4.45e-23) {
tmp = t_1;
} else if (a <= 3.2e-174) {
tmp = x + (z * (y / t));
} else if ((a <= 1.05e-89) || !(a <= 0.084)) {
tmp = t_1;
} else {
tmp = x - ((y * (a - z)) / t);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (x + y) - (y * (z / a)) tmp = 0 if a <= -4.45e-23: tmp = t_1 elif a <= 3.2e-174: tmp = x + (z * (y / t)) elif (a <= 1.05e-89) or not (a <= 0.084): tmp = t_1 else: tmp = x - ((y * (a - z)) / t) return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(x + y) - Float64(y * Float64(z / a))) tmp = 0.0 if (a <= -4.45e-23) tmp = t_1; elseif (a <= 3.2e-174) tmp = Float64(x + Float64(z * Float64(y / t))); elseif ((a <= 1.05e-89) || !(a <= 0.084)) tmp = t_1; else tmp = Float64(x - Float64(Float64(y * Float64(a - z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (x + y) - (y * (z / a)); tmp = 0.0; if (a <= -4.45e-23) tmp = t_1; elseif (a <= 3.2e-174) tmp = x + (z * (y / t)); elseif ((a <= 1.05e-89) || ~((a <= 0.084))) tmp = t_1; else tmp = x - ((y * (a - z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(x + y), $MachinePrecision] - N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.45e-23], t$95$1, If[LessEqual[a, 3.2e-174], N[(x + N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, 1.05e-89], N[Not[LessEqual[a, 0.084]], $MachinePrecision]], t$95$1, N[(x - N[(N[(y * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + y\right) - y \cdot \frac{z}{a}\\
\mathbf{if}\;a \leq -4.45 \cdot 10^{-23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-174}:\\
\;\;\;\;x + z \cdot \frac{y}{t}\\
\mathbf{elif}\;a \leq 1.05 \cdot 10^{-89} \lor \neg \left(a \leq 0.084\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y \cdot \left(a - z\right)}{t}\\
\end{array}
\end{array}
if a < -4.45000000000000011e-23 or 3.2e-174 < a < 1.05e-89 or 0.0840000000000000052 < a Initial program 83.9%
Taylor expanded in t around 0 84.0%
+-commutative84.0%
associate-/l*86.8%
Simplified86.8%
if -4.45000000000000011e-23 < a < 3.2e-174Initial program 73.4%
sub-neg73.4%
+-commutative73.4%
distribute-frac-neg73.4%
distribute-rgt-neg-out73.4%
associate-/l*75.4%
fma-define75.6%
distribute-frac-neg75.6%
distribute-neg-frac275.6%
sub-neg75.6%
distribute-neg-in75.6%
remove-double-neg75.6%
+-commutative75.6%
sub-neg75.6%
Simplified75.6%
Taylor expanded in t around inf 75.9%
associate--l+75.9%
associate-+r+86.2%
distribute-rgt1-in86.2%
metadata-eval86.2%
mul0-lft86.2%
associate-/l*86.2%
associate-/l*84.9%
Simplified84.9%
Taylor expanded in z around inf 85.6%
+-commutative85.6%
mul-1-neg85.6%
sub-neg85.6%
*-commutative85.6%
*-commutative85.6%
times-frac83.3%
Simplified83.3%
Taylor expanded in z around inf 87.4%
if 1.05e-89 < a < 0.0840000000000000052Initial program 78.2%
Taylor expanded in t around inf 69.9%
associate--l+69.9%
distribute-lft-out--69.9%
div-sub81.0%
mul-1-neg81.0%
unsub-neg81.0%
*-commutative81.0%
distribute-lft-out--81.0%
Simplified81.0%
Final simplification86.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (+ x y) (* y (/ z a)))))
(if (<= a -6.2e-24)
t_1
(if (<= a 3.2e-174)
(+ x (/ 1.0 (/ (/ t y) (- z a))))
(if (or (<= a 6.5e-90) (not (<= a 0.345)))
t_1
(- x (/ (* y (- a z)) t)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (x + y) - (y * (z / a));
double tmp;
if (a <= -6.2e-24) {
tmp = t_1;
} else if (a <= 3.2e-174) {
tmp = x + (1.0 / ((t / y) / (z - a)));
} else if ((a <= 6.5e-90) || !(a <= 0.345)) {
tmp = t_1;
} else {
tmp = x - ((y * (a - z)) / t);
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (x + y) - (y * (z / a))
if (a <= (-6.2d-24)) then
tmp = t_1
else if (a <= 3.2d-174) then
tmp = x + (1.0d0 / ((t / y) / (z - a)))
else if ((a <= 6.5d-90) .or. (.not. (a <= 0.345d0))) then
tmp = t_1
else
tmp = x - ((y * (a - z)) / t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (x + y) - (y * (z / a));
double tmp;
if (a <= -6.2e-24) {
tmp = t_1;
} else if (a <= 3.2e-174) {
tmp = x + (1.0 / ((t / y) / (z - a)));
} else if ((a <= 6.5e-90) || !(a <= 0.345)) {
tmp = t_1;
} else {
tmp = x - ((y * (a - z)) / t);
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (x + y) - (y * (z / a)) tmp = 0 if a <= -6.2e-24: tmp = t_1 elif a <= 3.2e-174: tmp = x + (1.0 / ((t / y) / (z - a))) elif (a <= 6.5e-90) or not (a <= 0.345): tmp = t_1 else: tmp = x - ((y * (a - z)) / t) return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(x + y) - Float64(y * Float64(z / a))) tmp = 0.0 if (a <= -6.2e-24) tmp = t_1; elseif (a <= 3.2e-174) tmp = Float64(x + Float64(1.0 / Float64(Float64(t / y) / Float64(z - a)))); elseif ((a <= 6.5e-90) || !(a <= 0.345)) tmp = t_1; else tmp = Float64(x - Float64(Float64(y * Float64(a - z)) / t)); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (x + y) - (y * (z / a)); tmp = 0.0; if (a <= -6.2e-24) tmp = t_1; elseif (a <= 3.2e-174) tmp = x + (1.0 / ((t / y) / (z - a))); elseif ((a <= 6.5e-90) || ~((a <= 0.345))) tmp = t_1; else tmp = x - ((y * (a - z)) / t); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(x + y), $MachinePrecision] - N[(y * N[(z / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -6.2e-24], t$95$1, If[LessEqual[a, 3.2e-174], N[(x + N[(1.0 / N[(N[(t / y), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, 6.5e-90], N[Not[LessEqual[a, 0.345]], $MachinePrecision]], t$95$1, N[(x - N[(N[(y * N[(a - z), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + y\right) - y \cdot \frac{z}{a}\\
\mathbf{if}\;a \leq -6.2 \cdot 10^{-24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-174}:\\
\;\;\;\;x + \frac{1}{\frac{\frac{t}{y}}{z - a}}\\
\mathbf{elif}\;a \leq 6.5 \cdot 10^{-90} \lor \neg \left(a \leq 0.345\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x - \frac{y \cdot \left(a - z\right)}{t}\\
\end{array}
\end{array}
if a < -6.2000000000000001e-24 or 3.2e-174 < a < 6.4999999999999996e-90 or 0.34499999999999997 < a Initial program 83.9%
Taylor expanded in t around 0 84.0%
+-commutative84.0%
associate-/l*86.8%
Simplified86.8%
if -6.2000000000000001e-24 < a < 3.2e-174Initial program 73.4%
Taylor expanded in t around inf 86.2%
associate--l+86.2%
distribute-lft-out--86.2%
div-sub86.3%
mul-1-neg86.3%
unsub-neg86.3%
*-commutative86.3%
distribute-lft-out--86.3%
Simplified86.3%
clear-num86.3%
inv-pow86.3%
Applied egg-rr86.3%
unpow-186.3%
associate-/r*88.4%
Simplified88.4%
if 6.4999999999999996e-90 < a < 0.34499999999999997Initial program 78.2%
Taylor expanded in t around inf 69.9%
associate--l+69.9%
distribute-lft-out--69.9%
div-sub81.0%
mul-1-neg81.0%
unsub-neg81.0%
*-commutative81.0%
distribute-lft-out--81.0%
Simplified81.0%
Final simplification86.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* z (/ y (- a)))))
(if (<= z -8.5e+217)
t_1
(if (<= z -2.2e+166)
(* y (/ z t))
(if (or (<= z -1.45e+161) (not (<= z 4.7e+154))) t_1 (+ x y))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = z * (y / -a);
double tmp;
if (z <= -8.5e+217) {
tmp = t_1;
} else if (z <= -2.2e+166) {
tmp = y * (z / t);
} else if ((z <= -1.45e+161) || !(z <= 4.7e+154)) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = z * (y / -a)
if (z <= (-8.5d+217)) then
tmp = t_1
else if (z <= (-2.2d+166)) then
tmp = y * (z / t)
else if ((z <= (-1.45d+161)) .or. (.not. (z <= 4.7d+154))) then
tmp = t_1
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = z * (y / -a);
double tmp;
if (z <= -8.5e+217) {
tmp = t_1;
} else if (z <= -2.2e+166) {
tmp = y * (z / t);
} else if ((z <= -1.45e+161) || !(z <= 4.7e+154)) {
tmp = t_1;
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = z * (y / -a) tmp = 0 if z <= -8.5e+217: tmp = t_1 elif z <= -2.2e+166: tmp = y * (z / t) elif (z <= -1.45e+161) or not (z <= 4.7e+154): tmp = t_1 else: tmp = x + y return tmp
function code(x, y, z, t, a) t_1 = Float64(z * Float64(y / Float64(-a))) tmp = 0.0 if (z <= -8.5e+217) tmp = t_1; elseif (z <= -2.2e+166) tmp = Float64(y * Float64(z / t)); elseif ((z <= -1.45e+161) || !(z <= 4.7e+154)) tmp = t_1; else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = z * (y / -a); tmp = 0.0; if (z <= -8.5e+217) tmp = t_1; elseif (z <= -2.2e+166) tmp = y * (z / t); elseif ((z <= -1.45e+161) || ~((z <= 4.7e+154))) tmp = t_1; else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(z * N[(y / (-a)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.5e+217], t$95$1, If[LessEqual[z, -2.2e+166], N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -1.45e+161], N[Not[LessEqual[z, 4.7e+154]], $MachinePrecision]], t$95$1, N[(x + y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \frac{y}{-a}\\
\mathbf{if}\;z \leq -8.5 \cdot 10^{+217}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.2 \cdot 10^{+166}:\\
\;\;\;\;y \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -1.45 \cdot 10^{+161} \lor \neg \left(z \leq 4.7 \cdot 10^{+154}\right):\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if z < -8.50000000000000021e217 or -2.1999999999999999e166 < z < -1.45000000000000008e161 or 4.69999999999999983e154 < z Initial program 88.2%
sub-neg88.2%
+-commutative88.2%
distribute-frac-neg88.2%
distribute-rgt-neg-out88.2%
associate-/l*86.6%
fma-define86.8%
distribute-frac-neg86.8%
distribute-neg-frac286.8%
sub-neg86.8%
distribute-neg-in86.8%
remove-double-neg86.8%
+-commutative86.8%
sub-neg86.8%
Simplified86.8%
Taylor expanded in z around inf 77.4%
Taylor expanded in t around 0 66.3%
associate-*r/66.3%
neg-mul-166.3%
distribute-rgt-neg-in66.3%
Simplified66.3%
Taylor expanded in y around 0 66.3%
mul-1-neg66.3%
*-commutative66.3%
associate-*r/63.3%
distribute-rgt-neg-in63.3%
distribute-neg-frac263.3%
Simplified63.3%
if -8.50000000000000021e217 < z < -2.1999999999999999e166Initial program 71.5%
sub-neg71.5%
+-commutative71.5%
distribute-frac-neg71.5%
distribute-rgt-neg-out71.5%
associate-/l*88.3%
fma-define88.1%
distribute-frac-neg88.1%
distribute-neg-frac288.1%
sub-neg88.1%
distribute-neg-in88.1%
remove-double-neg88.1%
+-commutative88.1%
sub-neg88.1%
Simplified88.1%
Taylor expanded in z around inf 43.2%
Taylor expanded in t around inf 42.5%
associate-*r/61.4%
Simplified61.4%
if -1.45000000000000008e161 < z < 4.69999999999999983e154Initial program 78.7%
Taylor expanded in a around inf 66.8%
+-commutative66.8%
Simplified66.8%
Final simplification66.0%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.1e+218)
(* y (/ z (- a)))
(if (<= z -3.7e+168)
(* y (/ z t))
(if (or (<= z -2.1e+161) (not (<= z 2.05e+154)))
(* z (/ y (- a)))
(+ x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.1e+218) {
tmp = y * (z / -a);
} else if (z <= -3.7e+168) {
tmp = y * (z / t);
} else if ((z <= -2.1e+161) || !(z <= 2.05e+154)) {
tmp = z * (y / -a);
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.1d+218)) then
tmp = y * (z / -a)
else if (z <= (-3.7d+168)) then
tmp = y * (z / t)
else if ((z <= (-2.1d+161)) .or. (.not. (z <= 2.05d+154))) then
tmp = z * (y / -a)
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.1e+218) {
tmp = y * (z / -a);
} else if (z <= -3.7e+168) {
tmp = y * (z / t);
} else if ((z <= -2.1e+161) || !(z <= 2.05e+154)) {
tmp = z * (y / -a);
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.1e+218: tmp = y * (z / -a) elif z <= -3.7e+168: tmp = y * (z / t) elif (z <= -2.1e+161) or not (z <= 2.05e+154): tmp = z * (y / -a) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.1e+218) tmp = Float64(y * Float64(z / Float64(-a))); elseif (z <= -3.7e+168) tmp = Float64(y * Float64(z / t)); elseif ((z <= -2.1e+161) || !(z <= 2.05e+154)) tmp = Float64(z * Float64(y / Float64(-a))); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.1e+218) tmp = y * (z / -a); elseif (z <= -3.7e+168) tmp = y * (z / t); elseif ((z <= -2.1e+161) || ~((z <= 2.05e+154))) tmp = z * (y / -a); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.1e+218], N[(y * N[(z / (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.7e+168], N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -2.1e+161], N[Not[LessEqual[z, 2.05e+154]], $MachinePrecision]], N[(z * N[(y / (-a)), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.1 \cdot 10^{+218}:\\
\;\;\;\;y \cdot \frac{z}{-a}\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{+168}:\\
\;\;\;\;y \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{+161} \lor \neg \left(z \leq 2.05 \cdot 10^{+154}\right):\\
\;\;\;\;z \cdot \frac{y}{-a}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if z < -1.1e218Initial program 75.6%
sub-neg75.6%
+-commutative75.6%
distribute-frac-neg75.6%
distribute-rgt-neg-out75.6%
associate-/l*87.8%
fma-define88.1%
distribute-frac-neg88.1%
distribute-neg-frac288.1%
sub-neg88.1%
distribute-neg-in88.1%
remove-double-neg88.1%
+-commutative88.1%
sub-neg88.1%
Simplified88.1%
Taylor expanded in z around inf 75.3%
Taylor expanded in t around 0 63.4%
mul-1-neg63.4%
associate-/l*69.2%
distribute-lft-neg-in69.2%
Simplified69.2%
if -1.1e218 < z < -3.70000000000000009e168Initial program 71.5%
sub-neg71.5%
+-commutative71.5%
distribute-frac-neg71.5%
distribute-rgt-neg-out71.5%
associate-/l*88.3%
fma-define88.1%
distribute-frac-neg88.1%
distribute-neg-frac288.1%
sub-neg88.1%
distribute-neg-in88.1%
remove-double-neg88.1%
+-commutative88.1%
sub-neg88.1%
Simplified88.1%
Taylor expanded in z around inf 43.2%
Taylor expanded in t around inf 42.5%
associate-*r/61.4%
Simplified61.4%
if -3.70000000000000009e168 < z < -2.1e161 or 2.05e154 < z Initial program 95.3%
sub-neg95.3%
+-commutative95.3%
distribute-frac-neg95.3%
distribute-rgt-neg-out95.3%
associate-/l*86.0%
fma-define86.1%
distribute-frac-neg86.1%
distribute-neg-frac286.1%
sub-neg86.1%
distribute-neg-in86.1%
remove-double-neg86.1%
+-commutative86.1%
sub-neg86.1%
Simplified86.1%
Taylor expanded in z around inf 78.5%
Taylor expanded in t around 0 67.9%
associate-*r/67.9%
neg-mul-167.9%
distribute-rgt-neg-in67.9%
Simplified67.9%
Taylor expanded in y around 0 67.9%
mul-1-neg67.9%
*-commutative67.9%
associate-*r/63.3%
distribute-rgt-neg-in63.3%
distribute-neg-frac263.3%
Simplified63.3%
if -2.1e161 < z < 2.05e154Initial program 78.7%
Taylor expanded in a around inf 66.8%
+-commutative66.8%
Simplified66.8%
Final simplification66.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -7.5e+217)
(* y (/ z (- a)))
(if (<= z -8.5e+168)
(* y (/ z t))
(if (<= z -3e+160)
(* z (/ y (- a)))
(if (<= z 3.2e+154) (+ x y) (/ (* y z) (- a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.5e+217) {
tmp = y * (z / -a);
} else if (z <= -8.5e+168) {
tmp = y * (z / t);
} else if (z <= -3e+160) {
tmp = z * (y / -a);
} else if (z <= 3.2e+154) {
tmp = x + y;
} else {
tmp = (y * z) / -a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-7.5d+217)) then
tmp = y * (z / -a)
else if (z <= (-8.5d+168)) then
tmp = y * (z / t)
else if (z <= (-3d+160)) then
tmp = z * (y / -a)
else if (z <= 3.2d+154) then
tmp = x + y
else
tmp = (y * z) / -a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.5e+217) {
tmp = y * (z / -a);
} else if (z <= -8.5e+168) {
tmp = y * (z / t);
} else if (z <= -3e+160) {
tmp = z * (y / -a);
} else if (z <= 3.2e+154) {
tmp = x + y;
} else {
tmp = (y * z) / -a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7.5e+217: tmp = y * (z / -a) elif z <= -8.5e+168: tmp = y * (z / t) elif z <= -3e+160: tmp = z * (y / -a) elif z <= 3.2e+154: tmp = x + y else: tmp = (y * z) / -a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7.5e+217) tmp = Float64(y * Float64(z / Float64(-a))); elseif (z <= -8.5e+168) tmp = Float64(y * Float64(z / t)); elseif (z <= -3e+160) tmp = Float64(z * Float64(y / Float64(-a))); elseif (z <= 3.2e+154) tmp = Float64(x + y); else tmp = Float64(Float64(y * z) / Float64(-a)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7.5e+217) tmp = y * (z / -a); elseif (z <= -8.5e+168) tmp = y * (z / t); elseif (z <= -3e+160) tmp = z * (y / -a); elseif (z <= 3.2e+154) tmp = x + y; else tmp = (y * z) / -a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7.5e+217], N[(y * N[(z / (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8.5e+168], N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3e+160], N[(z * N[(y / (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+154], N[(x + y), $MachinePrecision], N[(N[(y * z), $MachinePrecision] / (-a)), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.5 \cdot 10^{+217}:\\
\;\;\;\;y \cdot \frac{z}{-a}\\
\mathbf{elif}\;z \leq -8.5 \cdot 10^{+168}:\\
\;\;\;\;y \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -3 \cdot 10^{+160}:\\
\;\;\;\;z \cdot \frac{y}{-a}\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+154}:\\
\;\;\;\;x + y\\
\mathbf{else}:\\
\;\;\;\;\frac{y \cdot z}{-a}\\
\end{array}
\end{array}
if z < -7.5000000000000001e217Initial program 75.6%
sub-neg75.6%
+-commutative75.6%
distribute-frac-neg75.6%
distribute-rgt-neg-out75.6%
associate-/l*87.8%
fma-define88.1%
distribute-frac-neg88.1%
distribute-neg-frac288.1%
sub-neg88.1%
distribute-neg-in88.1%
remove-double-neg88.1%
+-commutative88.1%
sub-neg88.1%
Simplified88.1%
Taylor expanded in z around inf 75.3%
Taylor expanded in t around 0 63.4%
mul-1-neg63.4%
associate-/l*69.2%
distribute-lft-neg-in69.2%
Simplified69.2%
if -7.5000000000000001e217 < z < -8.50000000000000069e168Initial program 71.5%
sub-neg71.5%
+-commutative71.5%
distribute-frac-neg71.5%
distribute-rgt-neg-out71.5%
associate-/l*88.3%
fma-define88.1%
distribute-frac-neg88.1%
distribute-neg-frac288.1%
sub-neg88.1%
distribute-neg-in88.1%
remove-double-neg88.1%
+-commutative88.1%
sub-neg88.1%
Simplified88.1%
Taylor expanded in z around inf 43.2%
Taylor expanded in t around inf 42.5%
associate-*r/61.4%
Simplified61.4%
if -8.50000000000000069e168 < z < -2.9999999999999999e160Initial program 99.2%
sub-neg99.2%
+-commutative99.2%
distribute-frac-neg99.2%
distribute-rgt-neg-out99.2%
associate-/l*100.0%
fma-define100.0%
distribute-frac-neg100.0%
distribute-neg-frac2100.0%
sub-neg100.0%
distribute-neg-in100.0%
remove-double-neg100.0%
+-commutative100.0%
sub-neg100.0%
Simplified100.0%
Taylor expanded in z around inf 99.2%
Taylor expanded in t around 0 99.2%
associate-*r/99.2%
neg-mul-199.2%
distribute-rgt-neg-in99.2%
Simplified99.2%
Taylor expanded in y around 0 99.2%
mul-1-neg99.2%
*-commutative99.2%
associate-*r/100.0%
distribute-rgt-neg-in100.0%
distribute-neg-frac2100.0%
Simplified100.0%
if -2.9999999999999999e160 < z < 3.2e154Initial program 78.7%
Taylor expanded in a around inf 66.8%
+-commutative66.8%
Simplified66.8%
if 3.2e154 < z Initial program 95.0%
sub-neg95.0%
+-commutative95.0%
distribute-frac-neg95.0%
distribute-rgt-neg-out95.0%
associate-/l*84.9%
fma-define85.1%
distribute-frac-neg85.1%
distribute-neg-frac285.1%
sub-neg85.1%
distribute-neg-in85.1%
remove-double-neg85.1%
+-commutative85.1%
sub-neg85.1%
Simplified85.1%
Taylor expanded in z around inf 76.9%
Taylor expanded in t around 0 65.5%
associate-*r/65.5%
neg-mul-165.5%
distribute-rgt-neg-in65.5%
Simplified65.5%
Final simplification66.9%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -1.85e+120) (not (<= t 3.4e+16))) (+ x (* y (- (/ z t) (/ a t)))) (- (+ x y) (* (- z t) (/ y (- a t))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.85e+120) || !(t <= 3.4e+16)) {
tmp = x + (y * ((z / t) - (a / t)));
} else {
tmp = (x + y) - ((z - t) * (y / (a - t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-1.85d+120)) .or. (.not. (t <= 3.4d+16))) then
tmp = x + (y * ((z / t) - (a / t)))
else
tmp = (x + y) - ((z - t) * (y / (a - t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -1.85e+120) || !(t <= 3.4e+16)) {
tmp = x + (y * ((z / t) - (a / t)));
} else {
tmp = (x + y) - ((z - t) * (y / (a - t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -1.85e+120) or not (t <= 3.4e+16): tmp = x + (y * ((z / t) - (a / t))) else: tmp = (x + y) - ((z - t) * (y / (a - t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -1.85e+120) || !(t <= 3.4e+16)) tmp = Float64(x + Float64(y * Float64(Float64(z / t) - Float64(a / t)))); else tmp = Float64(Float64(x + y) - Float64(Float64(z - t) * Float64(y / Float64(a - t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -1.85e+120) || ~((t <= 3.4e+16))) tmp = x + (y * ((z / t) - (a / t))); else tmp = (x + y) - ((z - t) * (y / (a - t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -1.85e+120], N[Not[LessEqual[t, 3.4e+16]], $MachinePrecision]], N[(x + N[(y * N[(N[(z / t), $MachinePrecision] - N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + y), $MachinePrecision] - N[(N[(z - t), $MachinePrecision] * N[(y / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.85 \cdot 10^{+120} \lor \neg \left(t \leq 3.4 \cdot 10^{+16}\right):\\
\;\;\;\;x + y \cdot \left(\frac{z}{t} - \frac{a}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + y\right) - \left(z - t\right) \cdot \frac{y}{a - t}\\
\end{array}
\end{array}
if t < -1.85000000000000012e120 or 3.4e16 < t Initial program 57.0%
sub-neg57.0%
+-commutative57.0%
distribute-frac-neg57.0%
distribute-rgt-neg-out57.0%
associate-/l*66.1%
fma-define66.2%
distribute-frac-neg66.2%
distribute-neg-frac266.2%
sub-neg66.2%
distribute-neg-in66.2%
remove-double-neg66.2%
+-commutative66.2%
sub-neg66.2%
Simplified66.2%
Taylor expanded in t around inf 67.3%
associate--l+67.3%
associate-+r+78.3%
distribute-rgt1-in78.3%
metadata-eval78.3%
mul0-lft78.3%
associate-/l*84.3%
associate-/l*90.2%
Simplified90.2%
Taylor expanded in y around 0 91.2%
if -1.85000000000000012e120 < t < 3.4e16Initial program 93.5%
associate-/l*93.9%
*-commutative93.9%
Applied egg-rr93.9%
Final simplification92.9%
(FPCore (x y z t a) :precision binary64 (if (or (<= t -5e+119) (not (<= t 920.0))) (+ x (* y (- (/ z t) (/ a t)))) (- (+ x y) (/ (* y (- z t)) (- a t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -5e+119) || !(t <= 920.0)) {
tmp = x + (y * ((z / t) - (a / t)));
} else {
tmp = (x + y) - ((y * (z - t)) / (a - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((t <= (-5d+119)) .or. (.not. (t <= 920.0d0))) then
tmp = x + (y * ((z / t) - (a / t)))
else
tmp = (x + y) - ((y * (z - t)) / (a - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((t <= -5e+119) || !(t <= 920.0)) {
tmp = x + (y * ((z / t) - (a / t)));
} else {
tmp = (x + y) - ((y * (z - t)) / (a - t));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (t <= -5e+119) or not (t <= 920.0): tmp = x + (y * ((z / t) - (a / t))) else: tmp = (x + y) - ((y * (z - t)) / (a - t)) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((t <= -5e+119) || !(t <= 920.0)) tmp = Float64(x + Float64(y * Float64(Float64(z / t) - Float64(a / t)))); else tmp = Float64(Float64(x + y) - Float64(Float64(y * Float64(z - t)) / Float64(a - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((t <= -5e+119) || ~((t <= 920.0))) tmp = x + (y * ((z / t) - (a / t))); else tmp = (x + y) - ((y * (z - t)) / (a - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[t, -5e+119], N[Not[LessEqual[t, 920.0]], $MachinePrecision]], N[(x + N[(y * N[(N[(z / t), $MachinePrecision] - N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + y), $MachinePrecision] - N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5 \cdot 10^{+119} \lor \neg \left(t \leq 920\right):\\
\;\;\;\;x + y \cdot \left(\frac{z}{t} - \frac{a}{t}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x + y\right) - \frac{y \cdot \left(z - t\right)}{a - t}\\
\end{array}
\end{array}
if t < -4.9999999999999999e119 or 920 < t Initial program 57.0%
sub-neg57.0%
+-commutative57.0%
distribute-frac-neg57.0%
distribute-rgt-neg-out57.0%
associate-/l*66.8%
fma-define66.9%
distribute-frac-neg66.9%
distribute-neg-frac266.9%
sub-neg66.9%
distribute-neg-in66.9%
remove-double-neg66.9%
+-commutative66.9%
sub-neg66.9%
Simplified66.9%
Taylor expanded in t around inf 67.1%
associate--l+67.1%
associate-+r+77.9%
distribute-rgt1-in77.9%
metadata-eval77.9%
mul0-lft77.9%
associate-/l*84.6%
associate-/l*90.3%
Simplified90.3%
Taylor expanded in y around 0 91.3%
if -4.9999999999999999e119 < t < 920Initial program 93.9%
Final simplification92.9%
(FPCore (x y z t a)
:precision binary64
(if (<= t -2e+120)
(+ x (* a (- (* y (/ z (* t a))) (/ y t))))
(if (<= t 920.0)
(- (+ x y) (/ (* y (- z t)) (- a t)))
(+ x (* y (- (/ z t) (/ a t)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2e+120) {
tmp = x + (a * ((y * (z / (t * a))) - (y / t)));
} else if (t <= 920.0) {
tmp = (x + y) - ((y * (z - t)) / (a - t));
} else {
tmp = x + (y * ((z / t) - (a / t)));
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= (-2d+120)) then
tmp = x + (a * ((y * (z / (t * a))) - (y / t)))
else if (t <= 920.0d0) then
tmp = (x + y) - ((y * (z - t)) / (a - t))
else
tmp = x + (y * ((z / t) - (a / t)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= -2e+120) {
tmp = x + (a * ((y * (z / (t * a))) - (y / t)));
} else if (t <= 920.0) {
tmp = (x + y) - ((y * (z - t)) / (a - t));
} else {
tmp = x + (y * ((z / t) - (a / t)));
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= -2e+120: tmp = x + (a * ((y * (z / (t * a))) - (y / t))) elif t <= 920.0: tmp = (x + y) - ((y * (z - t)) / (a - t)) else: tmp = x + (y * ((z / t) - (a / t))) return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= -2e+120) tmp = Float64(x + Float64(a * Float64(Float64(y * Float64(z / Float64(t * a))) - Float64(y / t)))); elseif (t <= 920.0) tmp = Float64(Float64(x + y) - Float64(Float64(y * Float64(z - t)) / Float64(a - t))); else tmp = Float64(x + Float64(y * Float64(Float64(z / t) - Float64(a / t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= -2e+120) tmp = x + (a * ((y * (z / (t * a))) - (y / t))); elseif (t <= 920.0) tmp = (x + y) - ((y * (z - t)) / (a - t)); else tmp = x + (y * ((z / t) - (a / t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, -2e+120], N[(x + N[(a * N[(N[(y * N[(z / N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 920.0], N[(N[(x + y), $MachinePrecision] - N[(N[(y * N[(z - t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(y * N[(N[(z / t), $MachinePrecision] - N[(a / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2 \cdot 10^{+120}:\\
\;\;\;\;x + a \cdot \left(y \cdot \frac{z}{t \cdot a} - \frac{y}{t}\right)\\
\mathbf{elif}\;t \leq 920:\\
\;\;\;\;\left(x + y\right) - \frac{y \cdot \left(z - t\right)}{a - t}\\
\mathbf{else}:\\
\;\;\;\;x + y \cdot \left(\frac{z}{t} - \frac{a}{t}\right)\\
\end{array}
\end{array}
if t < -2e120Initial program 63.0%
sub-neg63.0%
+-commutative63.0%
distribute-frac-neg63.0%
distribute-rgt-neg-out63.0%
associate-/l*65.5%
fma-define66.1%
distribute-frac-neg66.1%
distribute-neg-frac266.1%
sub-neg66.1%
distribute-neg-in66.1%
remove-double-neg66.1%
+-commutative66.1%
sub-neg66.1%
Simplified66.1%
Taylor expanded in t around inf 66.4%
associate--l+66.4%
associate-+r+81.7%
distribute-rgt1-in81.7%
metadata-eval81.7%
mul0-lft81.7%
associate-/l*84.9%
associate-/l*92.5%
Simplified92.5%
Taylor expanded in a around inf 86.5%
associate-/l*92.8%
*-commutative92.8%
Simplified92.8%
if -2e120 < t < 920Initial program 93.9%
if 920 < t Initial program 54.0%
sub-neg54.0%
+-commutative54.0%
distribute-frac-neg54.0%
distribute-rgt-neg-out54.0%
associate-/l*67.5%
fma-define67.4%
distribute-frac-neg67.4%
distribute-neg-frac267.4%
sub-neg67.4%
distribute-neg-in67.4%
remove-double-neg67.4%
+-commutative67.4%
sub-neg67.4%
Simplified67.4%
Taylor expanded in t around inf 67.4%
associate--l+67.4%
associate-+r+76.0%
distribute-rgt1-in76.0%
metadata-eval76.0%
mul0-lft76.0%
associate-/l*84.5%
associate-/l*89.2%
Simplified89.2%
Taylor expanded in y around 0 90.7%
Final simplification93.0%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1.8e+82)
(+ x y)
(if (<= a -1.02e-57)
(* y (/ z (- t a)))
(if (<= a 2600000.0) (+ x (* z (/ y t))) (+ x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -1.02e-57) {
tmp = y * (z / (t - a));
} else if (a <= 2600000.0) {
tmp = x + (z * (y / t));
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-1.8d+82)) then
tmp = x + y
else if (a <= (-1.02d-57)) then
tmp = y * (z / (t - a))
else if (a <= 2600000.0d0) then
tmp = x + (z * (y / t))
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1.8e+82) {
tmp = x + y;
} else if (a <= -1.02e-57) {
tmp = y * (z / (t - a));
} else if (a <= 2600000.0) {
tmp = x + (z * (y / t));
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -1.8e+82: tmp = x + y elif a <= -1.02e-57: tmp = y * (z / (t - a)) elif a <= 2600000.0: tmp = x + (z * (y / t)) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1.8e+82) tmp = Float64(x + y); elseif (a <= -1.02e-57) tmp = Float64(y * Float64(z / Float64(t - a))); elseif (a <= 2600000.0) tmp = Float64(x + Float64(z * Float64(y / t))); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -1.8e+82) tmp = x + y; elseif (a <= -1.02e-57) tmp = y * (z / (t - a)); elseif (a <= 2600000.0) tmp = x + (z * (y / t)); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1.8e+82], N[(x + y), $MachinePrecision], If[LessEqual[a, -1.02e-57], N[(y * N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2600000.0], N[(x + N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.8 \cdot 10^{+82}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;a \leq -1.02 \cdot 10^{-57}:\\
\;\;\;\;y \cdot \frac{z}{t - a}\\
\mathbf{elif}\;a \leq 2600000:\\
\;\;\;\;x + z \cdot \frac{y}{t}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -1.80000000000000007e82 or 2.6e6 < a Initial program 81.1%
Taylor expanded in a around inf 78.5%
+-commutative78.5%
Simplified78.5%
if -1.80000000000000007e82 < a < -1.02e-57Initial program 83.8%
sub-neg83.8%
+-commutative83.8%
distribute-frac-neg83.8%
distribute-rgt-neg-out83.8%
associate-/l*89.1%
fma-define89.4%
distribute-frac-neg89.4%
distribute-neg-frac289.4%
sub-neg89.4%
distribute-neg-in89.4%
remove-double-neg89.4%
+-commutative89.4%
sub-neg89.4%
Simplified89.4%
Taylor expanded in z around inf 51.8%
associate-/l*59.5%
Simplified59.5%
if -1.02e-57 < a < 2.6e6Initial program 78.1%
sub-neg78.1%
+-commutative78.1%
distribute-frac-neg78.1%
distribute-rgt-neg-out78.1%
associate-/l*77.4%
fma-define77.6%
distribute-frac-neg77.6%
distribute-neg-frac277.6%
sub-neg77.6%
distribute-neg-in77.6%
remove-double-neg77.6%
+-commutative77.6%
sub-neg77.6%
Simplified77.6%
Taylor expanded in t around inf 70.2%
associate--l+70.2%
associate-+r+79.0%
distribute-rgt1-in79.0%
metadata-eval79.0%
mul0-lft79.0%
associate-/l*78.2%
associate-/l*76.5%
Simplified76.5%
Taylor expanded in z around inf 77.0%
+-commutative77.0%
mul-1-neg77.0%
sub-neg77.0%
*-commutative77.0%
*-commutative77.0%
times-frac76.1%
Simplified76.1%
Taylor expanded in z around inf 78.9%
Final simplification76.0%
(FPCore (x y z t a)
:precision binary64
(if (<= a -3.2e+82)
(+ x y)
(if (<= a -8.5e-81)
(* y (/ z (- t a)))
(if (<= a 236.0) (+ x (/ (* y z) t)) (+ x y)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.2e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = y * (z / (t - a));
} else if (a <= 236.0) {
tmp = x + ((y * z) / t);
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (a <= (-3.2d+82)) then
tmp = x + y
else if (a <= (-8.5d-81)) then
tmp = y * (z / (t - a))
else if (a <= 236.0d0) then
tmp = x + ((y * z) / t)
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -3.2e+82) {
tmp = x + y;
} else if (a <= -8.5e-81) {
tmp = y * (z / (t - a));
} else if (a <= 236.0) {
tmp = x + ((y * z) / t);
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if a <= -3.2e+82: tmp = x + y elif a <= -8.5e-81: tmp = y * (z / (t - a)) elif a <= 236.0: tmp = x + ((y * z) / t) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if (a <= -3.2e+82) tmp = Float64(x + y); elseif (a <= -8.5e-81) tmp = Float64(y * Float64(z / Float64(t - a))); elseif (a <= 236.0) tmp = Float64(x + Float64(Float64(y * z) / t)); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (a <= -3.2e+82) tmp = x + y; elseif (a <= -8.5e-81) tmp = y * (z / (t - a)); elseif (a <= 236.0) tmp = x + ((y * z) / t); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -3.2e+82], N[(x + y), $MachinePrecision], If[LessEqual[a, -8.5e-81], N[(y * N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 236.0], N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.2 \cdot 10^{+82}:\\
\;\;\;\;x + y\\
\mathbf{elif}\;a \leq -8.5 \cdot 10^{-81}:\\
\;\;\;\;y \cdot \frac{z}{t - a}\\
\mathbf{elif}\;a \leq 236:\\
\;\;\;\;x + \frac{y \cdot z}{t}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if a < -3.19999999999999975e82 or 236 < a Initial program 81.1%
Taylor expanded in a around inf 78.5%
+-commutative78.5%
Simplified78.5%
if -3.19999999999999975e82 < a < -8.5000000000000001e-81Initial program 76.6%
sub-neg76.6%
+-commutative76.6%
distribute-frac-neg76.6%
distribute-rgt-neg-out76.6%
associate-/l*81.1%
fma-define81.6%
distribute-frac-neg81.6%
distribute-neg-frac281.6%
sub-neg81.6%
distribute-neg-in81.6%
remove-double-neg81.6%
+-commutative81.6%
sub-neg81.6%
Simplified81.6%
Taylor expanded in z around inf 50.7%
associate-/l*62.1%
Simplified62.1%
if -8.5000000000000001e-81 < a < 236Initial program 80.4%
sub-neg80.4%
+-commutative80.4%
distribute-frac-neg80.4%
distribute-rgt-neg-out80.4%
associate-/l*79.7%
fma-define79.9%
distribute-frac-neg79.9%
distribute-neg-frac279.9%
sub-neg79.9%
distribute-neg-in79.9%
remove-double-neg79.9%
+-commutative79.9%
sub-neg79.9%
Simplified79.9%
Taylor expanded in t around inf 71.4%
associate--l+71.4%
associate-+r+79.7%
distribute-rgt1-in79.7%
metadata-eval79.7%
mul0-lft79.7%
associate-/l*77.2%
associate-/l*75.5%
Simplified75.5%
Taylor expanded in a around 0 79.1%
Final simplification76.2%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -8.8e+120) (not (<= z 2e+108))) (* y (/ z (- t a))) (+ x y)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -8.8e+120) || !(z <= 2e+108)) {
tmp = y * (z / (t - a));
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-8.8d+120)) .or. (.not. (z <= 2d+108))) then
tmp = y * (z / (t - a))
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -8.8e+120) || !(z <= 2e+108)) {
tmp = y * (z / (t - a));
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -8.8e+120) or not (z <= 2e+108): tmp = y * (z / (t - a)) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -8.8e+120) || !(z <= 2e+108)) tmp = Float64(y * Float64(z / Float64(t - a))); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -8.8e+120) || ~((z <= 2e+108))) tmp = y * (z / (t - a)); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -8.8e+120], N[Not[LessEqual[z, 2e+108]], $MachinePrecision]], N[(y * N[(z / N[(t - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8.8 \cdot 10^{+120} \lor \neg \left(z \leq 2 \cdot 10^{+108}\right):\\
\;\;\;\;y \cdot \frac{z}{t - a}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if z < -8.8000000000000005e120 or 2.0000000000000001e108 < z Initial program 83.2%
sub-neg83.2%
+-commutative83.2%
distribute-frac-neg83.2%
distribute-rgt-neg-out83.2%
associate-/l*85.9%
fma-define86.1%
distribute-frac-neg86.1%
distribute-neg-frac286.1%
sub-neg86.1%
distribute-neg-in86.1%
remove-double-neg86.1%
+-commutative86.1%
sub-neg86.1%
Simplified86.1%
Taylor expanded in z around inf 67.1%
associate-/l*72.5%
Simplified72.5%
if -8.8000000000000005e120 < z < 2.0000000000000001e108Initial program 78.9%
Taylor expanded in a around inf 69.5%
+-commutative69.5%
Simplified69.5%
Final simplification70.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.12e+153) (not (<= z 2.4e+207))) (* y (/ z t)) (+ x y)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.12e+153) || !(z <= 2.4e+207)) {
tmp = y * (z / t);
} else {
tmp = x + y;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-1.12d+153)) .or. (.not. (z <= 2.4d+207))) then
tmp = y * (z / t)
else
tmp = x + y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.12e+153) || !(z <= 2.4e+207)) {
tmp = y * (z / t);
} else {
tmp = x + y;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.12e+153) or not (z <= 2.4e+207): tmp = y * (z / t) else: tmp = x + y return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.12e+153) || !(z <= 2.4e+207)) tmp = Float64(y * Float64(z / t)); else tmp = Float64(x + y); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.12e+153) || ~((z <= 2.4e+207))) tmp = y * (z / t); else tmp = x + y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.12e+153], N[Not[LessEqual[z, 2.4e+207]], $MachinePrecision]], N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision], N[(x + y), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.12 \cdot 10^{+153} \lor \neg \left(z \leq 2.4 \cdot 10^{+207}\right):\\
\;\;\;\;y \cdot \frac{z}{t}\\
\mathbf{else}:\\
\;\;\;\;x + y\\
\end{array}
\end{array}
if z < -1.1200000000000001e153 or 2.4000000000000001e207 < z Initial program 81.9%
sub-neg81.9%
+-commutative81.9%
distribute-frac-neg81.9%
distribute-rgt-neg-out81.9%
associate-/l*84.0%
fma-define84.1%
distribute-frac-neg84.1%
distribute-neg-frac284.1%
sub-neg84.1%
distribute-neg-in84.1%
remove-double-neg84.1%
+-commutative84.1%
sub-neg84.1%
Simplified84.1%
Taylor expanded in z around inf 71.7%
Taylor expanded in t around inf 35.4%
associate-*r/41.1%
Simplified41.1%
if -1.1200000000000001e153 < z < 2.4000000000000001e207Initial program 79.6%
Taylor expanded in a around inf 66.1%
+-commutative66.1%
Simplified66.1%
Final simplification61.2%
(FPCore (x y z t a) :precision binary64 (if (<= t 2.2e+76) (+ x y) x))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 2.2e+76) {
tmp = x + y;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (t <= 2.2d+76) then
tmp = x + y
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (t <= 2.2e+76) {
tmp = x + y;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if t <= 2.2e+76: tmp = x + y else: tmp = x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (t <= 2.2e+76) tmp = Float64(x + y); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (t <= 2.2e+76) tmp = x + y; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[t, 2.2e+76], N[(x + y), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 2.2 \cdot 10^{+76}:\\
\;\;\;\;x + y\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if t < 2.2e76Initial program 87.2%
Taylor expanded in a around inf 58.5%
+-commutative58.5%
Simplified58.5%
if 2.2e76 < t Initial program 45.7%
Taylor expanded in x around inf 66.8%
Final simplification59.9%
(FPCore (x y z t a) :precision binary64 x)
double code(double x, double y, double z, double t, double a) {
return x;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x
end function
public static double code(double x, double y, double z, double t, double a) {
return x;
}
def code(x, y, z, t, a): return x
function code(x, y, z, t, a) return x end
function tmp = code(x, y, z, t, a) tmp = x; end
code[x_, y_, z_, t_, a_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 80.1%
Taylor expanded in x around inf 48.2%
Final simplification48.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (+ y x) (* (* (- z t) (/ 1.0 (- a t))) y)))
(t_2 (- (+ x y) (/ (* (- z t) y) (- a t)))))
(if (< t_2 -1.3664970889390727e-7)
t_1
(if (< t_2 1.4754293444577233e-239)
(/ (- (* y (- a z)) (* x t)) (- a t))
t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y + x) - (((z - t) * (1.0 / (a - t))) * y);
double t_2 = (x + y) - (((z - t) * y) / (a - t));
double tmp;
if (t_2 < -1.3664970889390727e-7) {
tmp = t_1;
} else if (t_2 < 1.4754293444577233e-239) {
tmp = ((y * (a - z)) - (x * t)) / (a - t);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (y + x) - (((z - t) * (1.0d0 / (a - t))) * y)
t_2 = (x + y) - (((z - t) * y) / (a - t))
if (t_2 < (-1.3664970889390727d-7)) then
tmp = t_1
else if (t_2 < 1.4754293444577233d-239) then
tmp = ((y * (a - z)) - (x * t)) / (a - t)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (y + x) - (((z - t) * (1.0 / (a - t))) * y);
double t_2 = (x + y) - (((z - t) * y) / (a - t));
double tmp;
if (t_2 < -1.3664970889390727e-7) {
tmp = t_1;
} else if (t_2 < 1.4754293444577233e-239) {
tmp = ((y * (a - z)) - (x * t)) / (a - t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y + x) - (((z - t) * (1.0 / (a - t))) * y) t_2 = (x + y) - (((z - t) * y) / (a - t)) tmp = 0 if t_2 < -1.3664970889390727e-7: tmp = t_1 elif t_2 < 1.4754293444577233e-239: tmp = ((y * (a - z)) - (x * t)) / (a - t) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y + x) - Float64(Float64(Float64(z - t) * Float64(1.0 / Float64(a - t))) * y)) t_2 = Float64(Float64(x + y) - Float64(Float64(Float64(z - t) * y) / Float64(a - t))) tmp = 0.0 if (t_2 < -1.3664970889390727e-7) tmp = t_1; elseif (t_2 < 1.4754293444577233e-239) tmp = Float64(Float64(Float64(y * Float64(a - z)) - Float64(x * t)) / Float64(a - t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y + x) - (((z - t) * (1.0 / (a - t))) * y); t_2 = (x + y) - (((z - t) * y) / (a - t)); tmp = 0.0; if (t_2 < -1.3664970889390727e-7) tmp = t_1; elseif (t_2 < 1.4754293444577233e-239) tmp = ((y * (a - z)) - (x * t)) / (a - t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y + x), $MachinePrecision] - N[(N[(N[(z - t), $MachinePrecision] * N[(1.0 / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x + y), $MachinePrecision] - N[(N[(N[(z - t), $MachinePrecision] * y), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t$95$2, -1.3664970889390727e-7], t$95$1, If[Less[t$95$2, 1.4754293444577233e-239], N[(N[(N[(y * N[(a - z), $MachinePrecision]), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision] / N[(a - t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(y + x\right) - \left(\left(z - t\right) \cdot \frac{1}{a - t}\right) \cdot y\\
t_2 := \left(x + y\right) - \frac{\left(z - t\right) \cdot y}{a - t}\\
\mathbf{if}\;t\_2 < -1.3664970889390727 \cdot 10^{-7}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 < 1.4754293444577233 \cdot 10^{-239}:\\
\;\;\;\;\frac{y \cdot \left(a - z\right) - x \cdot t}{a - t}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
herbie shell --seed 2024130
(FPCore (x y z t a)
:name "Graphics.Rendering.Plot.Render.Plot.Axis:renderAxisTick from plot-0.2.3.4, B"
:precision binary64
:alt
(if (< (- (+ x y) (/ (* (- z t) y) (- a t))) -1.3664970889390727e-7) (- (+ y x) (* (* (- z t) (/ 1.0 (- a t))) y)) (if (< (- (+ x y) (/ (* (- z t) y) (- a t))) 1.4754293444577233e-239) (/ (- (* y (- a z)) (* x t)) (- a t)) (- (+ y x) (* (* (- z t) (/ 1.0 (- a t))) y))))
(- (+ x y) (/ (* (- z t) y) (- a t))))