
(FPCore (x y z t a b) :precision binary64 (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)))
double code(double x, double y, double z, double t, double a, double b) {
return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y);
}
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 + y) * a)) - (y * b)) / ((x + t) + y)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y);
}
def code(x, y, z, t, a, b): return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(Float64(Float64(x + y) * z) + Float64(Float64(t + y) * a)) - Float64(y * b)) / Float64(Float64(x + t) + y)) end
function tmp = code(x, y, z, t, a, b) tmp = ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(N[(N[(x + y), $MachinePrecision] * z), $MachinePrecision] + N[(N[(t + y), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(N[(x + t), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(x + y\right) \cdot z + \left(t + y\right) \cdot a\right) - y \cdot b}{\left(x + t\right) + y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)))
double code(double x, double y, double z, double t, double a, double b) {
return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y);
}
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 + y) * a)) - (y * b)) / ((x + t) + y)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y);
}
def code(x, y, z, t, a, b): return ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y)
function code(x, y, z, t, a, b) return Float64(Float64(Float64(Float64(Float64(x + y) * z) + Float64(Float64(t + y) * a)) - Float64(y * b)) / Float64(Float64(x + t) + y)) end
function tmp = code(x, y, z, t, a, b) tmp = ((((x + y) * z) + ((t + y) * a)) - (y * b)) / ((x + t) + y); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(N[(N[(N[(x + y), $MachinePrecision] * z), $MachinePrecision] + N[(N[(t + y), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(N[(x + t), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(x + y\right) \cdot z + \left(t + y\right) \cdot a\right) - y \cdot b}{\left(x + t\right) + y}
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ y t)))
(t_2 (+ y (+ x t)))
(t_3 (/ (- (+ (* z (+ x y)) (* (+ y t) a)) (* y b)) t_2)))
(if (<= t_3 (- INFINITY))
(- (+ z a) b)
(if (<= t_3 1e+269)
t_3
(if (<= t_3 INFINITY)
(+ (* a (/ (+ y t) t_1)) (* z (/ (+ x y) t_1)))
(/ (+ a (- z b)) (/ t_2 y)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y + t);
double t_2 = y + (x + t);
double t_3 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_2;
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = (z + a) - b;
} else if (t_3 <= 1e+269) {
tmp = t_3;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (a * ((y + t) / t_1)) + (z * ((x + y) / t_1));
} else {
tmp = (a + (z - b)) / (t_2 / y);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y + t);
double t_2 = y + (x + t);
double t_3 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_2;
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = (z + a) - b;
} else if (t_3 <= 1e+269) {
tmp = t_3;
} else if (t_3 <= Double.POSITIVE_INFINITY) {
tmp = (a * ((y + t) / t_1)) + (z * ((x + y) / t_1));
} else {
tmp = (a + (z - b)) / (t_2 / y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (y + t) t_2 = y + (x + t) t_3 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_2 tmp = 0 if t_3 <= -math.inf: tmp = (z + a) - b elif t_3 <= 1e+269: tmp = t_3 elif t_3 <= math.inf: tmp = (a * ((y + t) / t_1)) + (z * ((x + y) / t_1)) else: tmp = (a + (z - b)) / (t_2 / y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(y + t)) t_2 = Float64(y + Float64(x + t)) t_3 = Float64(Float64(Float64(Float64(z * Float64(x + y)) + Float64(Float64(y + t) * a)) - Float64(y * b)) / t_2) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64(z + a) - b); elseif (t_3 <= 1e+269) tmp = t_3; elseif (t_3 <= Inf) tmp = Float64(Float64(a * Float64(Float64(y + t) / t_1)) + Float64(z * Float64(Float64(x + y) / t_1))); else tmp = Float64(Float64(a + Float64(z - b)) / Float64(t_2 / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (y + t); t_2 = y + (x + t); t_3 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_2; tmp = 0.0; if (t_3 <= -Inf) tmp = (z + a) - b; elseif (t_3 <= 1e+269) tmp = t_3; elseif (t_3 <= Inf) tmp = (a * ((y + t) / t_1)) + (z * ((x + y) / t_1)); else tmp = (a + (z - b)) / (t_2 / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(z * N[(x + y), $MachinePrecision]), $MachinePrecision] + N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[t$95$3, 1e+269], t$95$3, If[LessEqual[t$95$3, Infinity], N[(N[(a * N[(N[(y + t), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(t$95$2 / y), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y + t\right)\\
t_2 := y + \left(x + t\right)\\
t_3 := \frac{\left(z \cdot \left(x + y\right) + \left(y + t\right) \cdot a\right) - y \cdot b}{t\_2}\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;t\_3 \leq 10^{+269}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;a \cdot \frac{y + t}{t\_1} + z \cdot \frac{x + y}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{a + \left(z - b\right)}{\frac{t\_2}{y}}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < -inf.0Initial program 6.5%
Taylor expanded in y around inf 83.9%
if -inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 1e269Initial program 99.1%
if 1e269 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < +inf.0Initial program 7.7%
Taylor expanded in b around inf 17.6%
+-commutative17.6%
mul-1-neg17.6%
unsub-neg17.6%
Simplified60.7%
Taylor expanded in b around 0 7.1%
associate-/l*47.8%
+-commutative47.8%
associate-+r+47.8%
+-commutative47.8%
associate-+r+47.8%
associate-/l*84.5%
+-commutative84.5%
associate-+r+84.5%
+-commutative84.5%
associate-+r+84.5%
Simplified84.5%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 0.0%
Taylor expanded in y around inf 6.0%
clear-num6.0%
inv-pow6.0%
+-commutative6.0%
+-commutative6.0%
associate--l+6.0%
Applied egg-rr6.0%
unpow-16.0%
associate-+r-6.0%
associate-/r*83.5%
associate-+r+83.5%
associate-+r-83.5%
Simplified83.5%
clear-num83.6%
add-cube-cbrt81.6%
*-un-lft-identity81.6%
times-frac81.6%
pow281.6%
+-commutative81.6%
associate-+l-81.6%
+-commutative81.6%
associate-+l-81.6%
associate-+l+81.6%
Applied egg-rr81.6%
/-rgt-identity81.6%
associate-*r/81.6%
unpow281.6%
rem-3cbrt-lft83.6%
associate--r-83.6%
Simplified83.6%
Final simplification92.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t)))
(t_2 (/ (- (+ (* z (+ x y)) (* (+ y t) a)) (* y b)) t_1)))
(if (<= t_2 (- INFINITY))
(- (+ z a) b)
(if (<= t_2 5e+277)
t_2
(if (<= t_2 INFINITY)
(+ z (* a (/ (+ y t) (+ x (+ y t)))))
(/ (+ a (- z b)) (/ t_1 y)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1;
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = (z + a) - b;
} else if (t_2 <= 5e+277) {
tmp = t_2;
} else if (t_2 <= ((double) INFINITY)) {
tmp = z + (a * ((y + t) / (x + (y + t))));
} else {
tmp = (a + (z - b)) / (t_1 / y);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1;
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = (z + a) - b;
} else if (t_2 <= 5e+277) {
tmp = t_2;
} else if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = z + (a * ((y + t) / (x + (y + t))));
} else {
tmp = (a + (z - b)) / (t_1 / y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1 tmp = 0 if t_2 <= -math.inf: tmp = (z + a) - b elif t_2 <= 5e+277: tmp = t_2 elif t_2 <= math.inf: tmp = z + (a * ((y + t) / (x + (y + t)))) else: tmp = (a + (z - b)) / (t_1 / y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(Float64(Float64(Float64(z * Float64(x + y)) + Float64(Float64(y + t) * a)) - Float64(y * b)) / t_1) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(Float64(z + a) - b); elseif (t_2 <= 5e+277) tmp = t_2; elseif (t_2 <= Inf) tmp = Float64(z + Float64(a * Float64(Float64(y + t) / Float64(x + Float64(y + t))))); else tmp = Float64(Float64(a + Float64(z - b)) / Float64(t_1 / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1; tmp = 0.0; if (t_2 <= -Inf) tmp = (z + a) - b; elseif (t_2 <= 5e+277) tmp = t_2; elseif (t_2 <= Inf) tmp = z + (a * ((y + t) / (x + (y + t)))); else tmp = (a + (z - b)) / (t_1 / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(z * N[(x + y), $MachinePrecision]), $MachinePrecision] + N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[t$95$2, 5e+277], t$95$2, If[LessEqual[t$95$2, Infinity], N[(z + N[(a * N[(N[(y + t), $MachinePrecision] / N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := \frac{\left(z \cdot \left(x + y\right) + \left(y + t\right) \cdot a\right) - y \cdot b}{t\_1}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+277}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;z + a \cdot \frac{y + t}{x + \left(y + t\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{a + \left(z - b\right)}{\frac{t\_1}{y}}\\
\end{array}
\end{array}
if (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < -inf.0Initial program 6.5%
Taylor expanded in y around inf 83.9%
if -inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 4.99999999999999982e277Initial program 99.1%
if 4.99999999999999982e277 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < +inf.0Initial program 5.6%
Taylor expanded in b around inf 17.8%
+-commutative17.8%
mul-1-neg17.8%
unsub-neg17.8%
Simplified61.9%
Taylor expanded in b around 0 5.0%
associate-/l*46.6%
+-commutative46.6%
associate-+r+46.6%
+-commutative46.6%
associate-+r+46.6%
associate-/l*84.1%
+-commutative84.1%
associate-+r+84.1%
+-commutative84.1%
associate-+r+84.1%
Simplified84.1%
Taylor expanded in y around inf 72.1%
if +inf.0 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 0.0%
Taylor expanded in y around inf 6.0%
clear-num6.0%
inv-pow6.0%
+-commutative6.0%
+-commutative6.0%
associate--l+6.0%
Applied egg-rr6.0%
unpow-16.0%
associate-+r-6.0%
associate-/r*83.5%
associate-+r+83.5%
associate-+r-83.5%
Simplified83.5%
clear-num83.6%
add-cube-cbrt81.6%
*-un-lft-identity81.6%
times-frac81.6%
pow281.6%
+-commutative81.6%
associate-+l-81.6%
+-commutative81.6%
associate-+l-81.6%
associate-+l+81.6%
Applied egg-rr81.6%
/-rgt-identity81.6%
associate-*r/81.6%
unpow281.6%
rem-3cbrt-lft83.6%
associate--r-83.6%
Simplified83.6%
Final simplification90.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))) (t_2 (/ y t_1)))
(if (<= y -1.82e-68)
(- (+ z a) b)
(if (<= y -7.7e-137)
(* z (/ (+ x y) t_1))
(if (<= y -2.5e-162)
(/ a (/ t_1 (+ y t)))
(if (<= y 2.05e-125)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 2.9e-46)
(* b (- (/ z b) t_2))
(if (<= y 4.8e+53)
(* b (- (/ a b) t_2))
(* y (/ (+ a (- z b)) (+ x y)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = y / t_1;
double tmp;
if (y <= -1.82e-68) {
tmp = (z + a) - b;
} else if (y <= -7.7e-137) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.5e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 2.05e-125) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 2.9e-46) {
tmp = b * ((z / b) - t_2);
} else if (y <= 4.8e+53) {
tmp = b * ((a / b) - t_2);
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
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 + (x + t)
t_2 = y / t_1
if (y <= (-1.82d-68)) then
tmp = (z + a) - b
else if (y <= (-7.7d-137)) then
tmp = z * ((x + y) / t_1)
else if (y <= (-2.5d-162)) then
tmp = a / (t_1 / (y + t))
else if (y <= 2.05d-125) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 2.9d-46) then
tmp = b * ((z / b) - t_2)
else if (y <= 4.8d+53) then
tmp = b * ((a / b) - t_2)
else
tmp = y * ((a + (z - b)) / (x + y))
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 + (x + t);
double t_2 = y / t_1;
double tmp;
if (y <= -1.82e-68) {
tmp = (z + a) - b;
} else if (y <= -7.7e-137) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.5e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 2.05e-125) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 2.9e-46) {
tmp = b * ((z / b) - t_2);
} else if (y <= 4.8e+53) {
tmp = b * ((a / b) - t_2);
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = y / t_1 tmp = 0 if y <= -1.82e-68: tmp = (z + a) - b elif y <= -7.7e-137: tmp = z * ((x + y) / t_1) elif y <= -2.5e-162: tmp = a / (t_1 / (y + t)) elif y <= 2.05e-125: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 2.9e-46: tmp = b * ((z / b) - t_2) elif y <= 4.8e+53: tmp = b * ((a / b) - t_2) else: tmp = y * ((a + (z - b)) / (x + y)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(y / t_1) tmp = 0.0 if (y <= -1.82e-68) tmp = Float64(Float64(z + a) - b); elseif (y <= -7.7e-137) tmp = Float64(z * Float64(Float64(x + y) / t_1)); elseif (y <= -2.5e-162) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif (y <= 2.05e-125) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 2.9e-46) tmp = Float64(b * Float64(Float64(z / b) - t_2)); elseif (y <= 4.8e+53) tmp = Float64(b * Float64(Float64(a / b) - t_2)); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / Float64(x + y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = y / t_1; tmp = 0.0; if (y <= -1.82e-68) tmp = (z + a) - b; elseif (y <= -7.7e-137) tmp = z * ((x + y) / t_1); elseif (y <= -2.5e-162) tmp = a / (t_1 / (y + t)); elseif (y <= 2.05e-125) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 2.9e-46) tmp = b * ((z / b) - t_2); elseif (y <= 4.8e+53) tmp = b * ((a / b) - t_2); else tmp = y * ((a + (z - b)) / (x + y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y / t$95$1), $MachinePrecision]}, If[LessEqual[y, -1.82e-68], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[y, -7.7e-137], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.5e-162], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.05e-125], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.9e-46], N[(b * N[(N[(z / b), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.8e+53], N[(b * N[(N[(a / b), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := \frac{y}{t\_1}\\
\mathbf{if}\;y \leq -1.82 \cdot 10^{-68}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;y \leq -7.7 \cdot 10^{-137}:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{elif}\;y \leq -2.5 \cdot 10^{-162}:\\
\;\;\;\;\frac{a}{\frac{t\_1}{y + t}}\\
\mathbf{elif}\;y \leq 2.05 \cdot 10^{-125}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{-46}:\\
\;\;\;\;b \cdot \left(\frac{z}{b} - t\_2\right)\\
\mathbf{elif}\;y \leq 4.8 \cdot 10^{+53}:\\
\;\;\;\;b \cdot \left(\frac{a}{b} - t\_2\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{x + y}\\
\end{array}
\end{array}
if y < -1.81999999999999994e-68Initial program 46.6%
Taylor expanded in y around inf 80.2%
if -1.81999999999999994e-68 < y < -7.7000000000000004e-137Initial program 68.1%
Taylor expanded in z around inf 39.8%
associate-/l*63.6%
+-commutative63.6%
+-commutative63.6%
associate-+r+63.6%
+-commutative63.6%
associate-+l+63.6%
Simplified63.6%
if -7.7000000000000004e-137 < y < -2.50000000000000007e-162Initial program 68.3%
Taylor expanded in b around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified78.1%
Taylor expanded in a around -inf 68.3%
associate-/l*99.5%
+-commutative99.5%
associate-+r+99.5%
+-commutative99.5%
associate-+r+99.5%
Simplified99.5%
clear-num99.7%
un-div-inv99.8%
associate-+l+99.8%
Applied egg-rr99.8%
if -2.50000000000000007e-162 < y < 2.0499999999999999e-125Initial program 83.4%
Taylor expanded in y around 0 68.6%
if 2.0499999999999999e-125 < y < 2.90000000000000005e-46Initial program 94.3%
Taylor expanded in b around inf 82.4%
+-commutative82.4%
mul-1-neg82.4%
unsub-neg82.4%
Simplified82.5%
Taylor expanded in x around inf 68.5%
if 2.90000000000000005e-46 < y < 4.8e53Initial program 75.5%
Taylor expanded in b around inf 66.4%
+-commutative66.4%
mul-1-neg66.4%
unsub-neg66.4%
Simplified70.9%
Taylor expanded in t around inf 75.4%
if 4.8e53 < y Initial program 27.9%
Taylor expanded in y around inf 24.9%
clear-num24.8%
inv-pow24.8%
+-commutative24.8%
+-commutative24.8%
associate--l+24.8%
Applied egg-rr24.8%
unpow-124.8%
associate-+r-24.8%
associate-/r*90.2%
associate-+r+90.2%
associate-+r-90.2%
Simplified90.2%
Taylor expanded in t around 0 21.8%
associate-/l*78.7%
associate--l+78.7%
+-commutative78.7%
Simplified78.7%
Final simplification76.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))) (t_2 (/ y t_1)))
(if (<= y -7.8e-69)
(- (+ z a) b)
(if (<= y -4.2e-138)
(* z (/ (+ x y) t_1))
(if (<= y -1.9e-162)
(/ a (/ t_1 (+ y t)))
(if (<= y 8.5e-123)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 5.9e-49)
(* b (- (/ z b) t_2))
(if (<= y 1.1e+54)
(* b (- (/ a b) t_2))
(* y (/ (+ a (- z b)) (+ x (+ y t))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = y / t_1;
double tmp;
if (y <= -7.8e-69) {
tmp = (z + a) - b;
} else if (y <= -4.2e-138) {
tmp = z * ((x + y) / t_1);
} else if (y <= -1.9e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 8.5e-123) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 5.9e-49) {
tmp = b * ((z / b) - t_2);
} else if (y <= 1.1e+54) {
tmp = b * ((a / b) - t_2);
} else {
tmp = y * ((a + (z - b)) / (x + (y + 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y + (x + t)
t_2 = y / t_1
if (y <= (-7.8d-69)) then
tmp = (z + a) - b
else if (y <= (-4.2d-138)) then
tmp = z * ((x + y) / t_1)
else if (y <= (-1.9d-162)) then
tmp = a / (t_1 / (y + t))
else if (y <= 8.5d-123) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 5.9d-49) then
tmp = b * ((z / b) - t_2)
else if (y <= 1.1d+54) then
tmp = b * ((a / b) - t_2)
else
tmp = y * ((a + (z - b)) / (x + (y + t)))
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 + (x + t);
double t_2 = y / t_1;
double tmp;
if (y <= -7.8e-69) {
tmp = (z + a) - b;
} else if (y <= -4.2e-138) {
tmp = z * ((x + y) / t_1);
} else if (y <= -1.9e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 8.5e-123) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 5.9e-49) {
tmp = b * ((z / b) - t_2);
} else if (y <= 1.1e+54) {
tmp = b * ((a / b) - t_2);
} else {
tmp = y * ((a + (z - b)) / (x + (y + t)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = y / t_1 tmp = 0 if y <= -7.8e-69: tmp = (z + a) - b elif y <= -4.2e-138: tmp = z * ((x + y) / t_1) elif y <= -1.9e-162: tmp = a / (t_1 / (y + t)) elif y <= 8.5e-123: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 5.9e-49: tmp = b * ((z / b) - t_2) elif y <= 1.1e+54: tmp = b * ((a / b) - t_2) else: tmp = y * ((a + (z - b)) / (x + (y + t))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(y / t_1) tmp = 0.0 if (y <= -7.8e-69) tmp = Float64(Float64(z + a) - b); elseif (y <= -4.2e-138) tmp = Float64(z * Float64(Float64(x + y) / t_1)); elseif (y <= -1.9e-162) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif (y <= 8.5e-123) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 5.9e-49) tmp = Float64(b * Float64(Float64(z / b) - t_2)); elseif (y <= 1.1e+54) tmp = Float64(b * Float64(Float64(a / b) - t_2)); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / Float64(x + Float64(y + t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = y / t_1; tmp = 0.0; if (y <= -7.8e-69) tmp = (z + a) - b; elseif (y <= -4.2e-138) tmp = z * ((x + y) / t_1); elseif (y <= -1.9e-162) tmp = a / (t_1 / (y + t)); elseif (y <= 8.5e-123) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 5.9e-49) tmp = b * ((z / b) - t_2); elseif (y <= 1.1e+54) tmp = b * ((a / b) - t_2); else tmp = y * ((a + (z - b)) / (x + (y + t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y / t$95$1), $MachinePrecision]}, If[LessEqual[y, -7.8e-69], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[y, -4.2e-138], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.9e-162], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.5e-123], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.9e-49], N[(b * N[(N[(z / b), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+54], N[(b * N[(N[(a / b), $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := \frac{y}{t\_1}\\
\mathbf{if}\;y \leq -7.8 \cdot 10^{-69}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;y \leq -4.2 \cdot 10^{-138}:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{elif}\;y \leq -1.9 \cdot 10^{-162}:\\
\;\;\;\;\frac{a}{\frac{t\_1}{y + t}}\\
\mathbf{elif}\;y \leq 8.5 \cdot 10^{-123}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 5.9 \cdot 10^{-49}:\\
\;\;\;\;b \cdot \left(\frac{z}{b} - t\_2\right)\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+54}:\\
\;\;\;\;b \cdot \left(\frac{a}{b} - t\_2\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{x + \left(y + t\right)}\\
\end{array}
\end{array}
if y < -7.79999999999999961e-69Initial program 46.6%
Taylor expanded in y around inf 80.2%
if -7.79999999999999961e-69 < y < -4.19999999999999972e-138Initial program 68.1%
Taylor expanded in z around inf 39.8%
associate-/l*63.6%
+-commutative63.6%
+-commutative63.6%
associate-+r+63.6%
+-commutative63.6%
associate-+l+63.6%
Simplified63.6%
if -4.19999999999999972e-138 < y < -1.90000000000000002e-162Initial program 68.3%
Taylor expanded in b around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified78.1%
Taylor expanded in a around -inf 68.3%
associate-/l*99.5%
+-commutative99.5%
associate-+r+99.5%
+-commutative99.5%
associate-+r+99.5%
Simplified99.5%
clear-num99.7%
un-div-inv99.8%
associate-+l+99.8%
Applied egg-rr99.8%
if -1.90000000000000002e-162 < y < 8.4999999999999995e-123Initial program 83.4%
Taylor expanded in y around 0 68.6%
if 8.4999999999999995e-123 < y < 5.90000000000000037e-49Initial program 94.3%
Taylor expanded in b around inf 82.4%
+-commutative82.4%
mul-1-neg82.4%
unsub-neg82.4%
Simplified82.5%
Taylor expanded in x around inf 68.5%
if 5.90000000000000037e-49 < y < 1.09999999999999995e54Initial program 75.5%
Taylor expanded in b around inf 66.4%
+-commutative66.4%
mul-1-neg66.4%
unsub-neg66.4%
Simplified70.9%
Taylor expanded in t around inf 75.4%
if 1.09999999999999995e54 < y Initial program 27.9%
Taylor expanded in y around inf 24.9%
associate-/l*90.3%
associate--l+90.3%
+-commutative90.3%
+-commutative90.3%
Applied egg-rr90.3%
associate-+r+90.3%
Simplified90.3%
Final simplification78.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ y t))))
(if (<= b -1.65e+110)
(* b (- (/ z b) (/ y (+ y (+ x t)))))
(if (<= b -660000000.0)
(+ a (* z (/ (+ x y) t_1)))
(if (or (<= b 1.95e+43) (and (not (<= b 2.95e+233)) (<= b 4.75e+247)))
(+ z (* a (/ (+ y t) t_1)))
(* y (/ (+ a (- z b)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y + t);
double tmp;
if (b <= -1.65e+110) {
tmp = b * ((z / b) - (y / (y + (x + t))));
} else if (b <= -660000000.0) {
tmp = a + (z * ((x + y) / t_1));
} else if ((b <= 1.95e+43) || (!(b <= 2.95e+233) && (b <= 4.75e+247))) {
tmp = z + (a * ((y + t) / t_1));
} else {
tmp = y * ((a + (z - b)) / 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 + (y + t)
if (b <= (-1.65d+110)) then
tmp = b * ((z / b) - (y / (y + (x + t))))
else if (b <= (-660000000.0d0)) then
tmp = a + (z * ((x + y) / t_1))
else if ((b <= 1.95d+43) .or. (.not. (b <= 2.95d+233)) .and. (b <= 4.75d+247)) then
tmp = z + (a * ((y + t) / t_1))
else
tmp = y * ((a + (z - b)) / 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);
double tmp;
if (b <= -1.65e+110) {
tmp = b * ((z / b) - (y / (y + (x + t))));
} else if (b <= -660000000.0) {
tmp = a + (z * ((x + y) / t_1));
} else if ((b <= 1.95e+43) || (!(b <= 2.95e+233) && (b <= 4.75e+247))) {
tmp = z + (a * ((y + t) / t_1));
} else {
tmp = y * ((a + (z - b)) / t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (y + t) tmp = 0 if b <= -1.65e+110: tmp = b * ((z / b) - (y / (y + (x + t)))) elif b <= -660000000.0: tmp = a + (z * ((x + y) / t_1)) elif (b <= 1.95e+43) or (not (b <= 2.95e+233) and (b <= 4.75e+247)): tmp = z + (a * ((y + t) / t_1)) else: tmp = y * ((a + (z - b)) / t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(y + t)) tmp = 0.0 if (b <= -1.65e+110) tmp = Float64(b * Float64(Float64(z / b) - Float64(y / Float64(y + Float64(x + t))))); elseif (b <= -660000000.0) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t_1))); elseif ((b <= 1.95e+43) || (!(b <= 2.95e+233) && (b <= 4.75e+247))) tmp = Float64(z + Float64(a * Float64(Float64(y + t) / t_1))); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (y + t); tmp = 0.0; if (b <= -1.65e+110) tmp = b * ((z / b) - (y / (y + (x + t)))); elseif (b <= -660000000.0) tmp = a + (z * ((x + y) / t_1)); elseif ((b <= 1.95e+43) || (~((b <= 2.95e+233)) && (b <= 4.75e+247))) tmp = z + (a * ((y + t) / t_1)); else tmp = y * ((a + (z - b)) / t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.65e+110], N[(b * N[(N[(z / b), $MachinePrecision] - N[(y / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -660000000.0], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[b, 1.95e+43], And[N[Not[LessEqual[b, 2.95e+233]], $MachinePrecision], LessEqual[b, 4.75e+247]]], N[(z + N[(a * N[(N[(y + t), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y + t\right)\\
\mathbf{if}\;b \leq -1.65 \cdot 10^{+110}:\\
\;\;\;\;b \cdot \left(\frac{z}{b} - \frac{y}{y + \left(x + t\right)}\right)\\
\mathbf{elif}\;b \leq -660000000:\\
\;\;\;\;a + z \cdot \frac{x + y}{t\_1}\\
\mathbf{elif}\;b \leq 1.95 \cdot 10^{+43} \lor \neg \left(b \leq 2.95 \cdot 10^{+233}\right) \land b \leq 4.75 \cdot 10^{+247}:\\
\;\;\;\;z + a \cdot \frac{y + t}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{t\_1}\\
\end{array}
\end{array}
if b < -1.64999999999999986e110Initial program 56.9%
Taylor expanded in b around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified82.2%
Taylor expanded in x around inf 85.7%
if -1.64999999999999986e110 < b < -6.6e8Initial program 64.5%
Taylor expanded in b around inf 57.7%
+-commutative57.7%
mul-1-neg57.7%
unsub-neg57.7%
Simplified77.0%
Taylor expanded in b around 0 55.0%
associate-/l*71.4%
+-commutative71.4%
associate-+r+71.4%
+-commutative71.4%
associate-+r+71.4%
associate-/l*90.1%
+-commutative90.1%
associate-+r+90.1%
+-commutative90.1%
associate-+r+90.1%
Simplified90.1%
Taylor expanded in y around inf 80.5%
if -6.6e8 < b < 1.95e43 or 2.95000000000000013e233 < b < 4.7500000000000001e247Initial program 60.0%
Taylor expanded in b around inf 53.0%
+-commutative53.0%
mul-1-neg53.0%
unsub-neg53.0%
Simplified70.4%
Taylor expanded in b around 0 56.2%
associate-/l*72.5%
+-commutative72.5%
associate-+r+72.5%
+-commutative72.5%
associate-+r+72.5%
associate-/l*94.2%
+-commutative94.2%
associate-+r+94.2%
+-commutative94.2%
associate-+r+94.2%
Simplified94.2%
Taylor expanded in y around inf 82.7%
if 1.95e43 < b < 2.95000000000000013e233 or 4.7500000000000001e247 < b Initial program 51.2%
Taylor expanded in y around inf 41.1%
associate-/l*84.1%
associate--l+84.1%
+-commutative84.1%
+-commutative84.1%
Applied egg-rr84.1%
associate-+r+84.1%
Simplified84.1%
Final simplification83.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))))
(if (<= y -2e-71)
(- (+ z a) b)
(if (<= y -6e-138)
(* z (/ (+ x y) t_1))
(if (<= y -2.4e-163)
(/ a (/ t_1 (+ y t)))
(if (<= y 1.2e-133)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 4e+53)
(* b (- (/ a b) (/ y t_1)))
(* y (/ (+ a (- z b)) (+ x y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double tmp;
if (y <= -2e-71) {
tmp = (z + a) - b;
} else if (y <= -6e-138) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.4e-163) {
tmp = a / (t_1 / (y + t));
} else if (y <= 1.2e-133) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4e+53) {
tmp = b * ((a / b) - (y / t_1));
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
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 = y + (x + t)
if (y <= (-2d-71)) then
tmp = (z + a) - b
else if (y <= (-6d-138)) then
tmp = z * ((x + y) / t_1)
else if (y <= (-2.4d-163)) then
tmp = a / (t_1 / (y + t))
else if (y <= 1.2d-133) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 4d+53) then
tmp = b * ((a / b) - (y / t_1))
else
tmp = y * ((a + (z - b)) / (x + y))
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 + (x + t);
double tmp;
if (y <= -2e-71) {
tmp = (z + a) - b;
} else if (y <= -6e-138) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.4e-163) {
tmp = a / (t_1 / (y + t));
} else if (y <= 1.2e-133) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4e+53) {
tmp = b * ((a / b) - (y / t_1));
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) tmp = 0 if y <= -2e-71: tmp = (z + a) - b elif y <= -6e-138: tmp = z * ((x + y) / t_1) elif y <= -2.4e-163: tmp = a / (t_1 / (y + t)) elif y <= 1.2e-133: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 4e+53: tmp = b * ((a / b) - (y / t_1)) else: tmp = y * ((a + (z - b)) / (x + y)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) tmp = 0.0 if (y <= -2e-71) tmp = Float64(Float64(z + a) - b); elseif (y <= -6e-138) tmp = Float64(z * Float64(Float64(x + y) / t_1)); elseif (y <= -2.4e-163) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif (y <= 1.2e-133) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 4e+53) tmp = Float64(b * Float64(Float64(a / b) - Float64(y / t_1))); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / Float64(x + y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); tmp = 0.0; if (y <= -2e-71) tmp = (z + a) - b; elseif (y <= -6e-138) tmp = z * ((x + y) / t_1); elseif (y <= -2.4e-163) tmp = a / (t_1 / (y + t)); elseif (y <= 1.2e-133) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 4e+53) tmp = b * ((a / b) - (y / t_1)); else tmp = y * ((a + (z - b)) / (x + y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2e-71], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[y, -6e-138], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.4e-163], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.2e-133], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4e+53], N[(b * N[(N[(a / b), $MachinePrecision] - N[(y / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
\mathbf{if}\;y \leq -2 \cdot 10^{-71}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;y \leq -6 \cdot 10^{-138}:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{elif}\;y \leq -2.4 \cdot 10^{-163}:\\
\;\;\;\;\frac{a}{\frac{t\_1}{y + t}}\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{-133}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+53}:\\
\;\;\;\;b \cdot \left(\frac{a}{b} - \frac{y}{t\_1}\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{x + y}\\
\end{array}
\end{array}
if y < -1.9999999999999998e-71Initial program 46.6%
Taylor expanded in y around inf 80.2%
if -1.9999999999999998e-71 < y < -6.0000000000000001e-138Initial program 68.1%
Taylor expanded in z around inf 39.8%
associate-/l*63.6%
+-commutative63.6%
+-commutative63.6%
associate-+r+63.6%
+-commutative63.6%
associate-+l+63.6%
Simplified63.6%
if -6.0000000000000001e-138 < y < -2.4000000000000001e-163Initial program 68.3%
Taylor expanded in b around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified78.1%
Taylor expanded in a around -inf 68.3%
associate-/l*99.5%
+-commutative99.5%
associate-+r+99.5%
+-commutative99.5%
associate-+r+99.5%
Simplified99.5%
clear-num99.7%
un-div-inv99.8%
associate-+l+99.8%
Applied egg-rr99.8%
if -2.4000000000000001e-163 < y < 1.2e-133Initial program 83.1%
Taylor expanded in y around 0 69.6%
if 1.2e-133 < y < 4e53Initial program 83.8%
Taylor expanded in b around inf 73.9%
+-commutative73.9%
mul-1-neg73.9%
unsub-neg73.9%
Simplified76.4%
Taylor expanded in t around inf 60.8%
if 4e53 < y Initial program 27.9%
Taylor expanded in y around inf 24.9%
clear-num24.8%
inv-pow24.8%
+-commutative24.8%
+-commutative24.8%
associate--l+24.8%
Applied egg-rr24.8%
unpow-124.8%
associate-+r-24.8%
associate-/r*90.2%
associate-+r+90.2%
associate-+r-90.2%
Simplified90.2%
Taylor expanded in t around 0 21.8%
associate-/l*78.7%
associate--l+78.7%
+-commutative78.7%
Simplified78.7%
Final simplification74.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t)))
(t_2 (+ a (- z b)))
(t_3 (+ x (+ y t)))
(t_4 (+ z (* a (/ (+ y t) t_3)))))
(if (<= b -3.3e+110)
(* b (- (/ z b) (/ y t_1)))
(if (<= b -102000000.0)
(+ a (* z (/ (+ x y) t_3)))
(if (<= b 7e+41)
t_4
(if (<= b 2.95e+233)
(* y (/ t_2 t_3))
(if (<= b 4.75e+247) t_4 (/ t_2 (/ t_1 y)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = a + (z - b);
double t_3 = x + (y + t);
double t_4 = z + (a * ((y + t) / t_3));
double tmp;
if (b <= -3.3e+110) {
tmp = b * ((z / b) - (y / t_1));
} else if (b <= -102000000.0) {
tmp = a + (z * ((x + y) / t_3));
} else if (b <= 7e+41) {
tmp = t_4;
} else if (b <= 2.95e+233) {
tmp = y * (t_2 / t_3);
} else if (b <= 4.75e+247) {
tmp = t_4;
} else {
tmp = t_2 / (t_1 / y);
}
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) :: t_4
real(8) :: tmp
t_1 = y + (x + t)
t_2 = a + (z - b)
t_3 = x + (y + t)
t_4 = z + (a * ((y + t) / t_3))
if (b <= (-3.3d+110)) then
tmp = b * ((z / b) - (y / t_1))
else if (b <= (-102000000.0d0)) then
tmp = a + (z * ((x + y) / t_3))
else if (b <= 7d+41) then
tmp = t_4
else if (b <= 2.95d+233) then
tmp = y * (t_2 / t_3)
else if (b <= 4.75d+247) then
tmp = t_4
else
tmp = t_2 / (t_1 / y)
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 + (x + t);
double t_2 = a + (z - b);
double t_3 = x + (y + t);
double t_4 = z + (a * ((y + t) / t_3));
double tmp;
if (b <= -3.3e+110) {
tmp = b * ((z / b) - (y / t_1));
} else if (b <= -102000000.0) {
tmp = a + (z * ((x + y) / t_3));
} else if (b <= 7e+41) {
tmp = t_4;
} else if (b <= 2.95e+233) {
tmp = y * (t_2 / t_3);
} else if (b <= 4.75e+247) {
tmp = t_4;
} else {
tmp = t_2 / (t_1 / y);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = a + (z - b) t_3 = x + (y + t) t_4 = z + (a * ((y + t) / t_3)) tmp = 0 if b <= -3.3e+110: tmp = b * ((z / b) - (y / t_1)) elif b <= -102000000.0: tmp = a + (z * ((x + y) / t_3)) elif b <= 7e+41: tmp = t_4 elif b <= 2.95e+233: tmp = y * (t_2 / t_3) elif b <= 4.75e+247: tmp = t_4 else: tmp = t_2 / (t_1 / y) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(a + Float64(z - b)) t_3 = Float64(x + Float64(y + t)) t_4 = Float64(z + Float64(a * Float64(Float64(y + t) / t_3))) tmp = 0.0 if (b <= -3.3e+110) tmp = Float64(b * Float64(Float64(z / b) - Float64(y / t_1))); elseif (b <= -102000000.0) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t_3))); elseif (b <= 7e+41) tmp = t_4; elseif (b <= 2.95e+233) tmp = Float64(y * Float64(t_2 / t_3)); elseif (b <= 4.75e+247) tmp = t_4; else tmp = Float64(t_2 / Float64(t_1 / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = a + (z - b); t_3 = x + (y + t); t_4 = z + (a * ((y + t) / t_3)); tmp = 0.0; if (b <= -3.3e+110) tmp = b * ((z / b) - (y / t_1)); elseif (b <= -102000000.0) tmp = a + (z * ((x + y) / t_3)); elseif (b <= 7e+41) tmp = t_4; elseif (b <= 2.95e+233) tmp = y * (t_2 / t_3); elseif (b <= 4.75e+247) tmp = t_4; else tmp = t_2 / (t_1 / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(z + N[(a * N[(N[(y + t), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.3e+110], N[(b * N[(N[(z / b), $MachinePrecision] - N[(y / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -102000000.0], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7e+41], t$95$4, If[LessEqual[b, 2.95e+233], N[(y * N[(t$95$2 / t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.75e+247], t$95$4, N[(t$95$2 / N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := a + \left(z - b\right)\\
t_3 := x + \left(y + t\right)\\
t_4 := z + a \cdot \frac{y + t}{t\_3}\\
\mathbf{if}\;b \leq -3.3 \cdot 10^{+110}:\\
\;\;\;\;b \cdot \left(\frac{z}{b} - \frac{y}{t\_1}\right)\\
\mathbf{elif}\;b \leq -102000000:\\
\;\;\;\;a + z \cdot \frac{x + y}{t\_3}\\
\mathbf{elif}\;b \leq 7 \cdot 10^{+41}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;b \leq 2.95 \cdot 10^{+233}:\\
\;\;\;\;y \cdot \frac{t\_2}{t\_3}\\
\mathbf{elif}\;b \leq 4.75 \cdot 10^{+247}:\\
\;\;\;\;t\_4\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_2}{\frac{t\_1}{y}}\\
\end{array}
\end{array}
if b < -3.29999999999999971e110Initial program 56.9%
Taylor expanded in b around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified82.2%
Taylor expanded in x around inf 85.7%
if -3.29999999999999971e110 < b < -1.02e8Initial program 64.5%
Taylor expanded in b around inf 57.7%
+-commutative57.7%
mul-1-neg57.7%
unsub-neg57.7%
Simplified77.0%
Taylor expanded in b around 0 55.0%
associate-/l*71.4%
+-commutative71.4%
associate-+r+71.4%
+-commutative71.4%
associate-+r+71.4%
associate-/l*90.1%
+-commutative90.1%
associate-+r+90.1%
+-commutative90.1%
associate-+r+90.1%
Simplified90.1%
Taylor expanded in y around inf 80.5%
if -1.02e8 < b < 6.9999999999999998e41 or 2.95000000000000013e233 < b < 4.7500000000000001e247Initial program 60.0%
Taylor expanded in b around inf 53.0%
+-commutative53.0%
mul-1-neg53.0%
unsub-neg53.0%
Simplified70.4%
Taylor expanded in b around 0 56.2%
associate-/l*72.5%
+-commutative72.5%
associate-+r+72.5%
+-commutative72.5%
associate-+r+72.5%
associate-/l*94.2%
+-commutative94.2%
associate-+r+94.2%
+-commutative94.2%
associate-+r+94.2%
Simplified94.2%
Taylor expanded in y around inf 82.7%
if 6.9999999999999998e41 < b < 2.95000000000000013e233Initial program 58.0%
Taylor expanded in y around inf 43.3%
associate-/l*78.0%
associate--l+78.0%
+-commutative78.0%
+-commutative78.0%
Applied egg-rr78.0%
associate-+r+78.0%
Simplified78.0%
if 4.7500000000000001e247 < b Initial program 35.5%
Taylor expanded in y around inf 36.1%
clear-num36.0%
inv-pow36.0%
+-commutative36.0%
+-commutative36.0%
associate--l+36.0%
Applied egg-rr36.0%
unpow-136.0%
associate-+r-36.0%
associate-/r*98.1%
associate-+r+98.1%
associate-+r-98.1%
Simplified98.1%
clear-num98.6%
add-cube-cbrt96.2%
*-un-lft-identity96.2%
times-frac96.1%
pow296.1%
+-commutative96.1%
associate-+l-96.1%
+-commutative96.1%
associate-+l-96.1%
associate-+l+96.1%
Applied egg-rr96.1%
/-rgt-identity96.1%
associate-*r/96.2%
unpow296.2%
rem-3cbrt-lft98.6%
associate--r-98.6%
Simplified98.6%
Final simplification83.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))) (t_2 (* z (/ (+ x y) t_1))))
(if (<= y -2e-68)
(- (+ z a) b)
(if (<= y -2.8e-134)
t_2
(if (<= y -3.3e-172)
(/ a (/ t_1 (+ y t)))
(if (<= y 2.95e-261)
t_2
(if (<= y 1.48e-130)
(/ (* (+ y t) a) t_1)
(* y (/ (+ a (- z b)) (+ x y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = z * ((x + y) / t_1);
double tmp;
if (y <= -2e-68) {
tmp = (z + a) - b;
} else if (y <= -2.8e-134) {
tmp = t_2;
} else if (y <= -3.3e-172) {
tmp = a / (t_1 / (y + t));
} else if (y <= 2.95e-261) {
tmp = t_2;
} else if (y <= 1.48e-130) {
tmp = ((y + t) * a) / t_1;
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
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 + (x + t)
t_2 = z * ((x + y) / t_1)
if (y <= (-2d-68)) then
tmp = (z + a) - b
else if (y <= (-2.8d-134)) then
tmp = t_2
else if (y <= (-3.3d-172)) then
tmp = a / (t_1 / (y + t))
else if (y <= 2.95d-261) then
tmp = t_2
else if (y <= 1.48d-130) then
tmp = ((y + t) * a) / t_1
else
tmp = y * ((a + (z - b)) / (x + y))
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 + (x + t);
double t_2 = z * ((x + y) / t_1);
double tmp;
if (y <= -2e-68) {
tmp = (z + a) - b;
} else if (y <= -2.8e-134) {
tmp = t_2;
} else if (y <= -3.3e-172) {
tmp = a / (t_1 / (y + t));
} else if (y <= 2.95e-261) {
tmp = t_2;
} else if (y <= 1.48e-130) {
tmp = ((y + t) * a) / t_1;
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = z * ((x + y) / t_1) tmp = 0 if y <= -2e-68: tmp = (z + a) - b elif y <= -2.8e-134: tmp = t_2 elif y <= -3.3e-172: tmp = a / (t_1 / (y + t)) elif y <= 2.95e-261: tmp = t_2 elif y <= 1.48e-130: tmp = ((y + t) * a) / t_1 else: tmp = y * ((a + (z - b)) / (x + y)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(z * Float64(Float64(x + y) / t_1)) tmp = 0.0 if (y <= -2e-68) tmp = Float64(Float64(z + a) - b); elseif (y <= -2.8e-134) tmp = t_2; elseif (y <= -3.3e-172) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif (y <= 2.95e-261) tmp = t_2; elseif (y <= 1.48e-130) tmp = Float64(Float64(Float64(y + t) * a) / t_1); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / Float64(x + y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = z * ((x + y) / t_1); tmp = 0.0; if (y <= -2e-68) tmp = (z + a) - b; elseif (y <= -2.8e-134) tmp = t_2; elseif (y <= -3.3e-172) tmp = a / (t_1 / (y + t)); elseif (y <= 2.95e-261) tmp = t_2; elseif (y <= 1.48e-130) tmp = ((y + t) * a) / t_1; else tmp = y * ((a + (z - b)) / (x + y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2e-68], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[y, -2.8e-134], t$95$2, If[LessEqual[y, -3.3e-172], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.95e-261], t$95$2, If[LessEqual[y, 1.48e-130], N[(N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision] / t$95$1), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := z \cdot \frac{x + y}{t\_1}\\
\mathbf{if}\;y \leq -2 \cdot 10^{-68}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;y \leq -2.8 \cdot 10^{-134}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -3.3 \cdot 10^{-172}:\\
\;\;\;\;\frac{a}{\frac{t\_1}{y + t}}\\
\mathbf{elif}\;y \leq 2.95 \cdot 10^{-261}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 1.48 \cdot 10^{-130}:\\
\;\;\;\;\frac{\left(y + t\right) \cdot a}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{x + y}\\
\end{array}
\end{array}
if y < -2.00000000000000013e-68Initial program 46.6%
Taylor expanded in y around inf 80.2%
if -2.00000000000000013e-68 < y < -2.7999999999999999e-134 or -3.3e-172 < y < 2.9500000000000002e-261Initial program 72.3%
Taylor expanded in z around inf 42.2%
associate-/l*61.2%
+-commutative61.2%
+-commutative61.2%
associate-+r+61.2%
+-commutative61.2%
associate-+l+61.2%
Simplified61.2%
if -2.7999999999999999e-134 < y < -3.3e-172Initial program 74.1%
Taylor expanded in b around inf 73.1%
+-commutative73.1%
mul-1-neg73.1%
unsub-neg73.1%
Simplified82.0%
Taylor expanded in a around -inf 74.1%
associate-/l*99.4%
+-commutative99.4%
associate-+r+99.4%
+-commutative99.4%
associate-+r+99.4%
Simplified99.4%
clear-num99.6%
un-div-inv99.7%
associate-+l+99.7%
Applied egg-rr99.7%
if 2.9500000000000002e-261 < y < 1.4800000000000001e-130Initial program 95.6%
Taylor expanded in a around inf 61.8%
if 1.4800000000000001e-130 < y Initial program 51.8%
Taylor expanded in y around inf 36.0%
clear-num35.9%
inv-pow35.9%
+-commutative35.9%
+-commutative35.9%
associate--l+35.9%
Applied egg-rr35.9%
unpow-135.9%
associate-+r-35.9%
associate-/r*73.1%
associate-+r+73.1%
associate-+r-73.1%
Simplified73.1%
Taylor expanded in t around 0 31.3%
associate-/l*63.8%
associate--l+63.8%
+-commutative63.8%
Simplified63.8%
Final simplification70.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))))
(if (<= y -2.75e-70)
(- (+ z a) b)
(if (<= y -3e-133)
(* z (/ (+ x y) t_1))
(if (<= y -2.3e-162)
(/ a (/ t_1 (+ y t)))
(if (<= y 9.4e-123)
(/ (+ (* t a) (* x z)) (+ x t))
(* y (/ (+ a (- z b)) (+ x y)))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double tmp;
if (y <= -2.75e-70) {
tmp = (z + a) - b;
} else if (y <= -3e-133) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.3e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 9.4e-123) {
tmp = ((t * a) + (x * z)) / (x + t);
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
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 = y + (x + t)
if (y <= (-2.75d-70)) then
tmp = (z + a) - b
else if (y <= (-3d-133)) then
tmp = z * ((x + y) / t_1)
else if (y <= (-2.3d-162)) then
tmp = a / (t_1 / (y + t))
else if (y <= 9.4d-123) then
tmp = ((t * a) + (x * z)) / (x + t)
else
tmp = y * ((a + (z - b)) / (x + y))
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 + (x + t);
double tmp;
if (y <= -2.75e-70) {
tmp = (z + a) - b;
} else if (y <= -3e-133) {
tmp = z * ((x + y) / t_1);
} else if (y <= -2.3e-162) {
tmp = a / (t_1 / (y + t));
} else if (y <= 9.4e-123) {
tmp = ((t * a) + (x * z)) / (x + t);
} else {
tmp = y * ((a + (z - b)) / (x + y));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) tmp = 0 if y <= -2.75e-70: tmp = (z + a) - b elif y <= -3e-133: tmp = z * ((x + y) / t_1) elif y <= -2.3e-162: tmp = a / (t_1 / (y + t)) elif y <= 9.4e-123: tmp = ((t * a) + (x * z)) / (x + t) else: tmp = y * ((a + (z - b)) / (x + y)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) tmp = 0.0 if (y <= -2.75e-70) tmp = Float64(Float64(z + a) - b); elseif (y <= -3e-133) tmp = Float64(z * Float64(Float64(x + y) / t_1)); elseif (y <= -2.3e-162) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif (y <= 9.4e-123) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / Float64(x + y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); tmp = 0.0; if (y <= -2.75e-70) tmp = (z + a) - b; elseif (y <= -3e-133) tmp = z * ((x + y) / t_1); elseif (y <= -2.3e-162) tmp = a / (t_1 / (y + t)); elseif (y <= 9.4e-123) tmp = ((t * a) + (x * z)) / (x + t); else tmp = y * ((a + (z - b)) / (x + y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.75e-70], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[y, -3e-133], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.3e-162], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.4e-123], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
\mathbf{if}\;y \leq -2.75 \cdot 10^{-70}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;y \leq -3 \cdot 10^{-133}:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{elif}\;y \leq -2.3 \cdot 10^{-162}:\\
\;\;\;\;\frac{a}{\frac{t\_1}{y + t}}\\
\mathbf{elif}\;y \leq 9.4 \cdot 10^{-123}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{x + y}\\
\end{array}
\end{array}
if y < -2.75e-70Initial program 46.6%
Taylor expanded in y around inf 80.2%
if -2.75e-70 < y < -3.00000000000000019e-133Initial program 68.1%
Taylor expanded in z around inf 39.8%
associate-/l*63.6%
+-commutative63.6%
+-commutative63.6%
associate-+r+63.6%
+-commutative63.6%
associate-+l+63.6%
Simplified63.6%
if -3.00000000000000019e-133 < y < -2.2999999999999998e-162Initial program 68.3%
Taylor expanded in b around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified78.1%
Taylor expanded in a around -inf 68.3%
associate-/l*99.5%
+-commutative99.5%
associate-+r+99.5%
+-commutative99.5%
associate-+r+99.5%
Simplified99.5%
clear-num99.7%
un-div-inv99.8%
associate-+l+99.8%
Applied egg-rr99.8%
if -2.2999999999999998e-162 < y < 9.4000000000000004e-123Initial program 83.4%
Taylor expanded in y around 0 68.6%
if 9.4000000000000004e-123 < y Initial program 51.8%
Taylor expanded in y around inf 36.0%
clear-num35.9%
inv-pow35.9%
+-commutative35.9%
+-commutative35.9%
associate--l+35.9%
Applied egg-rr35.9%
unpow-135.9%
associate-+r-35.9%
associate-/r*73.1%
associate-+r+73.1%
associate-+r-73.1%
Simplified73.1%
Taylor expanded in t around 0 31.3%
associate-/l*63.8%
associate--l+63.8%
+-commutative63.8%
Simplified63.8%
Final simplification71.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (+ y t))))
(if (<= b -2.2e+112)
(* b (- (/ z b) (/ y (+ y (+ x t)))))
(if (<= b 8.2e+27)
(+ a (* z (/ (+ x y) t_1)))
(* y (/ (+ a (- z b)) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + (y + t);
double tmp;
if (b <= -2.2e+112) {
tmp = b * ((z / b) - (y / (y + (x + t))));
} else if (b <= 8.2e+27) {
tmp = a + (z * ((x + y) / t_1));
} else {
tmp = y * ((a + (z - b)) / 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 + (y + t)
if (b <= (-2.2d+112)) then
tmp = b * ((z / b) - (y / (y + (x + t))))
else if (b <= 8.2d+27) then
tmp = a + (z * ((x + y) / t_1))
else
tmp = y * ((a + (z - b)) / 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);
double tmp;
if (b <= -2.2e+112) {
tmp = b * ((z / b) - (y / (y + (x + t))));
} else if (b <= 8.2e+27) {
tmp = a + (z * ((x + y) / t_1));
} else {
tmp = y * ((a + (z - b)) / t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x + (y + t) tmp = 0 if b <= -2.2e+112: tmp = b * ((z / b) - (y / (y + (x + t)))) elif b <= 8.2e+27: tmp = a + (z * ((x + y) / t_1)) else: tmp = y * ((a + (z - b)) / t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(y + t)) tmp = 0.0 if (b <= -2.2e+112) tmp = Float64(b * Float64(Float64(z / b) - Float64(y / Float64(y + Float64(x + t))))); elseif (b <= 8.2e+27) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t_1))); else tmp = Float64(y * Float64(Float64(a + Float64(z - b)) / t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x + (y + t); tmp = 0.0; if (b <= -2.2e+112) tmp = b * ((z / b) - (y / (y + (x + t)))); elseif (b <= 8.2e+27) tmp = a + (z * ((x + y) / t_1)); else tmp = y * ((a + (z - b)) / t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(y + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.2e+112], N[(b * N[(N[(z / b), $MachinePrecision] - N[(y / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 8.2e+27], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(a + N[(z - b), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(y + t\right)\\
\mathbf{if}\;b \leq -2.2 \cdot 10^{+112}:\\
\;\;\;\;b \cdot \left(\frac{z}{b} - \frac{y}{y + \left(x + t\right)}\right)\\
\mathbf{elif}\;b \leq 8.2 \cdot 10^{+27}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;y \cdot \frac{a + \left(z - b\right)}{t\_1}\\
\end{array}
\end{array}
if b < -2.1999999999999999e112Initial program 56.9%
Taylor expanded in b around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified82.2%
Taylor expanded in x around inf 85.7%
if -2.1999999999999999e112 < b < 8.2000000000000005e27Initial program 60.6%
Taylor expanded in b around inf 54.6%
+-commutative54.6%
mul-1-neg54.6%
unsub-neg54.6%
Simplified73.7%
Taylor expanded in b around 0 55.5%
associate-/l*72.7%
+-commutative72.7%
associate-+r+72.7%
+-commutative72.7%
associate-+r+72.7%
associate-/l*94.1%
+-commutative94.1%
associate-+r+94.1%
+-commutative94.1%
associate-+r+94.1%
Simplified94.1%
Taylor expanded in y around inf 76.9%
if 8.2000000000000005e27 < b Initial program 53.1%
Taylor expanded in y around inf 38.9%
associate-/l*75.2%
associate--l+75.2%
+-commutative75.2%
+-commutative75.2%
Applied egg-rr75.2%
associate-+r+75.2%
Simplified75.2%
Final simplification77.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))))
(if (<= a 1.2e-302)
(- (+ z a) b)
(if (<= a 170000000.0) (* z (/ (+ x y) t_1)) (* a (/ (+ y t) t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double tmp;
if (a <= 1.2e-302) {
tmp = (z + a) - b;
} else if (a <= 170000000.0) {
tmp = z * ((x + y) / t_1);
} else {
tmp = a * ((y + t) / 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 = y + (x + t)
if (a <= 1.2d-302) then
tmp = (z + a) - b
else if (a <= 170000000.0d0) then
tmp = z * ((x + y) / t_1)
else
tmp = a * ((y + t) / 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 = y + (x + t);
double tmp;
if (a <= 1.2e-302) {
tmp = (z + a) - b;
} else if (a <= 170000000.0) {
tmp = z * ((x + y) / t_1);
} else {
tmp = a * ((y + t) / t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) tmp = 0 if a <= 1.2e-302: tmp = (z + a) - b elif a <= 170000000.0: tmp = z * ((x + y) / t_1) else: tmp = a * ((y + t) / t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) tmp = 0.0 if (a <= 1.2e-302) tmp = Float64(Float64(z + a) - b); elseif (a <= 170000000.0) tmp = Float64(z * Float64(Float64(x + y) / t_1)); else tmp = Float64(a * Float64(Float64(y + t) / t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); tmp = 0.0; if (a <= 1.2e-302) tmp = (z + a) - b; elseif (a <= 170000000.0) tmp = z * ((x + y) / t_1); else tmp = a * ((y + t) / t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, 1.2e-302], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[a, 170000000.0], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(a * N[(N[(y + t), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
\mathbf{if}\;a \leq 1.2 \cdot 10^{-302}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;a \leq 170000000:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{y + t}{t\_1}\\
\end{array}
\end{array}
if a < 1.20000000000000011e-302Initial program 58.4%
Taylor expanded in y around inf 62.5%
if 1.20000000000000011e-302 < a < 1.7e8Initial program 67.7%
Taylor expanded in z around inf 36.7%
associate-/l*64.3%
+-commutative64.3%
+-commutative64.3%
associate-+r+64.3%
+-commutative64.3%
associate-+l+64.3%
Simplified64.3%
if 1.7e8 < a Initial program 49.0%
Taylor expanded in a around inf 39.9%
associate-/l*70.4%
+-commutative70.4%
associate-+r+70.4%
+-commutative70.4%
associate-+l+70.4%
Simplified70.4%
Final simplification64.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))))
(if (<= a 2.35e-303)
(- (+ z a) b)
(if (<= a 240000000.0) (* z (/ (+ x y) t_1)) (* (+ y t) (/ a t_1))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double tmp;
if (a <= 2.35e-303) {
tmp = (z + a) - b;
} else if (a <= 240000000.0) {
tmp = z * ((x + y) / t_1);
} else {
tmp = (y + t) * (a / 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 = y + (x + t)
if (a <= 2.35d-303) then
tmp = (z + a) - b
else if (a <= 240000000.0d0) then
tmp = z * ((x + y) / t_1)
else
tmp = (y + t) * (a / 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 = y + (x + t);
double tmp;
if (a <= 2.35e-303) {
tmp = (z + a) - b;
} else if (a <= 240000000.0) {
tmp = z * ((x + y) / t_1);
} else {
tmp = (y + t) * (a / t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) tmp = 0 if a <= 2.35e-303: tmp = (z + a) - b elif a <= 240000000.0: tmp = z * ((x + y) / t_1) else: tmp = (y + t) * (a / t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) tmp = 0.0 if (a <= 2.35e-303) tmp = Float64(Float64(z + a) - b); elseif (a <= 240000000.0) tmp = Float64(z * Float64(Float64(x + y) / t_1)); else tmp = Float64(Float64(y + t) * Float64(a / t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); tmp = 0.0; if (a <= 2.35e-303) tmp = (z + a) - b; elseif (a <= 240000000.0) tmp = z * ((x + y) / t_1); else tmp = (y + t) * (a / t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, 2.35e-303], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[a, 240000000.0], N[(z * N[(N[(x + y), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(y + t), $MachinePrecision] * N[(a / t$95$1), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
\mathbf{if}\;a \leq 2.35 \cdot 10^{-303}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;a \leq 240000000:\\
\;\;\;\;z \cdot \frac{x + y}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\left(y + t\right) \cdot \frac{a}{t\_1}\\
\end{array}
\end{array}
if a < 2.3499999999999999e-303Initial program 58.4%
Taylor expanded in y around inf 62.5%
if 2.3499999999999999e-303 < a < 2.4e8Initial program 67.7%
Taylor expanded in z around inf 36.7%
associate-/l*64.3%
+-commutative64.3%
+-commutative64.3%
associate-+r+64.3%
+-commutative64.3%
associate-+l+64.3%
Simplified64.3%
if 2.4e8 < a Initial program 49.0%
Taylor expanded in b around inf 46.4%
+-commutative46.4%
mul-1-neg46.4%
unsub-neg46.4%
Simplified67.3%
Taylor expanded in a around -inf 39.9%
associate-/l*70.4%
+-commutative70.4%
associate-+r+70.4%
+-commutative70.4%
associate-+r+70.4%
Simplified70.4%
clear-num70.4%
un-div-inv70.4%
associate-+l+70.4%
Applied egg-rr70.4%
associate-/r/72.0%
+-commutative72.0%
Simplified72.0%
Final simplification65.0%
(FPCore (x y z t a b) :precision binary64 (if (<= a 1.05e+98) (- (+ z a) b) (* a (/ (+ y t) (+ y (+ x t))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.05e+98) {
tmp = (z + a) - b;
} else {
tmp = a * ((y + t) / (y + (x + 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 (a <= 1.05d+98) then
tmp = (z + a) - b
else
tmp = a * ((y + t) / (y + (x + 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 (a <= 1.05e+98) {
tmp = (z + a) - b;
} else {
tmp = a * ((y + t) / (y + (x + t)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 1.05e+98: tmp = (z + a) - b else: tmp = a * ((y + t) / (y + (x + t))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 1.05e+98) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a * Float64(Float64(y + t) / Float64(y + Float64(x + t)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 1.05e+98) tmp = (z + a) - b; else tmp = a * ((y + t) / (y + (x + t))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 1.05e+98], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a * N[(N[(y + t), $MachinePrecision] / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.05 \cdot 10^{+98}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{y + t}{y + \left(x + t\right)}\\
\end{array}
\end{array}
if a < 1.05000000000000002e98Initial program 61.4%
Taylor expanded in y around inf 59.8%
if 1.05000000000000002e98 < a Initial program 43.2%
Taylor expanded in a around inf 37.9%
associate-/l*80.4%
+-commutative80.4%
associate-+r+80.4%
+-commutative80.4%
associate-+l+80.4%
Simplified80.4%
Final simplification63.0%
(FPCore (x y z t a b) :precision binary64 (if (<= a 1.15e+234) (- (+ z a) b) (* a (/ t (+ x t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= 1.15e+234) {
tmp = (z + a) - b;
} else {
tmp = a * (t / (x + 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 (a <= 1.15d+234) then
tmp = (z + a) - b
else
tmp = a * (t / (x + 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 (a <= 1.15e+234) {
tmp = (z + a) - b;
} else {
tmp = a * (t / (x + t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= 1.15e+234: tmp = (z + a) - b else: tmp = a * (t / (x + t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= 1.15e+234) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a * Float64(t / Float64(x + t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= 1.15e+234) tmp = (z + a) - b; else tmp = a * (t / (x + t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, 1.15e+234], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a * N[(t / N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 1.15 \cdot 10^{+234}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a \cdot \frac{t}{x + t}\\
\end{array}
\end{array}
if a < 1.15e234Initial program 59.0%
Taylor expanded in y around inf 61.9%
if 1.15e234 < a Initial program 49.9%
Taylor expanded in b around inf 41.6%
+-commutative41.6%
mul-1-neg41.6%
unsub-neg41.6%
Simplified41.8%
Taylor expanded in a around -inf 44.1%
associate-/l*79.0%
+-commutative79.0%
associate-+r+79.0%
+-commutative79.0%
associate-+r+79.0%
Simplified79.0%
Taylor expanded in y around 0 36.1%
associate-/l*56.7%
Simplified56.7%
Final simplification61.7%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4.9e-68) a (if (<= t 1.6e+99) z a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.9e-68) {
tmp = a;
} else if (t <= 1.6e+99) {
tmp = z;
} else {
tmp = 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.9d-68)) then
tmp = a
else if (t <= 1.6d+99) then
tmp = z
else
tmp = 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.9e-68) {
tmp = a;
} else if (t <= 1.6e+99) {
tmp = z;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.9e-68: tmp = a elif t <= 1.6e+99: tmp = z else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.9e-68) tmp = a; elseif (t <= 1.6e+99) tmp = z; else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.9e-68) tmp = a; elseif (t <= 1.6e+99) tmp = z; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.9e-68], a, If[LessEqual[t, 1.6e+99], z, a]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.9 \cdot 10^{-68}:\\
\;\;\;\;a\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{+99}:\\
\;\;\;\;z\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if t < -4.89999999999999977e-68 or 1.6e99 < t Initial program 45.0%
Taylor expanded in t around inf 47.0%
if -4.89999999999999977e-68 < t < 1.6e99Initial program 68.2%
Taylor expanded in x around inf 43.4%
Final simplification44.9%
(FPCore (x y z t a b) :precision binary64 (- (+ z a) b))
double code(double x, double y, double z, double t, double a, double b) {
return (z + a) - b;
}
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 = (z + a) - b
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (z + a) - b;
}
def code(x, y, z, t, a, b): return (z + a) - b
function code(x, y, z, t, a, b) return Float64(Float64(z + a) - b) end
function tmp = code(x, y, z, t, a, b) tmp = (z + a) - b; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]
\begin{array}{l}
\\
\left(z + a\right) - b
\end{array}
Initial program 58.6%
Taylor expanded in y around inf 60.1%
Final simplification60.1%
(FPCore (x y z t a b) :precision binary64 a)
double code(double x, double y, double z, double t, double a, double b) {
return 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 = a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return a;
}
def code(x, y, z, t, a, b): return a
function code(x, y, z, t, a, b) return a end
function tmp = code(x, y, z, t, a, b) tmp = a; end
code[x_, y_, z_, t_, a_, b_] := a
\begin{array}{l}
\\
a
\end{array}
Initial program 58.6%
Taylor expanded in t around inf 30.6%
Final simplification30.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (+ x t) y))
(t_2 (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)))
(t_3 (/ t_2 t_1))
(t_4 (- (+ z a) b)))
(if (< t_3 -3.5813117084150564e+153)
t_4
(if (< t_3 1.2285964308315609e+82) (/ 1.0 (/ t_1 t_2)) t_4))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + t) + y;
double t_2 = (((x + y) * z) + ((t + y) * a)) - (y * b);
double t_3 = t_2 / t_1;
double t_4 = (z + a) - b;
double tmp;
if (t_3 < -3.5813117084150564e+153) {
tmp = t_4;
} else if (t_3 < 1.2285964308315609e+82) {
tmp = 1.0 / (t_1 / t_2);
} else {
tmp = t_4;
}
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) :: t_4
real(8) :: tmp
t_1 = (x + t) + y
t_2 = (((x + y) * z) + ((t + y) * a)) - (y * b)
t_3 = t_2 / t_1
t_4 = (z + a) - b
if (t_3 < (-3.5813117084150564d+153)) then
tmp = t_4
else if (t_3 < 1.2285964308315609d+82) then
tmp = 1.0d0 / (t_1 / t_2)
else
tmp = t_4
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 + t) + y;
double t_2 = (((x + y) * z) + ((t + y) * a)) - (y * b);
double t_3 = t_2 / t_1;
double t_4 = (z + a) - b;
double tmp;
if (t_3 < -3.5813117084150564e+153) {
tmp = t_4;
} else if (t_3 < 1.2285964308315609e+82) {
tmp = 1.0 / (t_1 / t_2);
} else {
tmp = t_4;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + t) + y t_2 = (((x + y) * z) + ((t + y) * a)) - (y * b) t_3 = t_2 / t_1 t_4 = (z + a) - b tmp = 0 if t_3 < -3.5813117084150564e+153: tmp = t_4 elif t_3 < 1.2285964308315609e+82: tmp = 1.0 / (t_1 / t_2) else: tmp = t_4 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + t) + y) t_2 = Float64(Float64(Float64(Float64(x + y) * z) + Float64(Float64(t + y) * a)) - Float64(y * b)) t_3 = Float64(t_2 / t_1) t_4 = Float64(Float64(z + a) - b) tmp = 0.0 if (t_3 < -3.5813117084150564e+153) tmp = t_4; elseif (t_3 < 1.2285964308315609e+82) tmp = Float64(1.0 / Float64(t_1 / t_2)); else tmp = t_4; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + t) + y; t_2 = (((x + y) * z) + ((t + y) * a)) - (y * b); t_3 = t_2 / t_1; t_4 = (z + a) - b; tmp = 0.0; if (t_3 < -3.5813117084150564e+153) tmp = t_4; elseif (t_3 < 1.2285964308315609e+82) tmp = 1.0 / (t_1 / t_2); else tmp = t_4; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + t), $MachinePrecision] + y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(x + y), $MachinePrecision] * z), $MachinePrecision] + N[(N[(t + y), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / t$95$1), $MachinePrecision]}, Block[{t$95$4 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[Less[t$95$3, -3.5813117084150564e+153], t$95$4, If[Less[t$95$3, 1.2285964308315609e+82], N[(1.0 / N[(t$95$1 / t$95$2), $MachinePrecision]), $MachinePrecision], t$95$4]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x + t\right) + y\\
t_2 := \left(\left(x + y\right) \cdot z + \left(t + y\right) \cdot a\right) - y \cdot b\\
t_3 := \frac{t\_2}{t\_1}\\
t_4 := \left(z + a\right) - b\\
\mathbf{if}\;t\_3 < -3.5813117084150564 \cdot 10^{+153}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 < 1.2285964308315609 \cdot 10^{+82}:\\
\;\;\;\;\frac{1}{\frac{t\_1}{t\_2}}\\
\mathbf{else}:\\
\;\;\;\;t\_4\\
\end{array}
\end{array}
herbie shell --seed 2024071
(FPCore (x y z t a b)
:name "AI.Clustering.Hierarchical.Internal:ward from clustering-0.2.1"
:precision binary64
:alt
(if (< (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) -3.5813117084150564e+153) (- (+ z a) b) (if (< (/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)) 1.2285964308315609e+82) (/ 1.0 (/ (+ (+ x t) y) (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)))) (- (+ z a) b)))
(/ (- (+ (* (+ x y) z) (* (+ t y) a)) (* y b)) (+ (+ x t) y)))