
(FPCore (x y z t a) :precision binary64 (/ (- x (* y z)) (- t (* a z))))
double code(double x, double y, double z, double t, double a) {
return (x - (y * z)) / (t - (a * z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (x - (y * z)) / (t - (a * z))
end function
public static double code(double x, double y, double z, double t, double a) {
return (x - (y * z)) / (t - (a * z));
}
def code(x, y, z, t, a): return (x - (y * z)) / (t - (a * z))
function code(x, y, z, t, a) return Float64(Float64(x - Float64(y * z)) / Float64(t - Float64(a * z))) end
function tmp = code(x, y, z, t, a) tmp = (x - (y * z)) / (t - (a * z)); end
code[x_, y_, z_, t_, a_] := N[(N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision] / N[(t - N[(a * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - y \cdot z}{t - a \cdot z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (/ (- x (* y z)) (- t (* a z))))
double code(double x, double y, double z, double t, double a) {
return (x - (y * z)) / (t - (a * z));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = (x - (y * z)) / (t - (a * z))
end function
public static double code(double x, double y, double z, double t, double a) {
return (x - (y * z)) / (t - (a * z));
}
def code(x, y, z, t, a): return (x - (y * z)) / (t - (a * z))
function code(x, y, z, t, a) return Float64(Float64(x - Float64(y * z)) / Float64(t - Float64(a * z))) end
function tmp = code(x, y, z, t, a) tmp = (x - (y * z)) / (t - (a * z)); end
code[x_, y_, z_, t_, a_] := N[(N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision] / N[(t - N[(a * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x - y \cdot z}{t - a \cdot z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* z a) t)) (t_2 (- (/ y (/ t_1 z)) (/ x t_1))))
(if (<= z -2e+28)
t_2
(if (<= z 2.95e-37)
(/ (- x (* z y)) (- t (* z a)))
(if (<= z 2.25e+179) t_2 (/ (- y (/ x z)) a))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double t_2 = (y / (t_1 / z)) - (x / t_1);
double tmp;
if (z <= -2e+28) {
tmp = t_2;
} else if (z <= 2.95e-37) {
tmp = (x - (z * y)) / (t - (z * a));
} else if (z <= 2.25e+179) {
tmp = t_2;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (z * a) - t
t_2 = (y / (t_1 / z)) - (x / t_1)
if (z <= (-2d+28)) then
tmp = t_2
else if (z <= 2.95d-37) then
tmp = (x - (z * y)) / (t - (z * a))
else if (z <= 2.25d+179) then
tmp = t_2
else
tmp = (y - (x / z)) / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double t_2 = (y / (t_1 / z)) - (x / t_1);
double tmp;
if (z <= -2e+28) {
tmp = t_2;
} else if (z <= 2.95e-37) {
tmp = (x - (z * y)) / (t - (z * a));
} else if (z <= 2.25e+179) {
tmp = t_2;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * a) - t t_2 = (y / (t_1 / z)) - (x / t_1) tmp = 0 if z <= -2e+28: tmp = t_2 elif z <= 2.95e-37: tmp = (x - (z * y)) / (t - (z * a)) elif z <= 2.25e+179: tmp = t_2 else: tmp = (y - (x / z)) / a return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * a) - t) t_2 = Float64(Float64(y / Float64(t_1 / z)) - Float64(x / t_1)) tmp = 0.0 if (z <= -2e+28) tmp = t_2; elseif (z <= 2.95e-37) tmp = Float64(Float64(x - Float64(z * y)) / Float64(t - Float64(z * a))); elseif (z <= 2.25e+179) tmp = t_2; else tmp = Float64(Float64(y - Float64(x / z)) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * a) - t; t_2 = (y / (t_1 / z)) - (x / t_1); tmp = 0.0; if (z <= -2e+28) tmp = t_2; elseif (z <= 2.95e-37) tmp = (x - (z * y)) / (t - (z * a)); elseif (z <= 2.25e+179) tmp = t_2; else tmp = (y - (x / z)) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / N[(t$95$1 / z), $MachinePrecision]), $MachinePrecision] - N[(x / t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2e+28], t$95$2, If[LessEqual[z, 2.95e-37], N[(N[(x - N[(z * y), $MachinePrecision]), $MachinePrecision] / N[(t - N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.25e+179], t$95$2, N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot a - t\\
t_2 := \frac{y}{\frac{t_1}{z}} - \frac{x}{t_1}\\
\mathbf{if}\;z \leq -2 \cdot 10^{+28}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 2.95 \cdot 10^{-37}:\\
\;\;\;\;\frac{x - z \cdot y}{t - z \cdot a}\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{+179}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\end{array}
\end{array}
if z < -1.99999999999999992e28 or 2.9499999999999998e-37 < z < 2.2500000000000001e179Initial program 76.9%
sub-neg76.9%
+-commutative76.9%
neg-sub076.9%
associate-+l-76.9%
sub0-neg76.9%
neg-mul-176.9%
sub-neg76.9%
+-commutative76.9%
neg-sub076.9%
associate-+l-76.9%
sub0-neg76.9%
neg-mul-176.9%
times-frac76.9%
metadata-eval76.9%
*-lft-identity76.9%
*-commutative76.9%
Simplified76.9%
div-sub76.9%
associate-/l*90.3%
Applied egg-rr90.3%
if -1.99999999999999992e28 < z < 2.9499999999999998e-37Initial program 99.8%
if 2.2500000000000001e179 < z Initial program 49.2%
sub-neg49.2%
+-commutative49.2%
neg-sub049.2%
associate-+l-49.2%
sub0-neg49.2%
neg-mul-149.2%
sub-neg49.2%
+-commutative49.2%
neg-sub049.2%
associate-+l-49.2%
sub0-neg49.2%
neg-mul-149.2%
times-frac49.2%
metadata-eval49.2%
*-lft-identity49.2%
*-commutative49.2%
Simplified49.2%
div-sub49.2%
associate-/l*61.1%
Applied egg-rr61.1%
Taylor expanded in a around inf 94.1%
Final simplification95.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* z a) t)) (t_2 (/ (- y (/ x z)) a)))
(if (<= z -4.5e+169)
t_2
(if (<= z -3.8e+72)
(- (* z (/ y t_1)) (/ x t_1))
(if (<= z 3.4e+98) (/ (- x (* z y)) (- t (* z a))) t_2)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double t_2 = (y - (x / z)) / a;
double tmp;
if (z <= -4.5e+169) {
tmp = t_2;
} else if (z <= -3.8e+72) {
tmp = (z * (y / t_1)) - (x / t_1);
} else if (z <= 3.4e+98) {
tmp = (x - (z * y)) / (t - (z * a));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (z * a) - t
t_2 = (y - (x / z)) / a
if (z <= (-4.5d+169)) then
tmp = t_2
else if (z <= (-3.8d+72)) then
tmp = (z * (y / t_1)) - (x / t_1)
else if (z <= 3.4d+98) then
tmp = (x - (z * y)) / (t - (z * a))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double t_2 = (y - (x / z)) / a;
double tmp;
if (z <= -4.5e+169) {
tmp = t_2;
} else if (z <= -3.8e+72) {
tmp = (z * (y / t_1)) - (x / t_1);
} else if (z <= 3.4e+98) {
tmp = (x - (z * y)) / (t - (z * a));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * a) - t t_2 = (y - (x / z)) / a tmp = 0 if z <= -4.5e+169: tmp = t_2 elif z <= -3.8e+72: tmp = (z * (y / t_1)) - (x / t_1) elif z <= 3.4e+98: tmp = (x - (z * y)) / (t - (z * a)) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * a) - t) t_2 = Float64(Float64(y - Float64(x / z)) / a) tmp = 0.0 if (z <= -4.5e+169) tmp = t_2; elseif (z <= -3.8e+72) tmp = Float64(Float64(z * Float64(y / t_1)) - Float64(x / t_1)); elseif (z <= 3.4e+98) tmp = Float64(Float64(x - Float64(z * y)) / Float64(t - Float64(z * a))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * a) - t; t_2 = (y - (x / z)) / a; tmp = 0.0; if (z <= -4.5e+169) tmp = t_2; elseif (z <= -3.8e+72) tmp = (z * (y / t_1)) - (x / t_1); elseif (z <= 3.4e+98) tmp = (x - (z * y)) / (t - (z * a)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[z, -4.5e+169], t$95$2, If[LessEqual[z, -3.8e+72], N[(N[(z * N[(y / t$95$1), $MachinePrecision]), $MachinePrecision] - N[(x / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.4e+98], N[(N[(x - N[(z * y), $MachinePrecision]), $MachinePrecision] / N[(t - N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot a - t\\
t_2 := \frac{y - \frac{x}{z}}{a}\\
\mathbf{if}\;z \leq -4.5 \cdot 10^{+169}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{+72}:\\
\;\;\;\;z \cdot \frac{y}{t_1} - \frac{x}{t_1}\\
\mathbf{elif}\;z \leq 3.4 \cdot 10^{+98}:\\
\;\;\;\;\frac{x - z \cdot y}{t - z \cdot a}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -4.5e169 or 3.39999999999999972e98 < z Initial program 55.6%
sub-neg55.6%
+-commutative55.6%
neg-sub055.6%
associate-+l-55.6%
sub0-neg55.6%
neg-mul-155.6%
sub-neg55.6%
+-commutative55.6%
neg-sub055.6%
associate-+l-55.6%
sub0-neg55.6%
neg-mul-155.6%
times-frac55.6%
metadata-eval55.6%
*-lft-identity55.6%
*-commutative55.6%
Simplified55.6%
div-sub55.6%
associate-/l*69.8%
Applied egg-rr69.8%
Taylor expanded in a around inf 85.8%
if -4.5e169 < z < -3.80000000000000006e72Initial program 63.9%
sub-neg63.9%
+-commutative63.9%
neg-sub063.9%
associate-+l-63.9%
sub0-neg63.9%
neg-mul-163.9%
sub-neg63.9%
+-commutative63.9%
neg-sub063.9%
associate-+l-63.9%
sub0-neg63.9%
neg-mul-163.9%
times-frac63.9%
metadata-eval63.9%
*-lft-identity63.9%
*-commutative63.9%
Simplified63.9%
div-sub64.1%
associate-/l*90.9%
Applied egg-rr90.9%
associate-/r/86.3%
Applied egg-rr86.3%
if -3.80000000000000006e72 < z < 3.39999999999999972e98Initial program 98.7%
Final simplification94.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.55e+169)
(/ y a)
(if (<= z -6.5e+19)
(* (- y) (/ z t))
(if (<= z -2.45e-23)
(/ y a)
(if (<= z 3.95e-60)
(/ x t)
(if (<= z 3.2e+56) (/ -1.0 (* a (/ z x))) (/ y a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -6.5e+19) {
tmp = -y * (z / t);
} else if (z <= -2.45e-23) {
tmp = y / a;
} else if (z <= 3.95e-60) {
tmp = x / t;
} else if (z <= 3.2e+56) {
tmp = -1.0 / (a * (z / x));
} else {
tmp = y / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.55d+169)) then
tmp = y / a
else if (z <= (-6.5d+19)) then
tmp = -y * (z / t)
else if (z <= (-2.45d-23)) then
tmp = y / a
else if (z <= 3.95d-60) then
tmp = x / t
else if (z <= 3.2d+56) then
tmp = (-1.0d0) / (a * (z / x))
else
tmp = y / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -6.5e+19) {
tmp = -y * (z / t);
} else if (z <= -2.45e-23) {
tmp = y / a;
} else if (z <= 3.95e-60) {
tmp = x / t;
} else if (z <= 3.2e+56) {
tmp = -1.0 / (a * (z / x));
} else {
tmp = y / a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.55e+169: tmp = y / a elif z <= -6.5e+19: tmp = -y * (z / t) elif z <= -2.45e-23: tmp = y / a elif z <= 3.95e-60: tmp = x / t elif z <= 3.2e+56: tmp = -1.0 / (a * (z / x)) else: tmp = y / a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.55e+169) tmp = Float64(y / a); elseif (z <= -6.5e+19) tmp = Float64(Float64(-y) * Float64(z / t)); elseif (z <= -2.45e-23) tmp = Float64(y / a); elseif (z <= 3.95e-60) tmp = Float64(x / t); elseif (z <= 3.2e+56) tmp = Float64(-1.0 / Float64(a * Float64(z / x))); else tmp = Float64(y / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.55e+169) tmp = y / a; elseif (z <= -6.5e+19) tmp = -y * (z / t); elseif (z <= -2.45e-23) tmp = y / a; elseif (z <= 3.95e-60) tmp = x / t; elseif (z <= 3.2e+56) tmp = -1.0 / (a * (z / x)); else tmp = y / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.55e+169], N[(y / a), $MachinePrecision], If[LessEqual[z, -6.5e+19], N[((-y) * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.45e-23], N[(y / a), $MachinePrecision], If[LessEqual[z, 3.95e-60], N[(x / t), $MachinePrecision], If[LessEqual[z, 3.2e+56], N[(-1.0 / N[(a * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y / a), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.55 \cdot 10^{+169}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq -6.5 \cdot 10^{+19}:\\
\;\;\;\;\left(-y\right) \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -2.45 \cdot 10^{-23}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq 3.95 \cdot 10^{-60}:\\
\;\;\;\;\frac{x}{t}\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+56}:\\
\;\;\;\;\frac{-1}{a \cdot \frac{z}{x}}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a}\\
\end{array}
\end{array}
if z < -2.55000000000000004e169 or -6.5e19 < z < -2.4499999999999999e-23 or 3.20000000000000003e56 < z Initial program 65.0%
sub-neg65.0%
+-commutative65.0%
neg-sub065.0%
associate-+l-65.0%
sub0-neg65.0%
neg-mul-165.0%
sub-neg65.0%
+-commutative65.0%
neg-sub065.0%
associate-+l-65.0%
sub0-neg65.0%
neg-mul-165.0%
times-frac65.0%
metadata-eval65.0%
*-lft-identity65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in z around inf 65.6%
if -2.55000000000000004e169 < z < -6.5e19Initial program 75.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
times-frac75.5%
metadata-eval75.5%
*-lft-identity75.5%
*-commutative75.5%
Simplified75.5%
Taylor expanded in y around inf 44.3%
*-commutative44.3%
associate-*r/62.4%
*-commutative62.4%
Simplified62.4%
Taylor expanded in z around 0 41.2%
associate-*r/41.2%
mul-1-neg41.2%
Simplified41.2%
if -2.4499999999999999e-23 < z < 3.95000000000000004e-60Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around 0 61.8%
if 3.95000000000000004e-60 < z < 3.20000000000000003e56Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around inf 58.2%
mul-1-neg58.2%
+-commutative58.2%
associate--l+58.2%
associate-/r*58.2%
distribute-neg-frac58.2%
mul-1-neg58.2%
associate-/r*58.2%
associate-*r/58.2%
div-sub58.2%
distribute-lft-out--58.2%
associate-*r/58.2%
Simplified62.0%
Taylor expanded in y around 0 52.1%
mul-1-neg52.1%
associate-/r*52.0%
distribute-frac-neg52.0%
mul-1-neg52.0%
associate-*r/52.0%
mul-1-neg52.0%
Simplified52.0%
associate-/l/52.1%
neg-mul-152.1%
*-commutative52.1%
times-frac51.9%
Applied egg-rr51.9%
*-commutative51.9%
clear-num51.8%
frac-times53.2%
metadata-eval53.2%
Applied egg-rr53.2%
Final simplification59.8%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.55e+169)
(/ y a)
(if (<= z -3.6e+17)
(* (- y) (/ z t))
(if (<= z -1.3e-25)
(/ y a)
(if (<= z 2.5e-60)
(/ x t)
(if (<= z 1e+57) (/ (- x) (* z a)) (/ y a)))))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -3.6e+17) {
tmp = -y * (z / t);
} else if (z <= -1.3e-25) {
tmp = y / a;
} else if (z <= 2.5e-60) {
tmp = x / t;
} else if (z <= 1e+57) {
tmp = -x / (z * a);
} else {
tmp = y / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.55d+169)) then
tmp = y / a
else if (z <= (-3.6d+17)) then
tmp = -y * (z / t)
else if (z <= (-1.3d-25)) then
tmp = y / a
else if (z <= 2.5d-60) then
tmp = x / t
else if (z <= 1d+57) then
tmp = -x / (z * a)
else
tmp = y / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -3.6e+17) {
tmp = -y * (z / t);
} else if (z <= -1.3e-25) {
tmp = y / a;
} else if (z <= 2.5e-60) {
tmp = x / t;
} else if (z <= 1e+57) {
tmp = -x / (z * a);
} else {
tmp = y / a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.55e+169: tmp = y / a elif z <= -3.6e+17: tmp = -y * (z / t) elif z <= -1.3e-25: tmp = y / a elif z <= 2.5e-60: tmp = x / t elif z <= 1e+57: tmp = -x / (z * a) else: tmp = y / a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.55e+169) tmp = Float64(y / a); elseif (z <= -3.6e+17) tmp = Float64(Float64(-y) * Float64(z / t)); elseif (z <= -1.3e-25) tmp = Float64(y / a); elseif (z <= 2.5e-60) tmp = Float64(x / t); elseif (z <= 1e+57) tmp = Float64(Float64(-x) / Float64(z * a)); else tmp = Float64(y / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.55e+169) tmp = y / a; elseif (z <= -3.6e+17) tmp = -y * (z / t); elseif (z <= -1.3e-25) tmp = y / a; elseif (z <= 2.5e-60) tmp = x / t; elseif (z <= 1e+57) tmp = -x / (z * a); else tmp = y / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.55e+169], N[(y / a), $MachinePrecision], If[LessEqual[z, -3.6e+17], N[((-y) * N[(z / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.3e-25], N[(y / a), $MachinePrecision], If[LessEqual[z, 2.5e-60], N[(x / t), $MachinePrecision], If[LessEqual[z, 1e+57], N[((-x) / N[(z * a), $MachinePrecision]), $MachinePrecision], N[(y / a), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.55 \cdot 10^{+169}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq -3.6 \cdot 10^{+17}:\\
\;\;\;\;\left(-y\right) \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-25}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{-60}:\\
\;\;\;\;\frac{x}{t}\\
\mathbf{elif}\;z \leq 10^{+57}:\\
\;\;\;\;\frac{-x}{z \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a}\\
\end{array}
\end{array}
if z < -2.55000000000000004e169 or -3.6e17 < z < -1.3e-25 or 1.00000000000000005e57 < z Initial program 65.0%
sub-neg65.0%
+-commutative65.0%
neg-sub065.0%
associate-+l-65.0%
sub0-neg65.0%
neg-mul-165.0%
sub-neg65.0%
+-commutative65.0%
neg-sub065.0%
associate-+l-65.0%
sub0-neg65.0%
neg-mul-165.0%
times-frac65.0%
metadata-eval65.0%
*-lft-identity65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in z around inf 65.6%
if -2.55000000000000004e169 < z < -3.6e17Initial program 75.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
times-frac75.5%
metadata-eval75.5%
*-lft-identity75.5%
*-commutative75.5%
Simplified75.5%
Taylor expanded in y around inf 44.3%
*-commutative44.3%
associate-*r/62.4%
*-commutative62.4%
Simplified62.4%
Taylor expanded in z around 0 41.2%
associate-*r/41.2%
mul-1-neg41.2%
Simplified41.2%
if -1.3e-25 < z < 2.5000000000000001e-60Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around 0 61.8%
if 2.5000000000000001e-60 < z < 1.00000000000000005e57Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around inf 58.2%
mul-1-neg58.2%
+-commutative58.2%
associate--l+58.2%
associate-/r*58.2%
distribute-neg-frac58.2%
mul-1-neg58.2%
associate-/r*58.2%
associate-*r/58.2%
div-sub58.2%
distribute-lft-out--58.2%
associate-*r/58.2%
Simplified62.0%
Taylor expanded in y around 0 52.1%
associate-*r/52.1%
mul-1-neg52.1%
*-commutative52.1%
Simplified52.1%
Final simplification59.7%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- y (/ x z)) a)))
(if (<= z -1.3e+60)
t_1
(if (<= z -4.4e-150)
(/ (- (* z y) x) (- t))
(if (<= z 1.2e+55) (/ (- x) (- (* z a) t)) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (y - (x / z)) / a;
double tmp;
if (z <= -1.3e+60) {
tmp = t_1;
} else if (z <= -4.4e-150) {
tmp = ((z * y) - x) / -t;
} else if (z <= 1.2e+55) {
tmp = -x / ((z * 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) :: tmp
t_1 = (y - (x / z)) / a
if (z <= (-1.3d+60)) then
tmp = t_1
else if (z <= (-4.4d-150)) then
tmp = ((z * y) - x) / -t
else if (z <= 1.2d+55) then
tmp = -x / ((z * 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)) / a;
double tmp;
if (z <= -1.3e+60) {
tmp = t_1;
} else if (z <= -4.4e-150) {
tmp = ((z * y) - x) / -t;
} else if (z <= 1.2e+55) {
tmp = -x / ((z * a) - t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (y - (x / z)) / a tmp = 0 if z <= -1.3e+60: tmp = t_1 elif z <= -4.4e-150: tmp = ((z * y) - x) / -t elif z <= 1.2e+55: tmp = -x / ((z * a) - t) else: tmp = t_1 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(y - Float64(x / z)) / a) tmp = 0.0 if (z <= -1.3e+60) tmp = t_1; elseif (z <= -4.4e-150) tmp = Float64(Float64(Float64(z * y) - x) / Float64(-t)); elseif (z <= 1.2e+55) tmp = Float64(Float64(-x) / Float64(Float64(z * a) - t)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (y - (x / z)) / a; tmp = 0.0; if (z <= -1.3e+60) tmp = t_1; elseif (z <= -4.4e-150) tmp = ((z * y) - x) / -t; elseif (z <= 1.2e+55) tmp = -x / ((z * a) - t); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[z, -1.3e+60], t$95$1, If[LessEqual[z, -4.4e-150], N[(N[(N[(z * y), $MachinePrecision] - x), $MachinePrecision] / (-t)), $MachinePrecision], If[LessEqual[z, 1.2e+55], N[((-x) / N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y - \frac{x}{z}}{a}\\
\mathbf{if}\;z \leq -1.3 \cdot 10^{+60}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -4.4 \cdot 10^{-150}:\\
\;\;\;\;\frac{z \cdot y - x}{-t}\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{+55}:\\
\;\;\;\;\frac{-x}{z \cdot a - t}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.30000000000000004e60 or 1.2e55 < z Initial program 62.1%
sub-neg62.1%
+-commutative62.1%
neg-sub062.1%
associate-+l-62.1%
sub0-neg62.1%
neg-mul-162.1%
sub-neg62.1%
+-commutative62.1%
neg-sub062.1%
associate-+l-62.1%
sub0-neg62.1%
neg-mul-162.1%
times-frac62.1%
metadata-eval62.1%
*-lft-identity62.1%
*-commutative62.1%
Simplified62.1%
div-sub62.2%
associate-/l*78.5%
Applied egg-rr78.5%
Taylor expanded in a around inf 74.8%
if -1.30000000000000004e60 < z < -4.3999999999999999e-150Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
times-frac99.9%
metadata-eval99.9%
*-lft-identity99.9%
*-commutative99.9%
Simplified99.9%
Taylor expanded in z around 0 72.1%
neg-mul-172.1%
Simplified72.1%
if -4.3999999999999999e-150 < z < 1.2e55Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in y around 0 80.2%
associate-*r/80.2%
neg-mul-180.2%
Simplified80.2%
Final simplification76.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* z a) t)))
(if (<= z -1.05e-13)
(* y (/ z t_1))
(if (<= z -1.4e-155)
(/ (- (* z y) x) (- t))
(if (<= z 9.5e+55) (/ (- x) t_1) (/ (- y (/ x z)) a))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double tmp;
if (z <= -1.05e-13) {
tmp = y * (z / t_1);
} else if (z <= -1.4e-155) {
tmp = ((z * y) - x) / -t;
} else if (z <= 9.5e+55) {
tmp = -x / t_1;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (z * a) - t
if (z <= (-1.05d-13)) then
tmp = y * (z / t_1)
else if (z <= (-1.4d-155)) then
tmp = ((z * y) - x) / -t
else if (z <= 9.5d+55) then
tmp = -x / t_1
else
tmp = (y - (x / z)) / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double tmp;
if (z <= -1.05e-13) {
tmp = y * (z / t_1);
} else if (z <= -1.4e-155) {
tmp = ((z * y) - x) / -t;
} else if (z <= 9.5e+55) {
tmp = -x / t_1;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * a) - t tmp = 0 if z <= -1.05e-13: tmp = y * (z / t_1) elif z <= -1.4e-155: tmp = ((z * y) - x) / -t elif z <= 9.5e+55: tmp = -x / t_1 else: tmp = (y - (x / z)) / a return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * a) - t) tmp = 0.0 if (z <= -1.05e-13) tmp = Float64(y * Float64(z / t_1)); elseif (z <= -1.4e-155) tmp = Float64(Float64(Float64(z * y) - x) / Float64(-t)); elseif (z <= 9.5e+55) tmp = Float64(Float64(-x) / t_1); else tmp = Float64(Float64(y - Float64(x / z)) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * a) - t; tmp = 0.0; if (z <= -1.05e-13) tmp = y * (z / t_1); elseif (z <= -1.4e-155) tmp = ((z * y) - x) / -t; elseif (z <= 9.5e+55) tmp = -x / t_1; else tmp = (y - (x / z)) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]}, If[LessEqual[z, -1.05e-13], N[(y * N[(z / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.4e-155], N[(N[(N[(z * y), $MachinePrecision] - x), $MachinePrecision] / (-t)), $MachinePrecision], If[LessEqual[z, 9.5e+55], N[((-x) / t$95$1), $MachinePrecision], N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot a - t\\
\mathbf{if}\;z \leq -1.05 \cdot 10^{-13}:\\
\;\;\;\;y \cdot \frac{z}{t_1}\\
\mathbf{elif}\;z \leq -1.4 \cdot 10^{-155}:\\
\;\;\;\;\frac{z \cdot y - x}{-t}\\
\mathbf{elif}\;z \leq 9.5 \cdot 10^{+55}:\\
\;\;\;\;\frac{-x}{t_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\end{array}
\end{array}
if z < -1.04999999999999994e-13Initial program 76.3%
sub-neg76.3%
+-commutative76.3%
neg-sub076.3%
associate-+l-76.3%
sub0-neg76.3%
neg-mul-176.3%
sub-neg76.3%
+-commutative76.3%
neg-sub076.3%
associate-+l-76.3%
sub0-neg76.3%
neg-mul-176.3%
times-frac76.3%
metadata-eval76.3%
*-lft-identity76.3%
*-commutative76.3%
Simplified76.3%
Taylor expanded in y around inf 55.1%
*-commutative55.1%
associate-*r/67.5%
*-commutative67.5%
Simplified67.5%
if -1.04999999999999994e-13 < z < -1.4e-155Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
times-frac99.9%
metadata-eval99.9%
*-lft-identity99.9%
*-commutative99.9%
Simplified99.9%
Taylor expanded in z around 0 83.0%
neg-mul-183.0%
Simplified83.0%
if -1.4e-155 < z < 9.49999999999999989e55Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in y around 0 80.2%
associate-*r/80.2%
neg-mul-180.2%
Simplified80.2%
if 9.49999999999999989e55 < z Initial program 59.5%
sub-neg59.5%
+-commutative59.5%
neg-sub059.5%
associate-+l-59.5%
sub0-neg59.5%
neg-mul-159.5%
sub-neg59.5%
+-commutative59.5%
neg-sub059.5%
associate-+l-59.5%
sub0-neg59.5%
neg-mul-159.5%
times-frac59.5%
metadata-eval59.5%
*-lft-identity59.5%
*-commutative59.5%
Simplified59.5%
div-sub59.5%
associate-/l*74.7%
Applied egg-rr74.7%
Taylor expanded in a around inf 80.3%
Final simplification77.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- (* z a) t)))
(if (<= z -4.9e-26)
(/ y (/ t_1 z))
(if (<= z -7.8e-156)
(/ (- (* z y) x) (- t))
(if (<= z 1.1e+57) (/ (- x) t_1) (/ (- y (/ x z)) a))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double tmp;
if (z <= -4.9e-26) {
tmp = y / (t_1 / z);
} else if (z <= -7.8e-156) {
tmp = ((z * y) - x) / -t;
} else if (z <= 1.1e+57) {
tmp = -x / t_1;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: tmp
t_1 = (z * a) - t
if (z <= (-4.9d-26)) then
tmp = y / (t_1 / z)
else if (z <= (-7.8d-156)) then
tmp = ((z * y) - x) / -t
else if (z <= 1.1d+57) then
tmp = -x / t_1
else
tmp = (y - (x / z)) / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (z * a) - t;
double tmp;
if (z <= -4.9e-26) {
tmp = y / (t_1 / z);
} else if (z <= -7.8e-156) {
tmp = ((z * y) - x) / -t;
} else if (z <= 1.1e+57) {
tmp = -x / t_1;
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z * a) - t tmp = 0 if z <= -4.9e-26: tmp = y / (t_1 / z) elif z <= -7.8e-156: tmp = ((z * y) - x) / -t elif z <= 1.1e+57: tmp = -x / t_1 else: tmp = (y - (x / z)) / a return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z * a) - t) tmp = 0.0 if (z <= -4.9e-26) tmp = Float64(y / Float64(t_1 / z)); elseif (z <= -7.8e-156) tmp = Float64(Float64(Float64(z * y) - x) / Float64(-t)); elseif (z <= 1.1e+57) tmp = Float64(Float64(-x) / t_1); else tmp = Float64(Float64(y - Float64(x / z)) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (z * a) - t; tmp = 0.0; if (z <= -4.9e-26) tmp = y / (t_1 / z); elseif (z <= -7.8e-156) tmp = ((z * y) - x) / -t; elseif (z <= 1.1e+57) tmp = -x / t_1; else tmp = (y - (x / z)) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]}, If[LessEqual[z, -4.9e-26], N[(y / N[(t$95$1 / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -7.8e-156], N[(N[(N[(z * y), $MachinePrecision] - x), $MachinePrecision] / (-t)), $MachinePrecision], If[LessEqual[z, 1.1e+57], N[((-x) / t$95$1), $MachinePrecision], N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot a - t\\
\mathbf{if}\;z \leq -4.9 \cdot 10^{-26}:\\
\;\;\;\;\frac{y}{\frac{t_1}{z}}\\
\mathbf{elif}\;z \leq -7.8 \cdot 10^{-156}:\\
\;\;\;\;\frac{z \cdot y - x}{-t}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+57}:\\
\;\;\;\;\frac{-x}{t_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\end{array}
\end{array}
if z < -4.8999999999999999e-26Initial program 76.3%
sub-neg76.3%
+-commutative76.3%
neg-sub076.3%
associate-+l-76.3%
sub0-neg76.3%
neg-mul-176.3%
sub-neg76.3%
+-commutative76.3%
neg-sub076.3%
associate-+l-76.3%
sub0-neg76.3%
neg-mul-176.3%
times-frac76.3%
metadata-eval76.3%
*-lft-identity76.3%
*-commutative76.3%
Simplified76.3%
Taylor expanded in y around inf 55.1%
*-commutative55.1%
associate-*r/67.5%
*-commutative67.5%
Simplified67.5%
clear-num67.6%
*-commutative67.6%
div-inv67.8%
Applied egg-rr67.8%
if -4.8999999999999999e-26 < z < -7.8000000000000002e-156Initial program 99.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
sub-neg99.9%
+-commutative99.9%
neg-sub099.9%
associate-+l-99.9%
sub0-neg99.9%
neg-mul-199.9%
times-frac99.9%
metadata-eval99.9%
*-lft-identity99.9%
*-commutative99.9%
Simplified99.9%
Taylor expanded in z around 0 83.0%
neg-mul-183.0%
Simplified83.0%
if -7.8000000000000002e-156 < z < 1.1e57Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in y around 0 80.2%
associate-*r/80.2%
neg-mul-180.2%
Simplified80.2%
if 1.1e57 < z Initial program 59.5%
sub-neg59.5%
+-commutative59.5%
neg-sub059.5%
associate-+l-59.5%
sub0-neg59.5%
neg-mul-159.5%
sub-neg59.5%
+-commutative59.5%
neg-sub059.5%
associate-+l-59.5%
sub0-neg59.5%
neg-mul-159.5%
times-frac59.5%
metadata-eval59.5%
*-lft-identity59.5%
*-commutative59.5%
Simplified59.5%
div-sub59.5%
associate-/l*74.7%
Applied egg-rr74.7%
Taylor expanded in a around inf 80.3%
Final simplification77.6%
(FPCore (x y z t a) :precision binary64 (if (<= z 2.5e+98) (/ (- x (* z y)) (- t (* z a))) (/ (- y (/ x z)) a)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= 2.5e+98) {
tmp = (x - (z * y)) / (t - (z * a));
} else {
tmp = (y - (x / 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 <= 2.5d+98) then
tmp = (x - (z * y)) / (t - (z * a))
else
tmp = (y - (x / 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 <= 2.5e+98) {
tmp = (x - (z * y)) / (t - (z * a));
} else {
tmp = (y - (x / z)) / a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= 2.5e+98: tmp = (x - (z * y)) / (t - (z * a)) else: tmp = (y - (x / z)) / a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= 2.5e+98) tmp = Float64(Float64(x - Float64(z * y)) / Float64(t - Float64(z * a))); else tmp = Float64(Float64(y - Float64(x / z)) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= 2.5e+98) tmp = (x - (z * y)) / (t - (z * a)); else tmp = (y - (x / z)) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, 2.5e+98], N[(N[(x - N[(z * y), $MachinePrecision]), $MachinePrecision] / N[(t - N[(z * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 2.5 \cdot 10^{+98}:\\
\;\;\;\;\frac{x - z \cdot y}{t - z \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\end{array}
\end{array}
if z < 2.4999999999999999e98Initial program 92.0%
if 2.4999999999999999e98 < z Initial program 52.9%
sub-neg52.9%
+-commutative52.9%
neg-sub052.9%
associate-+l-52.9%
sub0-neg52.9%
neg-mul-152.9%
sub-neg52.9%
+-commutative52.9%
neg-sub052.9%
associate-+l-52.9%
sub0-neg52.9%
neg-mul-152.9%
times-frac52.9%
metadata-eval52.9%
*-lft-identity52.9%
*-commutative52.9%
Simplified52.9%
div-sub52.9%
associate-/l*68.3%
Applied egg-rr68.3%
Taylor expanded in a around inf 88.4%
Final simplification91.3%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -1.95e-16) (not (<= z 1.45e+55))) (/ (- y (/ x z)) a) (/ (- x) (- (* z a) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -1.95e-16) || !(z <= 1.45e+55)) {
tmp = (y - (x / z)) / a;
} else {
tmp = -x / ((z * 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 ((z <= (-1.95d-16)) .or. (.not. (z <= 1.45d+55))) then
tmp = (y - (x / z)) / a
else
tmp = -x / ((z * 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 ((z <= -1.95e-16) || !(z <= 1.45e+55)) {
tmp = (y - (x / z)) / a;
} else {
tmp = -x / ((z * a) - t);
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -1.95e-16) or not (z <= 1.45e+55): tmp = (y - (x / z)) / a else: tmp = -x / ((z * a) - t) return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -1.95e-16) || !(z <= 1.45e+55)) tmp = Float64(Float64(y - Float64(x / z)) / a); else tmp = Float64(Float64(-x) / Float64(Float64(z * a) - t)); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -1.95e-16) || ~((z <= 1.45e+55))) tmp = (y - (x / z)) / a; else tmp = -x / ((z * a) - t); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -1.95e-16], N[Not[LessEqual[z, 1.45e+55]], $MachinePrecision]], N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[((-x) / N[(N[(z * a), $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.95 \cdot 10^{-16} \lor \neg \left(z \leq 1.45 \cdot 10^{+55}\right):\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{-x}{z \cdot a - t}\\
\end{array}
\end{array}
if z < -1.94999999999999989e-16 or 1.4499999999999999e55 < z Initial program 67.6%
sub-neg67.6%
+-commutative67.6%
neg-sub067.6%
associate-+l-67.6%
sub0-neg67.6%
neg-mul-167.6%
sub-neg67.6%
+-commutative67.6%
neg-sub067.6%
associate-+l-67.6%
sub0-neg67.6%
neg-mul-167.6%
times-frac67.6%
metadata-eval67.6%
*-lft-identity67.6%
*-commutative67.6%
Simplified67.6%
div-sub67.6%
associate-/l*81.6%
Applied egg-rr81.6%
Taylor expanded in a around inf 71.5%
if -1.94999999999999989e-16 < z < 1.4499999999999999e55Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in y around 0 77.1%
associate-*r/77.1%
neg-mul-177.1%
Simplified77.1%
Final simplification74.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2.55e+169)
(/ y a)
(if (<= z -2.7e+20)
(* (- y) (/ z t))
(if (or (<= z -2.7e-23) (not (<= z 2.45e-48))) (/ y a) (/ x t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -2.7e+20) {
tmp = -y * (z / t);
} else if ((z <= -2.7e-23) || !(z <= 2.45e-48)) {
tmp = y / a;
} else {
tmp = x / t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2.55d+169)) then
tmp = y / a
else if (z <= (-2.7d+20)) then
tmp = -y * (z / t)
else if ((z <= (-2.7d-23)) .or. (.not. (z <= 2.45d-48))) then
tmp = y / a
else
tmp = x / t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.55e+169) {
tmp = y / a;
} else if (z <= -2.7e+20) {
tmp = -y * (z / t);
} else if ((z <= -2.7e-23) || !(z <= 2.45e-48)) {
tmp = y / a;
} else {
tmp = x / t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2.55e+169: tmp = y / a elif z <= -2.7e+20: tmp = -y * (z / t) elif (z <= -2.7e-23) or not (z <= 2.45e-48): tmp = y / a else: tmp = x / t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.55e+169) tmp = Float64(y / a); elseif (z <= -2.7e+20) tmp = Float64(Float64(-y) * Float64(z / t)); elseif ((z <= -2.7e-23) || !(z <= 2.45e-48)) tmp = Float64(y / a); else tmp = Float64(x / t); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2.55e+169) tmp = y / a; elseif (z <= -2.7e+20) tmp = -y * (z / t); elseif ((z <= -2.7e-23) || ~((z <= 2.45e-48))) tmp = y / a; else tmp = x / t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.55e+169], N[(y / a), $MachinePrecision], If[LessEqual[z, -2.7e+20], N[((-y) * N[(z / t), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -2.7e-23], N[Not[LessEqual[z, 2.45e-48]], $MachinePrecision]], N[(y / a), $MachinePrecision], N[(x / t), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.55 \cdot 10^{+169}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{+20}:\\
\;\;\;\;\left(-y\right) \cdot \frac{z}{t}\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-23} \lor \neg \left(z \leq 2.45 \cdot 10^{-48}\right):\\
\;\;\;\;\frac{y}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{t}\\
\end{array}
\end{array}
if z < -2.55000000000000004e169 or -2.7e20 < z < -2.69999999999999985e-23 or 2.4500000000000001e-48 < z Initial program 71.9%
sub-neg71.9%
+-commutative71.9%
neg-sub071.9%
associate-+l-71.9%
sub0-neg71.9%
neg-mul-171.9%
sub-neg71.9%
+-commutative71.9%
neg-sub071.9%
associate-+l-71.9%
sub0-neg71.9%
neg-mul-171.9%
times-frac71.9%
metadata-eval71.9%
*-lft-identity71.9%
*-commutative71.9%
Simplified71.9%
Taylor expanded in z around inf 57.4%
if -2.55000000000000004e169 < z < -2.7e20Initial program 75.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
sub-neg75.5%
+-commutative75.5%
neg-sub075.5%
associate-+l-75.5%
sub0-neg75.5%
neg-mul-175.5%
times-frac75.5%
metadata-eval75.5%
*-lft-identity75.5%
*-commutative75.5%
Simplified75.5%
Taylor expanded in y around inf 44.3%
*-commutative44.3%
associate-*r/62.4%
*-commutative62.4%
Simplified62.4%
Taylor expanded in z around 0 41.2%
associate-*r/41.2%
mul-1-neg41.2%
Simplified41.2%
if -2.69999999999999985e-23 < z < 2.4500000000000001e-48Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around 0 61.0%
Final simplification57.0%
(FPCore (x y z t a) :precision binary64 (if (or (<= z -3.5e-32) (not (<= z 5.8e-61))) (/ (- y (/ x z)) a) (/ x t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.5e-32) || !(z <= 5.8e-61)) {
tmp = (y - (x / z)) / a;
} else {
tmp = x / t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((z <= (-3.5d-32)) .or. (.not. (z <= 5.8d-61))) then
tmp = (y - (x / z)) / a
else
tmp = x / t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((z <= -3.5e-32) || !(z <= 5.8e-61)) {
tmp = (y - (x / z)) / a;
} else {
tmp = x / t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (z <= -3.5e-32) or not (z <= 5.8e-61): tmp = (y - (x / z)) / a else: tmp = x / t return tmp
function code(x, y, z, t, a) tmp = 0.0 if ((z <= -3.5e-32) || !(z <= 5.8e-61)) tmp = Float64(Float64(y - Float64(x / z)) / a); else tmp = Float64(x / t); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((z <= -3.5e-32) || ~((z <= 5.8e-61))) tmp = (y - (x / z)) / a; else tmp = x / t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[Or[LessEqual[z, -3.5e-32], N[Not[LessEqual[z, 5.8e-61]], $MachinePrecision]], N[(N[(y - N[(x / z), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(x / t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.5 \cdot 10^{-32} \lor \neg \left(z \leq 5.8 \cdot 10^{-61}\right):\\
\;\;\;\;\frac{y - \frac{x}{z}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{t}\\
\end{array}
\end{array}
if z < -3.4999999999999999e-32 or 5.7999999999999999e-61 < z Initial program 73.2%
sub-neg73.2%
+-commutative73.2%
neg-sub073.2%
associate-+l-73.2%
sub0-neg73.2%
neg-mul-173.2%
sub-neg73.2%
+-commutative73.2%
neg-sub073.2%
associate-+l-73.2%
sub0-neg73.2%
neg-mul-173.2%
times-frac73.2%
metadata-eval73.2%
*-lft-identity73.2%
*-commutative73.2%
Simplified73.2%
div-sub73.2%
associate-/l*84.8%
Applied egg-rr84.8%
Taylor expanded in a around inf 69.3%
if -3.4999999999999999e-32 < z < 5.7999999999999999e-61Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around 0 61.8%
Final simplification66.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -7.5e-26) (/ y a) (if (<= z 1.65e-49) (/ x t) (/ y a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.5e-26) {
tmp = y / a;
} else if (z <= 1.65e-49) {
tmp = x / t;
} else {
tmp = y / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-7.5d-26)) then
tmp = y / a
else if (z <= 1.65d-49) then
tmp = x / t
else
tmp = y / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -7.5e-26) {
tmp = y / a;
} else if (z <= 1.65e-49) {
tmp = x / t;
} else {
tmp = y / a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -7.5e-26: tmp = y / a elif z <= 1.65e-49: tmp = x / t else: tmp = y / a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -7.5e-26) tmp = Float64(y / a); elseif (z <= 1.65e-49) tmp = Float64(x / t); else tmp = Float64(y / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -7.5e-26) tmp = y / a; elseif (z <= 1.65e-49) tmp = x / t; else tmp = y / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -7.5e-26], N[(y / a), $MachinePrecision], If[LessEqual[z, 1.65e-49], N[(x / t), $MachinePrecision], N[(y / a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.5 \cdot 10^{-26}:\\
\;\;\;\;\frac{y}{a}\\
\mathbf{elif}\;z \leq 1.65 \cdot 10^{-49}:\\
\;\;\;\;\frac{x}{t}\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a}\\
\end{array}
\end{array}
if z < -7.4999999999999994e-26 or 1.65e-49 < z Initial program 72.6%
sub-neg72.6%
+-commutative72.6%
neg-sub072.6%
associate-+l-72.6%
sub0-neg72.6%
neg-mul-172.6%
sub-neg72.6%
+-commutative72.6%
neg-sub072.6%
associate-+l-72.6%
sub0-neg72.6%
neg-mul-172.6%
times-frac72.6%
metadata-eval72.6%
*-lft-identity72.6%
*-commutative72.6%
Simplified72.6%
Taylor expanded in z around inf 50.4%
if -7.4999999999999994e-26 < z < 1.65e-49Initial program 99.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
sub-neg99.8%
+-commutative99.8%
neg-sub099.8%
associate-+l-99.8%
sub0-neg99.8%
neg-mul-199.8%
times-frac99.8%
metadata-eval99.8%
*-lft-identity99.8%
*-commutative99.8%
Simplified99.8%
Taylor expanded in z around 0 61.0%
Final simplification54.9%
(FPCore (x y z t a) :precision binary64 (/ x t))
double code(double x, double y, double z, double t, double a) {
return x / 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 / t
end function
public static double code(double x, double y, double z, double t, double a) {
return x / t;
}
def code(x, y, z, t, a): return x / t
function code(x, y, z, t, a) return Float64(x / t) end
function tmp = code(x, y, z, t, a) tmp = x / t; end
code[x_, y_, z_, t_, a_] := N[(x / t), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{t}
\end{array}
Initial program 84.2%
sub-neg84.2%
+-commutative84.2%
neg-sub084.2%
associate-+l-84.2%
sub0-neg84.2%
neg-mul-184.2%
sub-neg84.2%
+-commutative84.2%
neg-sub084.2%
associate-+l-84.2%
sub0-neg84.2%
neg-mul-184.2%
times-frac84.2%
metadata-eval84.2%
*-lft-identity84.2%
*-commutative84.2%
Simplified84.2%
Taylor expanded in z around 0 35.1%
Final simplification35.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (- t (* a z))) (t_2 (- (/ x t_1) (/ y (- (/ t z) a)))))
(if (< z -32113435955957344.0)
t_2
(if (< z 3.5139522372978296e-86) (* (- x (* y z)) (/ 1.0 t_1)) t_2))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a * z);
double t_2 = (x / t_1) - (y / ((t / z) - a));
double tmp;
if (z < -32113435955957344.0) {
tmp = t_2;
} else if (z < 3.5139522372978296e-86) {
tmp = (x - (y * z)) * (1.0 / t_1);
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t - (a * z)
t_2 = (x / t_1) - (y / ((t / z) - a))
if (z < (-32113435955957344.0d0)) then
tmp = t_2
else if (z < 3.5139522372978296d-86) then
tmp = (x - (y * z)) * (1.0d0 / t_1)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = t - (a * z);
double t_2 = (x / t_1) - (y / ((t / z) - a));
double tmp;
if (z < -32113435955957344.0) {
tmp = t_2;
} else if (z < 3.5139522372978296e-86) {
tmp = (x - (y * z)) * (1.0 / t_1);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = t - (a * z) t_2 = (x / t_1) - (y / ((t / z) - a)) tmp = 0 if z < -32113435955957344.0: tmp = t_2 elif z < 3.5139522372978296e-86: tmp = (x - (y * z)) * (1.0 / t_1) else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(t - Float64(a * z)) t_2 = Float64(Float64(x / t_1) - Float64(y / Float64(Float64(t / z) - a))) tmp = 0.0 if (z < -32113435955957344.0) tmp = t_2; elseif (z < 3.5139522372978296e-86) tmp = Float64(Float64(x - Float64(y * z)) * Float64(1.0 / t_1)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = t - (a * z); t_2 = (x / t_1) - (y / ((t / z) - a)); tmp = 0.0; if (z < -32113435955957344.0) tmp = t_2; elseif (z < 3.5139522372978296e-86) tmp = (x - (y * z)) * (1.0 / t_1); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t - N[(a * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x / t$95$1), $MachinePrecision] - N[(y / N[(N[(t / z), $MachinePrecision] - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[z, -32113435955957344.0], t$95$2, If[Less[z, 3.5139522372978296e-86], N[(N[(x - N[(y * z), $MachinePrecision]), $MachinePrecision] * N[(1.0 / t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t - a \cdot z\\
t_2 := \frac{x}{t_1} - \frac{y}{\frac{t}{z} - a}\\
\mathbf{if}\;z < -32113435955957344:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z < 3.5139522372978296 \cdot 10^{-86}:\\
\;\;\;\;\left(x - y \cdot z\right) \cdot \frac{1}{t_1}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2023171
(FPCore (x y z t a)
:name "Diagrams.Solve.Tridiagonal:solveTriDiagonal from diagrams-solve-0.1, A"
:precision binary64
:herbie-target
(if (< z -32113435955957344.0) (- (/ x (- t (* a z))) (/ y (- (/ t z) a))) (if (< z 3.5139522372978296e-86) (* (- x (* y z)) (/ 1.0 (- t (* a z)))) (- (/ x (- t (* a z))) (/ y (- (/ t z) a)))))
(/ (- x (* y z)) (- t (* a z))))