
(FPCore (x y z t a b) :precision binary64 (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))
double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x + ((y * z) / t)) / ((a + 1.0d0) + ((y * b) / t))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
def code(x, y, z, t, a, b): return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t))
function code(x, y, z, t, a, b) return Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) end
function tmp = code(x, y, z, t, a, b) tmp = (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 20 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))
double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x + ((y * z) / t)) / ((a + 1.0d0) + ((y * b) / t))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
def code(x, y, z, t, a, b): return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t))
function code(x, y, z, t, a, b) return Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) end
function tmp = code(x, y, z, t, a, b) tmp = (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}}
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x (/ (* y z) t)) (+ (/ (* y b) t) (+ a 1.0))))
(t_2 (/ y (/ (+ t (* t (fma y (/ b t) a))) z))))
(if (<= t_1 (- INFINITY))
t_2
(if (<= t_1 -2e-158)
t_1
(if (<= t_1 2e-252)
(/ (+ x (* y (/ z t))) (+ (* b (/ y t)) (+ a 1.0)))
(if (<= t_1 5e+290)
t_1
(if (<= t_1 INFINITY) t_2 (/ (+ z (* x (/ t y))) b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + ((y * z) / t)) / (((y * b) / t) + (a + 1.0));
double t_2 = y / ((t + (t * fma(y, (b / t), a))) / z);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = t_2;
} else if (t_1 <= -2e-158) {
tmp = t_1;
} else if (t_1 <= 2e-252) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t_1 <= 5e+290) {
tmp = t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = (z + (x * (t / y))) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(Float64(y * b) / t) + Float64(a + 1.0))) t_2 = Float64(y / Float64(Float64(t + Float64(t * fma(y, Float64(b / t), a))) / z)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = t_2; elseif (t_1 <= -2e-158) tmp = t_1; elseif (t_1 <= 2e-252) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))); elseif (t_1 <= 5e+290) tmp = t_1; elseif (t_1 <= Inf) tmp = t_2; else tmp = Float64(Float64(z + Float64(x * Float64(t / y))) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y / N[(N[(t + N[(t * N[(y * N[(b / t), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], t$95$2, If[LessEqual[t$95$1, -2e-158], t$95$1, If[LessEqual[t$95$1, 2e-252], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+290], t$95$1, If[LessEqual[t$95$1, Infinity], t$95$2, N[(N[(z + N[(x * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + \frac{y \cdot z}{t}}{\frac{y \cdot b}{t} + \left(a + 1\right)}\\
t_2 := \frac{y}{\frac{t + t \cdot \mathsf{fma}\left(y, \frac{b}{t}, a\right)}{z}}\\
\mathbf{if}\;t_1 \leq -\infty:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t_1 \leq -2 \cdot 10^{-158}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{-252}:\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
\mathbf{elif}\;t_1 \leq 5 \cdot 10^{+290}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\frac{z + x \cdot \frac{t}{y}}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < -inf.0 or 4.9999999999999998e290 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.0%
*-commutative37.0%
associate-*l/62.3%
*-commutative62.3%
associate-*l/62.2%
Simplified62.2%
Taylor expanded in x around 0 62.0%
associate-/l*87.1%
distribute-lft-in87.1%
*-rgt-identity87.1%
associate-*r/83.7%
fma-def83.7%
Simplified83.7%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < -2.00000000000000013e-158 or 1.99999999999999989e-252 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < 4.9999999999999998e290Initial program 99.8%
if -2.00000000000000013e-158 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < 1.99999999999999989e-252Initial program 75.6%
*-commutative75.6%
associate-*l/77.7%
*-commutative77.7%
associate-*l/82.3%
Simplified82.3%
Taylor expanded in b around 0 77.7%
*-commutative77.7%
associate-*r/86.4%
Simplified86.4%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) Initial program 0.0%
*-commutative0.0%
associate-*l/0.2%
*-commutative0.2%
associate-*l/8.0%
Simplified8.0%
Taylor expanded in y around inf 76.3%
associate--l+76.3%
times-frac72.3%
associate-*r*88.0%
unpow288.0%
Simplified88.0%
Taylor expanded in b around inf 94.2%
+-commutative94.2%
associate-*l/98.0%
*-commutative98.0%
Simplified98.0%
Final simplification94.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x (/ (* y z) t)) (+ (/ (* y b) t) (+ a 1.0)))))
(if (<= t_1 (- INFINITY))
(/ z b)
(if (<= t_1 -2e-158)
t_1
(if (<= t_1 2e-252)
(/ (+ x (* y (/ z t))) (+ (* b (/ y t)) (+ a 1.0)))
(if (<= t_1 5e+93)
t_1
(if (<= t_1 INFINITY)
(/ (+ x (/ z (/ t y))) (+ a (+ 1.0 (/ y (/ t b)))))
(/ (+ z (* x (/ t y))) b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + ((y * z) / t)) / (((y * b) / t) + (a + 1.0));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = z / b;
} else if (t_1 <= -2e-158) {
tmp = t_1;
} else if (t_1 <= 2e-252) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t_1 <= 5e+93) {
tmp = t_1;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b))));
} else {
tmp = (z + (x * (t / y))) / b;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + ((y * z) / t)) / (((y * b) / t) + (a + 1.0));
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = z / b;
} else if (t_1 <= -2e-158) {
tmp = t_1;
} else if (t_1 <= 2e-252) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t_1 <= 5e+93) {
tmp = t_1;
} else if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b))));
} else {
tmp = (z + (x * (t / y))) / b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + ((y * z) / t)) / (((y * b) / t) + (a + 1.0)) tmp = 0 if t_1 <= -math.inf: tmp = z / b elif t_1 <= -2e-158: tmp = t_1 elif t_1 <= 2e-252: tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)) elif t_1 <= 5e+93: tmp = t_1 elif t_1 <= math.inf: tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b)))) else: tmp = (z + (x * (t / y))) / b return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(Float64(y * b) / t) + Float64(a + 1.0))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(z / b); elseif (t_1 <= -2e-158) tmp = t_1; elseif (t_1 <= 2e-252) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))); elseif (t_1 <= 5e+93) tmp = t_1; elseif (t_1 <= Inf) tmp = Float64(Float64(x + Float64(z / Float64(t / y))) / Float64(a + Float64(1.0 + Float64(y / Float64(t / b))))); else tmp = Float64(Float64(z + Float64(x * Float64(t / y))) / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + ((y * z) / t)) / (((y * b) / t) + (a + 1.0)); tmp = 0.0; if (t_1 <= -Inf) tmp = z / b; elseif (t_1 <= -2e-158) tmp = t_1; elseif (t_1 <= 2e-252) tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)); elseif (t_1 <= 5e+93) tmp = t_1; elseif (t_1 <= Inf) tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b)))); else tmp = (z + (x * (t / y))) / b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, -2e-158], t$95$1, If[LessEqual[t$95$1, 2e-252], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+93], t$95$1, If[LessEqual[t$95$1, Infinity], N[(N[(x + N[(z / N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + N[(1.0 + N[(y / N[(t / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(z + N[(x * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + \frac{y \cdot z}{t}}{\frac{y \cdot b}{t} + \left(a + 1\right)}\\
\mathbf{if}\;t_1 \leq -\infty:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t_1 \leq -2 \cdot 10^{-158}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq 2 \cdot 10^{-252}:\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
\mathbf{elif}\;t_1 \leq 5 \cdot 10^{+93}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t_1 \leq \infty:\\
\;\;\;\;\frac{x + \frac{z}{\frac{t}{y}}}{a + \left(1 + \frac{y}{\frac{t}{b}}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{z + x \cdot \frac{t}{y}}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < -inf.0Initial program 33.2%
*-commutative33.2%
associate-*l/55.6%
*-commutative55.6%
associate-*l/55.4%
Simplified55.4%
Taylor expanded in t around 0 82.7%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < -2.00000000000000013e-158 or 1.99999999999999989e-252 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < 5.0000000000000001e93Initial program 99.8%
if -2.00000000000000013e-158 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < 1.99999999999999989e-252Initial program 75.6%
*-commutative75.6%
associate-*l/77.7%
*-commutative77.7%
associate-*l/82.3%
Simplified82.3%
Taylor expanded in b around 0 77.7%
*-commutative77.7%
associate-*r/86.4%
Simplified86.4%
if 5.0000000000000001e93 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 72.0%
*-commutative72.0%
associate-/l*86.1%
associate-*l/74.7%
*-commutative74.7%
cancel-sign-sub74.7%
*-commutative74.7%
associate-*l/86.1%
associate-+r-86.1%
associate-*l/74.7%
*-commutative74.7%
cancel-sign-sub74.7%
*-commutative74.7%
associate-/r/86.1%
Simplified86.1%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a 1) (/.f64 (*.f64 y b) t))) Initial program 0.0%
*-commutative0.0%
associate-*l/0.2%
*-commutative0.2%
associate-*l/8.0%
Simplified8.0%
Taylor expanded in y around inf 76.3%
associate--l+76.3%
times-frac72.3%
associate-*r*88.0%
unpow288.0%
Simplified88.0%
Taylor expanded in b around inf 94.2%
+-commutative94.2%
associate-*l/98.0%
*-commutative98.0%
Simplified98.0%
Final simplification93.6%
(FPCore (x y z t a b)
:precision binary64
(if (or (<= t -4.1e-16)
(not
(or (<= t -7.8e-82) (and (not (<= t -7e-167)) (<= t 2.35e-167)))))
(/ (+ x (* y (/ z t))) (+ (* b (/ y t)) (+ a 1.0)))
(/ (+ z (/ (* x t) y)) b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -4.1e-16) || !((t <= -7.8e-82) || (!(t <= -7e-167) && (t <= 2.35e-167)))) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else {
tmp = (z + ((x * t) / y)) / b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t <= (-4.1d-16)) .or. (.not. (t <= (-7.8d-82)) .or. (.not. (t <= (-7d-167))) .and. (t <= 2.35d-167))) then
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0d0))
else
tmp = (z + ((x * t) / y)) / b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -4.1e-16) || !((t <= -7.8e-82) || (!(t <= -7e-167) && (t <= 2.35e-167)))) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else {
tmp = (z + ((x * t) / y)) / b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -4.1e-16) or not ((t <= -7.8e-82) or (not (t <= -7e-167) and (t <= 2.35e-167))): tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)) else: tmp = (z + ((x * t) / y)) / b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -4.1e-16) || !((t <= -7.8e-82) || (!(t <= -7e-167) && (t <= 2.35e-167)))) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))); else tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -4.1e-16) || ~(((t <= -7.8e-82) || (~((t <= -7e-167)) && (t <= 2.35e-167))))) tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)); else tmp = (z + ((x * t) / y)) / b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -4.1e-16], N[Not[Or[LessEqual[t, -7.8e-82], And[N[Not[LessEqual[t, -7e-167]], $MachinePrecision], LessEqual[t, 2.35e-167]]]], $MachinePrecision]], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.1 \cdot 10^{-16} \lor \neg \left(t \leq -7.8 \cdot 10^{-82} \lor \neg \left(t \leq -7 \cdot 10^{-167}\right) \land t \leq 2.35 \cdot 10^{-167}\right):\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\end{array}
\end{array}
if t < -4.10000000000000006e-16 or -7.79999999999999947e-82 < t < -6.9999999999999998e-167 or 2.34999999999999985e-167 < t Initial program 85.2%
*-commutative85.2%
associate-*l/88.8%
*-commutative88.8%
associate-*l/91.4%
Simplified91.4%
Taylor expanded in b around 0 88.8%
*-commutative88.8%
associate-*r/92.9%
Simplified92.9%
if -4.10000000000000006e-16 < t < -7.79999999999999947e-82 or -6.9999999999999998e-167 < t < 2.34999999999999985e-167Initial program 55.0%
*-commutative55.0%
associate-*l/48.4%
*-commutative48.4%
associate-*l/44.7%
Simplified44.7%
Taylor expanded in y around inf 68.1%
associate--l+68.1%
times-frac65.1%
associate-*r*69.1%
unpow269.1%
Simplified69.1%
Taylor expanded in b around inf 83.8%
Final simplification90.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (* y (/ z t))))
(t_2 (/ t_1 (+ (* b (/ y t)) (+ a 1.0))))
(t_3 (/ (+ z (/ (* x t) y)) b)))
(if (<= t -4.1e-16)
t_2
(if (<= t -1.05e-83)
t_3
(if (<= t -1.2e-166)
t_2
(if (<= t 3.6e-168) t_3 (/ t_1 (+ (* y (/ b t)) (+ a 1.0)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y * (z / t));
double t_2 = t_1 / ((b * (y / t)) + (a + 1.0));
double t_3 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = t_2;
} else if (t <= -1.05e-83) {
tmp = t_3;
} else if (t <= -1.2e-166) {
tmp = t_2;
} else if (t <= 3.6e-168) {
tmp = t_3;
} else {
tmp = t_1 / ((y * (b / t)) + (a + 1.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x + (y * (z / t))
t_2 = t_1 / ((b * (y / t)) + (a + 1.0d0))
t_3 = (z + ((x * t) / y)) / b
if (t <= (-4.1d-16)) then
tmp = t_2
else if (t <= (-1.05d-83)) then
tmp = t_3
else if (t <= (-1.2d-166)) then
tmp = t_2
else if (t <= 3.6d-168) then
tmp = t_3
else
tmp = t_1 / ((y * (b / t)) + (a + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y * (z / t));
double t_2 = t_1 / ((b * (y / t)) + (a + 1.0));
double t_3 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = t_2;
} else if (t <= -1.05e-83) {
tmp = t_3;
} else if (t <= -1.2e-166) {
tmp = t_2;
} else if (t <= 3.6e-168) {
tmp = t_3;
} else {
tmp = t_1 / ((y * (b / t)) + (a + 1.0));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (y * (z / t)) t_2 = t_1 / ((b * (y / t)) + (a + 1.0)) t_3 = (z + ((x * t) / y)) / b tmp = 0 if t <= -4.1e-16: tmp = t_2 elif t <= -1.05e-83: tmp = t_3 elif t <= -1.2e-166: tmp = t_2 elif t <= 3.6e-168: tmp = t_3 else: tmp = t_1 / ((y * (b / t)) + (a + 1.0)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(y * Float64(z / t))) t_2 = Float64(t_1 / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))) t_3 = Float64(Float64(z + Float64(Float64(x * t) / y)) / b) tmp = 0.0 if (t <= -4.1e-16) tmp = t_2; elseif (t <= -1.05e-83) tmp = t_3; elseif (t <= -1.2e-166) tmp = t_2; elseif (t <= 3.6e-168) tmp = t_3; else tmp = Float64(t_1 / Float64(Float64(y * Float64(b / t)) + Float64(a + 1.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (y * (z / t)); t_2 = t_1 / ((b * (y / t)) + (a + 1.0)); t_3 = (z + ((x * t) / y)) / b; tmp = 0.0; if (t <= -4.1e-16) tmp = t_2; elseif (t <= -1.05e-83) tmp = t_3; elseif (t <= -1.2e-166) tmp = t_2; elseif (t <= 3.6e-168) tmp = t_3; else tmp = t_1 / ((y * (b / t)) + (a + 1.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[t, -4.1e-16], t$95$2, If[LessEqual[t, -1.05e-83], t$95$3, If[LessEqual[t, -1.2e-166], t$95$2, If[LessEqual[t, 3.6e-168], t$95$3, N[(t$95$1 / N[(N[(y * N[(b / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + y \cdot \frac{z}{t}\\
t_2 := \frac{t_1}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
t_3 := \frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{if}\;t \leq -4.1 \cdot 10^{-16}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.05 \cdot 10^{-83}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -1.2 \cdot 10^{-166}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{-168}:\\
\;\;\;\;t_3\\
\mathbf{else}:\\
\;\;\;\;\frac{t_1}{y \cdot \frac{b}{t} + \left(a + 1\right)}\\
\end{array}
\end{array}
if t < -4.10000000000000006e-16 or -1.0499999999999999e-83 < t < -1.1999999999999999e-166Initial program 90.6%
*-commutative90.6%
associate-*l/93.2%
*-commutative93.2%
associate-*l/91.9%
Simplified91.9%
Taylor expanded in b around 0 93.2%
*-commutative93.2%
associate-*r/95.9%
Simplified95.9%
if -4.10000000000000006e-16 < t < -1.0499999999999999e-83 or -1.1999999999999999e-166 < t < 3.5999999999999999e-168Initial program 55.0%
*-commutative55.0%
associate-*l/48.4%
*-commutative48.4%
associate-*l/44.7%
Simplified44.7%
Taylor expanded in y around inf 68.1%
associate--l+68.1%
times-frac65.1%
associate-*r*69.1%
unpow269.1%
Simplified69.1%
Taylor expanded in b around inf 83.8%
if 3.5999999999999999e-168 < t Initial program 81.7%
*-commutative81.7%
associate-*l/86.0%
*-commutative86.0%
associate-*l/91.1%
Simplified91.1%
Final simplification90.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x (/ y (/ t z))) (+ (* y (/ b t)) (+ a 1.0))))
(t_2 (/ (+ z (/ (* x t) y)) b)))
(if (<= t -4.1e-16)
t_1
(if (<= t -1.15e-83)
t_2
(if (<= t -1.7e-167)
(/ (+ x (* y (/ z t))) (+ (* b (/ y t)) (+ a 1.0)))
(if (<= t 3.6e-172) t_2 t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0));
double t_2 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = t_1;
} else if (t <= -1.15e-83) {
tmp = t_2;
} else if (t <= -1.7e-167) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t <= 3.6e-172) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0d0))
t_2 = (z + ((x * t) / y)) / b
if (t <= (-4.1d-16)) then
tmp = t_1
else if (t <= (-1.15d-83)) then
tmp = t_2
else if (t <= (-1.7d-167)) then
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0d0))
else if (t <= 3.6d-172) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0));
double t_2 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = t_1;
} else if (t <= -1.15e-83) {
tmp = t_2;
} else if (t <= -1.7e-167) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t <= 3.6e-172) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0)) t_2 = (z + ((x * t) / y)) / b tmp = 0 if t <= -4.1e-16: tmp = t_1 elif t <= -1.15e-83: tmp = t_2 elif t <= -1.7e-167: tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)) elif t <= 3.6e-172: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(y / Float64(t / z))) / Float64(Float64(y * Float64(b / t)) + Float64(a + 1.0))) t_2 = Float64(Float64(z + Float64(Float64(x * t) / y)) / b) tmp = 0.0 if (t <= -4.1e-16) tmp = t_1; elseif (t <= -1.15e-83) tmp = t_2; elseif (t <= -1.7e-167) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))); elseif (t <= 3.6e-172) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0)); t_2 = (z + ((x * t) / y)) / b; tmp = 0.0; if (t <= -4.1e-16) tmp = t_1; elseif (t <= -1.15e-83) tmp = t_2; elseif (t <= -1.7e-167) tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)); elseif (t <= 3.6e-172) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(b / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[t, -4.1e-16], t$95$1, If[LessEqual[t, -1.15e-83], t$95$2, If[LessEqual[t, -1.7e-167], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e-172], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + \frac{y}{\frac{t}{z}}}{y \cdot \frac{b}{t} + \left(a + 1\right)}\\
t_2 := \frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{if}\;t \leq -4.1 \cdot 10^{-16}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{-83}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-167}:\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{-172}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -4.10000000000000006e-16 or 3.60000000000000015e-172 < t Initial program 84.6%
*-commutative84.6%
associate-*l/89.1%
*-commutative89.1%
associate-*l/93.6%
Simplified93.6%
Taylor expanded in z around 0 88.0%
associate-/l*93.6%
Simplified93.6%
if -4.10000000000000006e-16 < t < -1.14999999999999995e-83 or -1.6999999999999999e-167 < t < 3.60000000000000015e-172Initial program 55.0%
*-commutative55.0%
associate-*l/48.4%
*-commutative48.4%
associate-*l/44.7%
Simplified44.7%
Taylor expanded in y around inf 68.1%
associate--l+68.1%
times-frac65.1%
associate-*r*69.1%
unpow269.1%
Simplified69.1%
Taylor expanded in b around inf 83.8%
if -1.14999999999999995e-83 < t < -1.6999999999999999e-167Initial program 92.8%
*-commutative92.8%
associate-*l/86.1%
*-commutative86.1%
associate-*l/65.6%
Simplified65.6%
Taylor expanded in b around 0 86.1%
*-commutative86.1%
associate-*r/86.0%
Simplified86.0%
Final simplification90.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ z (/ (* x t) y)) b)))
(if (<= t -4.1e-16)
(/ (+ x (/ y (/ t z))) (+ (* y (/ b t)) (+ a 1.0)))
(if (<= t -9.2e-83)
t_1
(if (<= t -6.3e-167)
(/ (+ x (* y (/ z t))) (+ (* b (/ y t)) (+ a 1.0)))
(if (<= t 8e-80)
t_1
(/ (+ x (/ z (/ t y))) (+ a (+ 1.0 (/ y (/ t b)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0));
} else if (t <= -9.2e-83) {
tmp = t_1;
} else if (t <= -6.3e-167) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t <= 8e-80) {
tmp = t_1;
} else {
tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = (z + ((x * t) / y)) / b
if (t <= (-4.1d-16)) then
tmp = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0d0))
else if (t <= (-9.2d-83)) then
tmp = t_1
else if (t <= (-6.3d-167)) then
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0d0))
else if (t <= 8d-80) then
tmp = t_1
else
tmp = (x + (z / (t / y))) / (a + (1.0d0 + (y / (t / b))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + ((x * t) / y)) / b;
double tmp;
if (t <= -4.1e-16) {
tmp = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0));
} else if (t <= -9.2e-83) {
tmp = t_1;
} else if (t <= -6.3e-167) {
tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0));
} else if (t <= 8e-80) {
tmp = t_1;
} else {
tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b))));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + ((x * t) / y)) / b tmp = 0 if t <= -4.1e-16: tmp = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0)) elif t <= -9.2e-83: tmp = t_1 elif t <= -6.3e-167: tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)) elif t <= 8e-80: tmp = t_1 else: tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b)))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + Float64(Float64(x * t) / y)) / b) tmp = 0.0 if (t <= -4.1e-16) tmp = Float64(Float64(x + Float64(y / Float64(t / z))) / Float64(Float64(y * Float64(b / t)) + Float64(a + 1.0))); elseif (t <= -9.2e-83) tmp = t_1; elseif (t <= -6.3e-167) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(Float64(b * Float64(y / t)) + Float64(a + 1.0))); elseif (t <= 8e-80) tmp = t_1; else tmp = Float64(Float64(x + Float64(z / Float64(t / y))) / Float64(a + Float64(1.0 + Float64(y / Float64(t / b))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + ((x * t) / y)) / b; tmp = 0.0; if (t <= -4.1e-16) tmp = (x + (y / (t / z))) / ((y * (b / t)) + (a + 1.0)); elseif (t <= -9.2e-83) tmp = t_1; elseif (t <= -6.3e-167) tmp = (x + (y * (z / t))) / ((b * (y / t)) + (a + 1.0)); elseif (t <= 8e-80) tmp = t_1; else tmp = (x + (z / (t / y))) / (a + (1.0 + (y / (t / b)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[t, -4.1e-16], N[(N[(x + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(b / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9.2e-83], t$95$1, If[LessEqual[t, -6.3e-167], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(b * N[(y / t), $MachinePrecision]), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e-80], t$95$1, N[(N[(x + N[(z / N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + N[(1.0 + N[(y / N[(t / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{if}\;t \leq -4.1 \cdot 10^{-16}:\\
\;\;\;\;\frac{x + \frac{y}{\frac{t}{z}}}{y \cdot \frac{b}{t} + \left(a + 1\right)}\\
\mathbf{elif}\;t \leq -9.2 \cdot 10^{-83}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -6.3 \cdot 10^{-167}:\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{b \cdot \frac{y}{t} + \left(a + 1\right)}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{-80}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{x + \frac{z}{\frac{t}{y}}}{a + \left(1 + \frac{y}{\frac{t}{b}}\right)}\\
\end{array}
\end{array}
if t < -4.10000000000000006e-16Initial program 90.0%
*-commutative90.0%
associate-*l/94.9%
*-commutative94.9%
associate-*l/98.2%
Simplified98.2%
Taylor expanded in z around 0 93.3%
associate-/l*98.3%
Simplified98.3%
if -4.10000000000000006e-16 < t < -9.19999999999999959e-83 or -6.3000000000000001e-167 < t < 7.99999999999999969e-80Initial program 55.7%
*-commutative55.7%
associate-*l/51.2%
*-commutative51.2%
associate-*l/48.1%
Simplified48.1%
Taylor expanded in y around inf 64.1%
associate--l+64.1%
times-frac61.6%
associate-*r*65.0%
unpow265.0%
Simplified65.0%
Taylor expanded in b around inf 80.8%
if -9.19999999999999959e-83 < t < -6.3000000000000001e-167Initial program 92.8%
*-commutative92.8%
associate-*l/86.1%
*-commutative86.1%
associate-*l/65.6%
Simplified65.6%
Taylor expanded in b around 0 86.1%
*-commutative86.1%
associate-*r/86.0%
Simplified86.0%
if 7.99999999999999969e-80 < t Initial program 84.9%
*-commutative84.9%
associate-/l*89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-*l/89.9%
associate-+r-89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-/r/95.8%
Simplified95.8%
Final simplification90.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* y z) (+ t (* t a)))) (t_2 (/ x (+ a 1.0))))
(if (<= t -9.6e+64)
t_2
(if (<= t -1e-15)
t_1
(if (<= t -1.05e-82)
(/ z b)
(if (<= t -7.5e-153) t_1 (if (<= t 9.2e-79) (/ z b) t_2)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * z) / (t + (t * a));
double t_2 = x / (a + 1.0);
double tmp;
if (t <= -9.6e+64) {
tmp = t_2;
} else if (t <= -1e-15) {
tmp = t_1;
} else if (t <= -1.05e-82) {
tmp = z / b;
} else if (t <= -7.5e-153) {
tmp = t_1;
} else if (t <= 9.2e-79) {
tmp = z / b;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (y * z) / (t + (t * a))
t_2 = x / (a + 1.0d0)
if (t <= (-9.6d+64)) then
tmp = t_2
else if (t <= (-1d-15)) then
tmp = t_1
else if (t <= (-1.05d-82)) then
tmp = z / b
else if (t <= (-7.5d-153)) then
tmp = t_1
else if (t <= 9.2d-79) then
tmp = z / b
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 b) {
double t_1 = (y * z) / (t + (t * a));
double t_2 = x / (a + 1.0);
double tmp;
if (t <= -9.6e+64) {
tmp = t_2;
} else if (t <= -1e-15) {
tmp = t_1;
} else if (t <= -1.05e-82) {
tmp = z / b;
} else if (t <= -7.5e-153) {
tmp = t_1;
} else if (t <= 9.2e-79) {
tmp = z / b;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (y * z) / (t + (t * a)) t_2 = x / (a + 1.0) tmp = 0 if t <= -9.6e+64: tmp = t_2 elif t <= -1e-15: tmp = t_1 elif t <= -1.05e-82: tmp = z / b elif t <= -7.5e-153: tmp = t_1 elif t <= 9.2e-79: tmp = z / b else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * z) / Float64(t + Float64(t * a))) t_2 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -9.6e+64) tmp = t_2; elseif (t <= -1e-15) tmp = t_1; elseif (t <= -1.05e-82) tmp = Float64(z / b); elseif (t <= -7.5e-153) tmp = t_1; elseif (t <= 9.2e-79) tmp = Float64(z / b); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (y * z) / (t + (t * a)); t_2 = x / (a + 1.0); tmp = 0.0; if (t <= -9.6e+64) tmp = t_2; elseif (t <= -1e-15) tmp = t_1; elseif (t <= -1.05e-82) tmp = z / b; elseif (t <= -7.5e-153) tmp = t_1; elseif (t <= 9.2e-79) tmp = z / b; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * z), $MachinePrecision] / N[(t + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.6e+64], t$95$2, If[LessEqual[t, -1e-15], t$95$1, If[LessEqual[t, -1.05e-82], N[(z / b), $MachinePrecision], If[LessEqual[t, -7.5e-153], t$95$1, If[LessEqual[t, 9.2e-79], N[(z / b), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y \cdot z}{t + t \cdot a}\\
t_2 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -9.6 \cdot 10^{+64}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-15}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.05 \cdot 10^{-82}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-153}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{-79}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -9.59999999999999997e64 or 9.20000000000000047e-79 < t Initial program 86.3%
*-commutative86.3%
associate-*l/91.0%
*-commutative91.0%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in t around inf 65.9%
if -9.59999999999999997e64 < t < -1.0000000000000001e-15 or -1.05e-82 < t < -7.5e-153Initial program 95.4%
*-commutative95.4%
associate-/l*91.5%
associate-*l/91.5%
*-commutative91.5%
cancel-sign-sub91.5%
*-commutative91.5%
associate-*l/91.5%
associate-+r-91.5%
associate-*l/91.5%
*-commutative91.5%
cancel-sign-sub91.5%
*-commutative91.5%
associate-/r/83.3%
Simplified83.3%
Taylor expanded in x around 0 70.1%
Taylor expanded in t around inf 60.1%
distribute-lft-in60.1%
*-rgt-identity60.1%
Simplified60.1%
if -1.0000000000000001e-15 < t < -1.05e-82 or -7.5e-153 < t < 9.20000000000000047e-79Initial program 56.6%
*-commutative56.6%
associate-*l/52.3%
*-commutative52.3%
associate-*l/48.3%
Simplified48.3%
Taylor expanded in t around 0 68.1%
Final simplification66.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -2.8e+65)
t_1
(if (<= t -5e-16)
(/ (* y (/ z t)) (+ a 1.0))
(if (<= t -2.35e-85)
(/ z b)
(if (<= t -9.2e-153)
(/ (* y z) (+ t (* t a)))
(if (<= t 1.02e-75) (/ z b) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -2.8e+65) {
tmp = t_1;
} else if (t <= -5e-16) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= -2.35e-85) {
tmp = z / b;
} else if (t <= -9.2e-153) {
tmp = (y * z) / (t + (t * a));
} else if (t <= 1.02e-75) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-2.8d+65)) then
tmp = t_1
else if (t <= (-5d-16)) then
tmp = (y * (z / t)) / (a + 1.0d0)
else if (t <= (-2.35d-85)) then
tmp = z / b
else if (t <= (-9.2d-153)) then
tmp = (y * z) / (t + (t * a))
else if (t <= 1.02d-75) then
tmp = z / b
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 b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -2.8e+65) {
tmp = t_1;
} else if (t <= -5e-16) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= -2.35e-85) {
tmp = z / b;
} else if (t <= -9.2e-153) {
tmp = (y * z) / (t + (t * a));
} else if (t <= 1.02e-75) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -2.8e+65: tmp = t_1 elif t <= -5e-16: tmp = (y * (z / t)) / (a + 1.0) elif t <= -2.35e-85: tmp = z / b elif t <= -9.2e-153: tmp = (y * z) / (t + (t * a)) elif t <= 1.02e-75: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -2.8e+65) tmp = t_1; elseif (t <= -5e-16) tmp = Float64(Float64(y * Float64(z / t)) / Float64(a + 1.0)); elseif (t <= -2.35e-85) tmp = Float64(z / b); elseif (t <= -9.2e-153) tmp = Float64(Float64(y * z) / Float64(t + Float64(t * a))); elseif (t <= 1.02e-75) tmp = Float64(z / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -2.8e+65) tmp = t_1; elseif (t <= -5e-16) tmp = (y * (z / t)) / (a + 1.0); elseif (t <= -2.35e-85) tmp = z / b; elseif (t <= -9.2e-153) tmp = (y * z) / (t + (t * a)); elseif (t <= 1.02e-75) tmp = z / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.8e+65], t$95$1, If[LessEqual[t, -5e-16], N[(N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.35e-85], N[(z / b), $MachinePrecision], If[LessEqual[t, -9.2e-153], N[(N[(y * z), $MachinePrecision] / N[(t + N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.02e-75], N[(z / b), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -2.8 \cdot 10^{+65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -5 \cdot 10^{-16}:\\
\;\;\;\;\frac{y \cdot \frac{z}{t}}{a + 1}\\
\mathbf{elif}\;t \leq -2.35 \cdot 10^{-85}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t \leq -9.2 \cdot 10^{-153}:\\
\;\;\;\;\frac{y \cdot z}{t + t \cdot a}\\
\mathbf{elif}\;t \leq 1.02 \cdot 10^{-75}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.7999999999999999e65 or 1.01999999999999997e-75 < t Initial program 86.3%
*-commutative86.3%
associate-*l/91.0%
*-commutative91.0%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in t around inf 65.9%
if -2.7999999999999999e65 < t < -5.0000000000000004e-16Initial program 92.4%
*-commutative92.4%
associate-*l/92.4%
*-commutative92.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 92.4%
associate-/l*92.7%
Simplified92.7%
Taylor expanded in b around 0 77.8%
Taylor expanded in x around 0 62.8%
associate-*r/62.8%
Simplified62.8%
if -5.0000000000000004e-16 < t < -2.35000000000000005e-85 or -9.19999999999999988e-153 < t < 1.01999999999999997e-75Initial program 56.6%
*-commutative56.6%
associate-*l/52.3%
*-commutative52.3%
associate-*l/48.3%
Simplified48.3%
Taylor expanded in t around 0 68.1%
if -2.35000000000000005e-85 < t < -9.19999999999999988e-153Initial program 99.4%
*-commutative99.4%
associate-/l*99.4%
associate-*l/99.2%
*-commutative99.2%
cancel-sign-sub99.2%
*-commutative99.2%
associate-*l/99.4%
associate-+r-99.4%
associate-*l/99.2%
*-commutative99.2%
cancel-sign-sub99.2%
*-commutative99.2%
associate-/r/80.4%
Simplified80.4%
Taylor expanded in x around 0 60.9%
Taylor expanded in t around inf 57.0%
distribute-lft-in57.0%
*-rgt-identity57.0%
Simplified57.0%
Final simplification66.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -1.02e+65)
t_1
(if (<= t -5e-15)
(/ (* y (/ z t)) (+ a 1.0))
(if (<= t -2.05e-85)
(/ z b)
(if (<= t -7.5e-153)
(/ (* z (/ y t)) (+ a 1.0))
(if (<= t 5.8e-78) (/ z b) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -1.02e+65) {
tmp = t_1;
} else if (t <= -5e-15) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= -2.05e-85) {
tmp = z / b;
} else if (t <= -7.5e-153) {
tmp = (z * (y / t)) / (a + 1.0);
} else if (t <= 5.8e-78) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-1.02d+65)) then
tmp = t_1
else if (t <= (-5d-15)) then
tmp = (y * (z / t)) / (a + 1.0d0)
else if (t <= (-2.05d-85)) then
tmp = z / b
else if (t <= (-7.5d-153)) then
tmp = (z * (y / t)) / (a + 1.0d0)
else if (t <= 5.8d-78) then
tmp = z / b
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 b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -1.02e+65) {
tmp = t_1;
} else if (t <= -5e-15) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= -2.05e-85) {
tmp = z / b;
} else if (t <= -7.5e-153) {
tmp = (z * (y / t)) / (a + 1.0);
} else if (t <= 5.8e-78) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -1.02e+65: tmp = t_1 elif t <= -5e-15: tmp = (y * (z / t)) / (a + 1.0) elif t <= -2.05e-85: tmp = z / b elif t <= -7.5e-153: tmp = (z * (y / t)) / (a + 1.0) elif t <= 5.8e-78: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -1.02e+65) tmp = t_1; elseif (t <= -5e-15) tmp = Float64(Float64(y * Float64(z / t)) / Float64(a + 1.0)); elseif (t <= -2.05e-85) tmp = Float64(z / b); elseif (t <= -7.5e-153) tmp = Float64(Float64(z * Float64(y / t)) / Float64(a + 1.0)); elseif (t <= 5.8e-78) tmp = Float64(z / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -1.02e+65) tmp = t_1; elseif (t <= -5e-15) tmp = (y * (z / t)) / (a + 1.0); elseif (t <= -2.05e-85) tmp = z / b; elseif (t <= -7.5e-153) tmp = (z * (y / t)) / (a + 1.0); elseif (t <= 5.8e-78) tmp = z / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.02e+65], t$95$1, If[LessEqual[t, -5e-15], N[(N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.05e-85], N[(z / b), $MachinePrecision], If[LessEqual[t, -7.5e-153], N[(N[(z * N[(y / t), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e-78], N[(z / b), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -1.02 \cdot 10^{+65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -5 \cdot 10^{-15}:\\
\;\;\;\;\frac{y \cdot \frac{z}{t}}{a + 1}\\
\mathbf{elif}\;t \leq -2.05 \cdot 10^{-85}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-153}:\\
\;\;\;\;\frac{z \cdot \frac{y}{t}}{a + 1}\\
\mathbf{elif}\;t \leq 5.8 \cdot 10^{-78}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.02000000000000005e65 or 5.8000000000000001e-78 < t Initial program 86.3%
*-commutative86.3%
associate-*l/91.0%
*-commutative91.0%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in t around inf 65.9%
if -1.02000000000000005e65 < t < -4.99999999999999999e-15Initial program 92.4%
*-commutative92.4%
associate-*l/92.4%
*-commutative92.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 92.4%
associate-/l*92.7%
Simplified92.7%
Taylor expanded in b around 0 77.8%
Taylor expanded in x around 0 62.8%
associate-*r/62.8%
Simplified62.8%
if -4.99999999999999999e-15 < t < -2.04999999999999997e-85 or -7.5e-153 < t < 5.8000000000000001e-78Initial program 56.6%
*-commutative56.6%
associate-*l/52.3%
*-commutative52.3%
associate-*l/48.3%
Simplified48.3%
Taylor expanded in t around 0 68.1%
if -2.04999999999999997e-85 < t < -7.5e-153Initial program 99.4%
*-commutative99.4%
associate-*l/90.0%
*-commutative90.0%
associate-*l/71.1%
Simplified71.1%
Taylor expanded in z around 0 80.4%
associate-/l*70.9%
Simplified70.9%
Taylor expanded in b around 0 56.3%
Taylor expanded in x around 0 57.0%
associate-*l/57.2%
*-commutative57.2%
Simplified57.2%
Final simplification66.2%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -9.8e+64)
(/ x (+ a 1.0))
(if (<= t -1.02e-14)
(/ (- z) (/ (* t (- -1.0 a)) y))
(if (<= t 1.2e-76)
(/ (+ z (/ (* x t) y)) b)
(/ x (+ (/ (* y b) t) (+ a 1.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -9.8e+64) {
tmp = x / (a + 1.0);
} else if (t <= -1.02e-14) {
tmp = -z / ((t * (-1.0 - a)) / y);
} else if (t <= 1.2e-76) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = x / (((y * b) / t) + (a + 1.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-9.8d+64)) then
tmp = x / (a + 1.0d0)
else if (t <= (-1.02d-14)) then
tmp = -z / ((t * ((-1.0d0) - a)) / y)
else if (t <= 1.2d-76) then
tmp = (z + ((x * t) / y)) / b
else
tmp = x / (((y * b) / t) + (a + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -9.8e+64) {
tmp = x / (a + 1.0);
} else if (t <= -1.02e-14) {
tmp = -z / ((t * (-1.0 - a)) / y);
} else if (t <= 1.2e-76) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = x / (((y * b) / t) + (a + 1.0));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -9.8e+64: tmp = x / (a + 1.0) elif t <= -1.02e-14: tmp = -z / ((t * (-1.0 - a)) / y) elif t <= 1.2e-76: tmp = (z + ((x * t) / y)) / b else: tmp = x / (((y * b) / t) + (a + 1.0)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -9.8e+64) tmp = Float64(x / Float64(a + 1.0)); elseif (t <= -1.02e-14) tmp = Float64(Float64(-z) / Float64(Float64(t * Float64(-1.0 - a)) / y)); elseif (t <= 1.2e-76) tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); else tmp = Float64(x / Float64(Float64(Float64(y * b) / t) + Float64(a + 1.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -9.8e+64) tmp = x / (a + 1.0); elseif (t <= -1.02e-14) tmp = -z / ((t * (-1.0 - a)) / y); elseif (t <= 1.2e-76) tmp = (z + ((x * t) / y)) / b; else tmp = x / (((y * b) / t) + (a + 1.0)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -9.8e+64], N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.02e-14], N[((-z) / N[(N[(t * N[(-1.0 - a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e-76], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], N[(x / N[(N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -9.8 \cdot 10^{+64}:\\
\;\;\;\;\frac{x}{a + 1}\\
\mathbf{elif}\;t \leq -1.02 \cdot 10^{-14}:\\
\;\;\;\;\frac{-z}{\frac{t \cdot \left(-1 - a\right)}{y}}\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{-76}:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\frac{y \cdot b}{t} + \left(a + 1\right)}\\
\end{array}
\end{array}
if t < -9.8000000000000005e64Initial program 89.3%
*-commutative89.3%
associate-*l/95.7%
*-commutative95.7%
associate-*l/99.9%
Simplified99.9%
Taylor expanded in t around inf 85.0%
if -9.8000000000000005e64 < t < -1.02e-14Initial program 92.4%
*-commutative92.4%
associate-/l*85.4%
associate-*l/85.6%
*-commutative85.6%
cancel-sign-sub85.6%
*-commutative85.6%
associate-*l/85.4%
associate-+r-85.4%
associate-*l/85.6%
*-commutative85.6%
cancel-sign-sub85.6%
*-commutative85.6%
associate-/r/85.4%
Simplified85.4%
Taylor expanded in x around 0 77.3%
Taylor expanded in t around inf 62.5%
distribute-lft-in62.5%
*-rgt-identity62.5%
Simplified62.5%
Taylor expanded in t around -inf 62.5%
mul-1-neg62.5%
distribute-neg-frac62.5%
distribute-rgt-neg-out62.5%
*-commutative62.5%
*-commutative62.5%
sub-neg62.5%
metadata-eval62.5%
distribute-lft-in62.5%
neg-mul-162.5%
distribute-rgt-neg-in62.5%
*-commutative62.5%
neg-mul-162.5%
distribute-neg-in62.5%
fma-udef62.5%
associate-/l*62.8%
Simplified62.8%
if -1.02e-14 < t < 1.20000000000000007e-76Initial program 60.8%
*-commutative60.8%
associate-*l/56.0%
*-commutative56.0%
associate-*l/50.5%
Simplified50.5%
Taylor expanded in y around inf 60.4%
associate--l+60.4%
times-frac58.2%
associate-*r*61.1%
unpow261.1%
Simplified61.1%
Taylor expanded in b around inf 75.8%
if 1.20000000000000007e-76 < t Initial program 84.9%
*-commutative84.9%
associate-/l*89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-*l/89.9%
associate-+r-89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-/r/95.8%
Simplified95.8%
Taylor expanded in x around inf 70.9%
Final simplification74.9%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -4.3e-15)
(/ (+ x (/ y (/ t z))) (+ a 1.0))
(if (<= t 5e-78)
(/ (+ z (/ (* x t) y)) b)
(* x (/ 1.0 (+ a (+ 1.0 (* y (/ b t)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.3e-15) {
tmp = (x + (y / (t / z))) / (a + 1.0);
} else if (t <= 5e-78) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = x * (1.0 / (a + (1.0 + (y * (b / t)))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-4.3d-15)) then
tmp = (x + (y / (t / z))) / (a + 1.0d0)
else if (t <= 5d-78) then
tmp = (z + ((x * t) / y)) / b
else
tmp = x * (1.0d0 / (a + (1.0d0 + (y * (b / t)))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.3e-15) {
tmp = (x + (y / (t / z))) / (a + 1.0);
} else if (t <= 5e-78) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = x * (1.0 / (a + (1.0 + (y * (b / t)))));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.3e-15: tmp = (x + (y / (t / z))) / (a + 1.0) elif t <= 5e-78: tmp = (z + ((x * t) / y)) / b else: tmp = x * (1.0 / (a + (1.0 + (y * (b / t))))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.3e-15) tmp = Float64(Float64(x + Float64(y / Float64(t / z))) / Float64(a + 1.0)); elseif (t <= 5e-78) tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); else tmp = Float64(x * Float64(1.0 / Float64(a + Float64(1.0 + Float64(y * Float64(b / t)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.3e-15) tmp = (x + (y / (t / z))) / (a + 1.0); elseif (t <= 5e-78) tmp = (z + ((x * t) / y)) / b; else tmp = x * (1.0 / (a + (1.0 + (y * (b / t))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.3e-15], N[(N[(x + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5e-78], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], N[(x * N[(1.0 / N[(a + N[(1.0 + N[(y * N[(b / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{x + \frac{y}{\frac{t}{z}}}{a + 1}\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-78}:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;x \cdot \frac{1}{a + \left(1 + y \cdot \frac{b}{t}\right)}\\
\end{array}
\end{array}
if t < -4.2999999999999997e-15Initial program 90.0%
*-commutative90.0%
associate-*l/94.9%
*-commutative94.9%
associate-*l/98.2%
Simplified98.2%
Taylor expanded in z around 0 93.3%
associate-/l*98.3%
Simplified98.3%
Taylor expanded in b around 0 87.9%
if -4.2999999999999997e-15 < t < 4.9999999999999996e-78Initial program 60.8%
*-commutative60.8%
associate-*l/56.0%
*-commutative56.0%
associate-*l/50.5%
Simplified50.5%
Taylor expanded in y around inf 60.4%
associate--l+60.4%
times-frac58.2%
associate-*r*61.1%
unpow261.1%
Simplified61.1%
Taylor expanded in b around inf 75.8%
if 4.9999999999999996e-78 < t Initial program 84.9%
*-commutative84.9%
associate-/l*89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-*l/89.9%
associate-+r-89.9%
associate-*l/95.8%
*-commutative95.8%
cancel-sign-sub95.8%
*-commutative95.8%
associate-/r/95.8%
Simplified95.8%
Taylor expanded in x around inf 70.9%
div-inv70.7%
*-commutative70.7%
associate-*l/74.7%
+-commutative74.7%
+-commutative74.7%
associate-+l+74.7%
*-commutative74.7%
Applied egg-rr74.7%
Final simplification78.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -1.04e+65)
t_1
(if (<= t -1.65e-14)
(/ (* y (/ z t)) (+ a 1.0))
(if (<= t 122000000000.0) (/ (+ z (* x (/ t y))) b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -1.04e+65) {
tmp = t_1;
} else if (t <= -1.65e-14) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= 122000000000.0) {
tmp = (z + (x * (t / y))) / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-1.04d+65)) then
tmp = t_1
else if (t <= (-1.65d-14)) then
tmp = (y * (z / t)) / (a + 1.0d0)
else if (t <= 122000000000.0d0) then
tmp = (z + (x * (t / y))) / b
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 b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -1.04e+65) {
tmp = t_1;
} else if (t <= -1.65e-14) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= 122000000000.0) {
tmp = (z + (x * (t / y))) / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -1.04e+65: tmp = t_1 elif t <= -1.65e-14: tmp = (y * (z / t)) / (a + 1.0) elif t <= 122000000000.0: tmp = (z + (x * (t / y))) / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -1.04e+65) tmp = t_1; elseif (t <= -1.65e-14) tmp = Float64(Float64(y * Float64(z / t)) / Float64(a + 1.0)); elseif (t <= 122000000000.0) tmp = Float64(Float64(z + Float64(x * Float64(t / y))) / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -1.04e+65) tmp = t_1; elseif (t <= -1.65e-14) tmp = (y * (z / t)) / (a + 1.0); elseif (t <= 122000000000.0) tmp = (z + (x * (t / y))) / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.04e+65], t$95$1, If[LessEqual[t, -1.65e-14], N[(N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 122000000000.0], N[(N[(z + N[(x * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -1.04 \cdot 10^{+65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.65 \cdot 10^{-14}:\\
\;\;\;\;\frac{y \cdot \frac{z}{t}}{a + 1}\\
\mathbf{elif}\;t \leq 122000000000:\\
\;\;\;\;\frac{z + x \cdot \frac{t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -1.03999999999999999e65 or 1.22e11 < t Initial program 86.6%
*-commutative86.6%
associate-*l/92.1%
*-commutative92.1%
associate-*l/98.3%
Simplified98.3%
Taylor expanded in t around inf 69.2%
if -1.03999999999999999e65 < t < -1.6499999999999999e-14Initial program 92.4%
*-commutative92.4%
associate-*l/92.4%
*-commutative92.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 92.4%
associate-/l*92.7%
Simplified92.7%
Taylor expanded in b around 0 77.8%
Taylor expanded in x around 0 62.8%
associate-*r/62.8%
Simplified62.8%
if -1.6499999999999999e-14 < t < 1.22e11Initial program 64.5%
*-commutative64.5%
associate-*l/60.5%
*-commutative60.5%
associate-*l/55.8%
Simplified55.8%
Taylor expanded in y around inf 57.6%
associate--l+57.6%
times-frac55.7%
associate-*r*59.0%
unpow259.0%
Simplified59.0%
Taylor expanded in b around inf 72.3%
+-commutative72.3%
associate-*l/70.7%
*-commutative70.7%
Simplified70.7%
Final simplification69.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -9e+66)
t_1
(if (<= t -2.12e-13)
(/ (* y (/ z t)) (+ a 1.0))
(if (<= t 320000000.0) (/ (+ z (/ (* x t) y)) b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -9e+66) {
tmp = t_1;
} else if (t <= -2.12e-13) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= 320000000.0) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-9d+66)) then
tmp = t_1
else if (t <= (-2.12d-13)) then
tmp = (y * (z / t)) / (a + 1.0d0)
else if (t <= 320000000.0d0) then
tmp = (z + ((x * t) / y)) / b
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 b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -9e+66) {
tmp = t_1;
} else if (t <= -2.12e-13) {
tmp = (y * (z / t)) / (a + 1.0);
} else if (t <= 320000000.0) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -9e+66: tmp = t_1 elif t <= -2.12e-13: tmp = (y * (z / t)) / (a + 1.0) elif t <= 320000000.0: tmp = (z + ((x * t) / y)) / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -9e+66) tmp = t_1; elseif (t <= -2.12e-13) tmp = Float64(Float64(y * Float64(z / t)) / Float64(a + 1.0)); elseif (t <= 320000000.0) tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -9e+66) tmp = t_1; elseif (t <= -2.12e-13) tmp = (y * (z / t)) / (a + 1.0); elseif (t <= 320000000.0) tmp = (z + ((x * t) / y)) / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9e+66], t$95$1, If[LessEqual[t, -2.12e-13], N[(N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 320000000.0], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -9 \cdot 10^{+66}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -2.12 \cdot 10^{-13}:\\
\;\;\;\;\frac{y \cdot \frac{z}{t}}{a + 1}\\
\mathbf{elif}\;t \leq 320000000:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -8.9999999999999997e66 or 3.2e8 < t Initial program 86.6%
*-commutative86.6%
associate-*l/92.1%
*-commutative92.1%
associate-*l/98.3%
Simplified98.3%
Taylor expanded in t around inf 69.2%
if -8.9999999999999997e66 < t < -2.1200000000000001e-13Initial program 92.4%
*-commutative92.4%
associate-*l/92.4%
*-commutative92.4%
associate-*l/92.4%
Simplified92.4%
Taylor expanded in z around 0 92.4%
associate-/l*92.7%
Simplified92.7%
Taylor expanded in b around 0 77.8%
Taylor expanded in x around 0 62.8%
associate-*r/62.8%
Simplified62.8%
if -2.1200000000000001e-13 < t < 3.2e8Initial program 64.5%
*-commutative64.5%
associate-*l/60.5%
*-commutative60.5%
associate-*l/55.8%
Simplified55.8%
Taylor expanded in y around inf 57.6%
associate--l+57.6%
times-frac55.7%
associate-*r*59.0%
unpow259.0%
Simplified59.0%
Taylor expanded in b around inf 72.3%
Final simplification70.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -9.6e+64)
t_1
(if (<= t -1e-14)
(/ (- z) (/ (* t (- -1.0 a)) y))
(if (<= t 1350000000.0) (/ (+ z (/ (* x t) y)) b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -9.6e+64) {
tmp = t_1;
} else if (t <= -1e-14) {
tmp = -z / ((t * (-1.0 - a)) / y);
} else if (t <= 1350000000.0) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-9.6d+64)) then
tmp = t_1
else if (t <= (-1d-14)) then
tmp = -z / ((t * ((-1.0d0) - a)) / y)
else if (t <= 1350000000.0d0) then
tmp = (z + ((x * t) / y)) / b
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 b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -9.6e+64) {
tmp = t_1;
} else if (t <= -1e-14) {
tmp = -z / ((t * (-1.0 - a)) / y);
} else if (t <= 1350000000.0) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -9.6e+64: tmp = t_1 elif t <= -1e-14: tmp = -z / ((t * (-1.0 - a)) / y) elif t <= 1350000000.0: tmp = (z + ((x * t) / y)) / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -9.6e+64) tmp = t_1; elseif (t <= -1e-14) tmp = Float64(Float64(-z) / Float64(Float64(t * Float64(-1.0 - a)) / y)); elseif (t <= 1350000000.0) tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -9.6e+64) tmp = t_1; elseif (t <= -1e-14) tmp = -z / ((t * (-1.0 - a)) / y); elseif (t <= 1350000000.0) tmp = (z + ((x * t) / y)) / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.6e+64], t$95$1, If[LessEqual[t, -1e-14], N[((-z) / N[(N[(t * N[(-1.0 - a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1350000000.0], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -9.6 \cdot 10^{+64}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-14}:\\
\;\;\;\;\frac{-z}{\frac{t \cdot \left(-1 - a\right)}{y}}\\
\mathbf{elif}\;t \leq 1350000000:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -9.59999999999999997e64 or 1.35e9 < t Initial program 86.6%
*-commutative86.6%
associate-*l/92.1%
*-commutative92.1%
associate-*l/98.3%
Simplified98.3%
Taylor expanded in t around inf 69.2%
if -9.59999999999999997e64 < t < -9.99999999999999999e-15Initial program 92.4%
*-commutative92.4%
associate-/l*85.4%
associate-*l/85.6%
*-commutative85.6%
cancel-sign-sub85.6%
*-commutative85.6%
associate-*l/85.4%
associate-+r-85.4%
associate-*l/85.6%
*-commutative85.6%
cancel-sign-sub85.6%
*-commutative85.6%
associate-/r/85.4%
Simplified85.4%
Taylor expanded in x around 0 77.3%
Taylor expanded in t around inf 62.5%
distribute-lft-in62.5%
*-rgt-identity62.5%
Simplified62.5%
Taylor expanded in t around -inf 62.5%
mul-1-neg62.5%
distribute-neg-frac62.5%
distribute-rgt-neg-out62.5%
*-commutative62.5%
*-commutative62.5%
sub-neg62.5%
metadata-eval62.5%
distribute-lft-in62.5%
neg-mul-162.5%
distribute-rgt-neg-in62.5%
*-commutative62.5%
neg-mul-162.5%
distribute-neg-in62.5%
fma-udef62.5%
associate-/l*62.8%
Simplified62.8%
if -9.99999999999999999e-15 < t < 1.35e9Initial program 64.5%
*-commutative64.5%
associate-*l/60.5%
*-commutative60.5%
associate-*l/55.8%
Simplified55.8%
Taylor expanded in y around inf 57.6%
associate--l+57.6%
times-frac55.7%
associate-*r*59.0%
unpow259.0%
Simplified59.0%
Taylor expanded in b around inf 72.3%
Final simplification70.4%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -1.35e-14) (not (<= t 1.5e-51))) (/ (+ x (* y (/ z t))) (+ a 1.0)) (/ (+ z (/ (* x t) y)) b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -1.35e-14) || !(t <= 1.5e-51)) {
tmp = (x + (y * (z / t))) / (a + 1.0);
} else {
tmp = (z + ((x * t) / y)) / b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t <= (-1.35d-14)) .or. (.not. (t <= 1.5d-51))) then
tmp = (x + (y * (z / t))) / (a + 1.0d0)
else
tmp = (z + ((x * t) / y)) / b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -1.35e-14) || !(t <= 1.5e-51)) {
tmp = (x + (y * (z / t))) / (a + 1.0);
} else {
tmp = (z + ((x * t) / y)) / b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -1.35e-14) or not (t <= 1.5e-51): tmp = (x + (y * (z / t))) / (a + 1.0) else: tmp = (z + ((x * t) / y)) / b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -1.35e-14) || !(t <= 1.5e-51)) tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(a + 1.0)); else tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -1.35e-14) || ~((t <= 1.5e-51))) tmp = (x + (y * (z / t))) / (a + 1.0); else tmp = (z + ((x * t) / y)) / b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -1.35e-14], N[Not[LessEqual[t, 1.5e-51]], $MachinePrecision]], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.35 \cdot 10^{-14} \lor \neg \left(t \leq 1.5 \cdot 10^{-51}\right):\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{a + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\end{array}
\end{array}
if t < -1.3499999999999999e-14 or 1.50000000000000001e-51 < t Initial program 86.4%
*-commutative86.4%
associate-*l/90.9%
*-commutative90.9%
associate-*l/96.0%
Simplified96.0%
Taylor expanded in b around 0 79.7%
if -1.3499999999999999e-14 < t < 1.50000000000000001e-51Initial program 62.6%
*-commutative62.6%
associate-*l/58.0%
*-commutative58.0%
associate-*l/52.8%
Simplified52.8%
Taylor expanded in y around inf 60.3%
associate--l+60.3%
times-frac58.3%
associate-*r*61.0%
unpow261.0%
Simplified61.0%
Taylor expanded in b around inf 75.1%
Final simplification77.8%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -2.2e-15)
(/ (+ x (/ y (/ t z))) (+ a 1.0))
(if (<= t 1.85e-50)
(/ (+ z (/ (* x t) y)) b)
(/ (+ x (* y (/ z t))) (+ a 1.0)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.2e-15) {
tmp = (x + (y / (t / z))) / (a + 1.0);
} else if (t <= 1.85e-50) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = (x + (y * (z / t))) / (a + 1.0);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-2.2d-15)) then
tmp = (x + (y / (t / z))) / (a + 1.0d0)
else if (t <= 1.85d-50) then
tmp = (z + ((x * t) / y)) / b
else
tmp = (x + (y * (z / t))) / (a + 1.0d0)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.2e-15) {
tmp = (x + (y / (t / z))) / (a + 1.0);
} else if (t <= 1.85e-50) {
tmp = (z + ((x * t) / y)) / b;
} else {
tmp = (x + (y * (z / t))) / (a + 1.0);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -2.2e-15: tmp = (x + (y / (t / z))) / (a + 1.0) elif t <= 1.85e-50: tmp = (z + ((x * t) / y)) / b else: tmp = (x + (y * (z / t))) / (a + 1.0) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -2.2e-15) tmp = Float64(Float64(x + Float64(y / Float64(t / z))) / Float64(a + 1.0)); elseif (t <= 1.85e-50) tmp = Float64(Float64(z + Float64(Float64(x * t) / y)) / b); else tmp = Float64(Float64(x + Float64(y * Float64(z / t))) / Float64(a + 1.0)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -2.2e-15) tmp = (x + (y / (t / z))) / (a + 1.0); elseif (t <= 1.85e-50) tmp = (z + ((x * t) / y)) / b; else tmp = (x + (y * (z / t))) / (a + 1.0); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.2e-15], N[(N[(x + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.85e-50], N[(N[(z + N[(N[(x * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision], N[(N[(x + N[(y * N[(z / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.2 \cdot 10^{-15}:\\
\;\;\;\;\frac{x + \frac{y}{\frac{t}{z}}}{a + 1}\\
\mathbf{elif}\;t \leq 1.85 \cdot 10^{-50}:\\
\;\;\;\;\frac{z + \frac{x \cdot t}{y}}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{x + y \cdot \frac{z}{t}}{a + 1}\\
\end{array}
\end{array}
if t < -2.19999999999999986e-15Initial program 90.0%
*-commutative90.0%
associate-*l/94.9%
*-commutative94.9%
associate-*l/98.2%
Simplified98.2%
Taylor expanded in z around 0 93.3%
associate-/l*98.3%
Simplified98.3%
Taylor expanded in b around 0 87.9%
if -2.19999999999999986e-15 < t < 1.85e-50Initial program 62.6%
*-commutative62.6%
associate-*l/58.0%
*-commutative58.0%
associate-*l/52.8%
Simplified52.8%
Taylor expanded in y around inf 60.3%
associate--l+60.3%
times-frac58.3%
associate-*r*61.0%
unpow261.0%
Simplified61.0%
Taylor expanded in b around inf 75.1%
if 1.85e-50 < t Initial program 84.1%
*-commutative84.1%
associate-*l/88.3%
*-commutative88.3%
associate-*l/94.5%
Simplified94.5%
Taylor expanded in b around 0 74.5%
Final simplification77.8%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -4.1e+67) (not (<= t 1e-75))) (/ x (+ a 1.0)) (/ z b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -4.1e+67) || !(t <= 1e-75)) {
tmp = x / (a + 1.0);
} else {
tmp = z / b;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if ((t <= (-4.1d+67)) .or. (.not. (t <= 1d-75))) then
tmp = x / (a + 1.0d0)
else
tmp = z / b
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -4.1e+67) || !(t <= 1e-75)) {
tmp = x / (a + 1.0);
} else {
tmp = z / b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -4.1e+67) or not (t <= 1e-75): tmp = x / (a + 1.0) else: tmp = z / b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -4.1e+67) || !(t <= 1e-75)) tmp = Float64(x / Float64(a + 1.0)); else tmp = Float64(z / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -4.1e+67) || ~((t <= 1e-75))) tmp = x / (a + 1.0); else tmp = z / b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -4.1e+67], N[Not[LessEqual[t, 1e-75]], $MachinePrecision]], N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], N[(z / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.1 \cdot 10^{+67} \lor \neg \left(t \leq 10^{-75}\right):\\
\;\;\;\;\frac{x}{a + 1}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if t < -4.09999999999999979e67 or 9.9999999999999996e-76 < t Initial program 86.9%
*-commutative86.9%
associate-*l/91.0%
*-commutative91.0%
associate-*l/96.4%
Simplified96.4%
Taylor expanded in t around inf 66.4%
if -4.09999999999999979e67 < t < 9.9999999999999996e-76Initial program 63.8%
*-commutative63.8%
associate-*l/60.4%
*-commutative60.4%
associate-*l/55.6%
Simplified55.6%
Taylor expanded in t around 0 58.0%
Final simplification62.6%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4.1e+67) (/ x a) (if (<= t 0.22) (/ z b) (- x (* x a)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.1e+67) {
tmp = x / a;
} else if (t <= 0.22) {
tmp = z / b;
} else {
tmp = x - (x * a);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-4.1d+67)) then
tmp = x / a
else if (t <= 0.22d0) then
tmp = z / b
else
tmp = x - (x * a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.1e+67) {
tmp = x / a;
} else if (t <= 0.22) {
tmp = z / b;
} else {
tmp = x - (x * a);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.1e+67: tmp = x / a elif t <= 0.22: tmp = z / b else: tmp = x - (x * a) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.1e+67) tmp = Float64(x / a); elseif (t <= 0.22) tmp = Float64(z / b); else tmp = Float64(x - Float64(x * a)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.1e+67) tmp = x / a; elseif (t <= 0.22) tmp = z / b; else tmp = x - (x * a); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.1e+67], N[(x / a), $MachinePrecision], If[LessEqual[t, 0.22], N[(z / b), $MachinePrecision], N[(x - N[(x * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.1 \cdot 10^{+67}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t \leq 0.22:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;x - x \cdot a\\
\end{array}
\end{array}
if t < -4.09999999999999979e67Initial program 91.3%
*-commutative91.3%
associate-/l*95.6%
associate-*l/99.9%
*-commutative99.9%
cancel-sign-sub99.9%
*-commutative99.9%
associate-*l/95.6%
associate-+r-95.6%
associate-*l/99.9%
*-commutative99.9%
cancel-sign-sub99.9%
*-commutative99.9%
associate-/r/99.9%
Simplified99.9%
Taylor expanded in x around inf 85.3%
Taylor expanded in a around inf 49.1%
if -4.09999999999999979e67 < t < 0.220000000000000001Initial program 66.5%
*-commutative66.5%
associate-*l/63.5%
*-commutative63.5%
associate-*l/59.4%
Simplified59.4%
Taylor expanded in t around 0 54.4%
if 0.220000000000000001 < t Initial program 85.2%
*-commutative85.2%
associate-*l/90.1%
*-commutative90.1%
associate-*l/97.4%
Simplified97.4%
Taylor expanded in t around inf 59.3%
Taylor expanded in a around 0 35.2%
+-commutative35.2%
mul-1-neg35.2%
unsub-neg35.2%
Simplified35.2%
Final simplification47.6%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4.4e+67) (/ x a) (if (<= t 3.3e-71) (/ z b) (/ x a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.4e+67) {
tmp = x / a;
} else if (t <= 3.3e-71) {
tmp = z / b;
} else {
tmp = x / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (t <= (-4.4d+67)) then
tmp = x / a
else if (t <= 3.3d-71) then
tmp = z / b
else
tmp = x / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.4e+67) {
tmp = x / a;
} else if (t <= 3.3e-71) {
tmp = z / b;
} else {
tmp = x / a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.4e+67: tmp = x / a elif t <= 3.3e-71: tmp = z / b else: tmp = x / a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.4e+67) tmp = Float64(x / a); elseif (t <= 3.3e-71) tmp = Float64(z / b); else tmp = Float64(x / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.4e+67) tmp = x / a; elseif (t <= 3.3e-71) tmp = z / b; else tmp = x / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.4e+67], N[(x / a), $MachinePrecision], If[LessEqual[t, 3.3e-71], N[(z / b), $MachinePrecision], N[(x / a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.4 \cdot 10^{+67}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t \leq 3.3 \cdot 10^{-71}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a}\\
\end{array}
\end{array}
if t < -4.4e67 or 3.3000000000000002e-71 < t Initial program 86.7%
*-commutative86.7%
associate-/l*91.6%
associate-*l/97.1%
*-commutative97.1%
cancel-sign-sub97.1%
*-commutative97.1%
associate-*l/91.6%
associate-+r-91.6%
associate-*l/97.1%
*-commutative97.1%
cancel-sign-sub97.1%
*-commutative97.1%
associate-/r/97.1%
Simplified97.1%
Taylor expanded in x around inf 75.1%
Taylor expanded in a around inf 35.1%
if -4.4e67 < t < 3.3000000000000002e-71Initial program 64.4%
*-commutative64.4%
associate-*l/61.1%
*-commutative61.1%
associate-*l/56.4%
Simplified56.4%
Taylor expanded in t around 0 57.9%
Final simplification45.6%
(FPCore (x y z t a b) :precision binary64 (/ x a))
double code(double x, double y, double z, double t, double a, double b) {
return x / a;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / a;
}
def code(x, y, z, t, a, b): return x / a
function code(x, y, z, t, a, b) return Float64(x / a) end
function tmp = code(x, y, z, t, a, b) tmp = x / a; end
code[x_, y_, z_, t_, a_, b_] := N[(x / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{a}
\end{array}
Initial program 76.5%
*-commutative76.5%
associate-/l*76.3%
associate-*l/77.6%
*-commutative77.6%
cancel-sign-sub77.6%
*-commutative77.6%
associate-*l/76.3%
associate-+r-76.3%
associate-*l/77.6%
*-commutative77.6%
cancel-sign-sub77.6%
*-commutative77.6%
associate-/r/76.0%
Simplified76.0%
Taylor expanded in x around inf 55.7%
Taylor expanded in a around inf 24.1%
Final simplification24.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(* 1.0 (* (+ x (* (/ y t) z)) (/ 1.0 (+ (+ a 1.0) (* (/ y t) b)))))))
(if (< t -1.3659085366310088e-271)
t_1
(if (< t 3.036967103737246e-130) (/ z b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b))));
double tmp;
if (t < -1.3659085366310088e-271) {
tmp = t_1;
} else if (t < 3.036967103737246e-130) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = 1.0d0 * ((x + ((y / t) * z)) * (1.0d0 / ((a + 1.0d0) + ((y / t) * b))))
if (t < (-1.3659085366310088d-271)) then
tmp = t_1
else if (t < 3.036967103737246d-130) then
tmp = z / b
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 b) {
double t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b))));
double tmp;
if (t < -1.3659085366310088e-271) {
tmp = t_1;
} else if (t < 3.036967103737246e-130) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b)))) tmp = 0 if t < -1.3659085366310088e-271: tmp = t_1 elif t < 3.036967103737246e-130: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(1.0 * Float64(Float64(x + Float64(Float64(y / t) * z)) * Float64(1.0 / Float64(Float64(a + 1.0) + Float64(Float64(y / t) * b))))) tmp = 0.0 if (t < -1.3659085366310088e-271) tmp = t_1; elseif (t < 3.036967103737246e-130) tmp = Float64(z / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b)))); tmp = 0.0; if (t < -1.3659085366310088e-271) tmp = t_1; elseif (t < 3.036967103737246e-130) tmp = z / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(1.0 * N[(N[(x + N[(N[(y / t), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y / t), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -1.3659085366310088e-271], t$95$1, If[Less[t, 3.036967103737246e-130], N[(z / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 1 \cdot \left(\left(x + \frac{y}{t} \cdot z\right) \cdot \frac{1}{\left(a + 1\right) + \frac{y}{t} \cdot b}\right)\\
\mathbf{if}\;t < -1.3659085366310088 \cdot 10^{-271}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t < 3.036967103737246 \cdot 10^{-130}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
herbie shell --seed 2023274
(FPCore (x y z t a b)
:name "Diagrams.Solve.Tridiagonal:solveCyclicTriDiagonal from diagrams-solve-0.1, B"
:precision binary64
:herbie-target
(if (< t -1.3659085366310088e-271) (* 1.0 (* (+ x (* (/ y t) z)) (/ 1.0 (+ (+ a 1.0) (* (/ y t) b))))) (if (< t 3.036967103737246e-130) (/ z b) (* 1.0 (* (+ x (* (/ y t) z)) (/ 1.0 (+ (+ a 1.0) (* (/ y t) b)))))))
(/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))