
(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 19 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 (+ t (+ x y)))
(t_2 (* (+ y t) a))
(t_3 (/ (- (+ t_2 (* z (+ x y))) (* y b)) (+ y (+ x t)))))
(if (or (<= t_3 -1e+284) (not (<= t_3 1e+264)))
(- (+ z a) b)
(- (+ (* z (+ (/ x t_1) (/ y t_1))) (/ t_2 t_1)) (/ (* y b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t + (x + y);
double t_2 = (y + t) * a;
double t_3 = ((t_2 + (z * (x + y))) - (y * b)) / (y + (x + t));
double tmp;
if ((t_3 <= -1e+284) || !(t_3 <= 1e+264)) {
tmp = (z + a) - b;
} else {
tmp = ((z * ((x / t_1) + (y / t_1))) + (t_2 / t_1)) - ((y * 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) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = t + (x + y)
t_2 = (y + t) * a
t_3 = ((t_2 + (z * (x + y))) - (y * b)) / (y + (x + t))
if ((t_3 <= (-1d+284)) .or. (.not. (t_3 <= 1d+264))) then
tmp = (z + a) - b
else
tmp = ((z * ((x / t_1) + (y / t_1))) + (t_2 / t_1)) - ((y * 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 = t + (x + y);
double t_2 = (y + t) * a;
double t_3 = ((t_2 + (z * (x + y))) - (y * b)) / (y + (x + t));
double tmp;
if ((t_3 <= -1e+284) || !(t_3 <= 1e+264)) {
tmp = (z + a) - b;
} else {
tmp = ((z * ((x / t_1) + (y / t_1))) + (t_2 / t_1)) - ((y * b) / t_1);
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t + (x + y) t_2 = (y + t) * a t_3 = ((t_2 + (z * (x + y))) - (y * b)) / (y + (x + t)) tmp = 0 if (t_3 <= -1e+284) or not (t_3 <= 1e+264): tmp = (z + a) - b else: tmp = ((z * ((x / t_1) + (y / t_1))) + (t_2 / t_1)) - ((y * b) / t_1) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t + Float64(x + y)) t_2 = Float64(Float64(y + t) * a) t_3 = Float64(Float64(Float64(t_2 + Float64(z * Float64(x + y))) - Float64(y * b)) / Float64(y + Float64(x + t))) tmp = 0.0 if ((t_3 <= -1e+284) || !(t_3 <= 1e+264)) tmp = Float64(Float64(z + a) - b); else tmp = Float64(Float64(Float64(z * Float64(Float64(x / t_1) + Float64(y / t_1))) + Float64(t_2 / t_1)) - Float64(Float64(y * b) / t_1)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t + (x + y); t_2 = (y + t) * a; t_3 = ((t_2 + (z * (x + y))) - (y * b)) / (y + (x + t)); tmp = 0.0; if ((t_3 <= -1e+284) || ~((t_3 <= 1e+264))) tmp = (z + a) - b; else tmp = ((z * ((x / t_1) + (y / t_1))) + (t_2 / t_1)) - ((y * b) / t_1); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(t$95$2 + N[(z * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$3, -1e+284], N[Not[LessEqual[t$95$3, 1e+264]], $MachinePrecision]], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(N[(N[(z * N[(N[(x / t$95$1), $MachinePrecision] + N[(y / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$2 / t$95$1), $MachinePrecision]), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \left(x + y\right)\\
t_2 := \left(y + t\right) \cdot a\\
t_3 := \frac{\left(t_2 + z \cdot \left(x + y\right)\right) - y \cdot b}{y + \left(x + t\right)}\\
\mathbf{if}\;t_3 \leq -1 \cdot 10^{+284} \lor \neg \left(t_3 \leq 10^{+264}\right):\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot \left(\frac{x}{t_1} + \frac{y}{t_1}\right) + \frac{t_2}{t_1}\right) - \frac{y \cdot b}{t_1}\\
\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)) < -1.00000000000000008e284 or 1.00000000000000004e264 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 9.6%
Taylor expanded in y around inf 74.9%
if -1.00000000000000008e284 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 1.00000000000000004e264Initial program 98.6%
Taylor expanded in z around 0 98.8%
Final simplification89.2%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ (- (+ (* (+ y t) a) (* z (+ x y))) (* y b)) (+ y (+ x t))))) (if (or (<= t_1 -4e+290) (not (<= t_1 1e+264))) (- (+ z a) b) t_1)))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((((y + t) * a) + (z * (x + y))) - (y * b)) / (y + (x + t));
double tmp;
if ((t_1 <= -4e+290) || !(t_1 <= 1e+264)) {
tmp = (z + a) - 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 = ((((y + t) * a) + (z * (x + y))) - (y * b)) / (y + (x + t))
if ((t_1 <= (-4d+290)) .or. (.not. (t_1 <= 1d+264))) then
tmp = (z + a) - 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 = ((((y + t) * a) + (z * (x + y))) - (y * b)) / (y + (x + t));
double tmp;
if ((t_1 <= -4e+290) || !(t_1 <= 1e+264)) {
tmp = (z + a) - b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = ((((y + t) * a) + (z * (x + y))) - (y * b)) / (y + (x + t)) tmp = 0 if (t_1 <= -4e+290) or not (t_1 <= 1e+264): tmp = (z + a) - b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(Float64(y + t) * a) + Float64(z * Float64(x + y))) - Float64(y * b)) / Float64(y + Float64(x + t))) tmp = 0.0 if ((t_1 <= -4e+290) || !(t_1 <= 1e+264)) tmp = Float64(Float64(z + a) - b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = ((((y + t) * a) + (z * (x + y))) - (y * b)) / (y + (x + t)); tmp = 0.0; if ((t_1 <= -4e+290) || ~((t_1 <= 1e+264))) tmp = (z + a) - b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision] + N[(z * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -4e+290], N[Not[LessEqual[t$95$1, 1e+264]], $MachinePrecision]], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], t$95$1]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\left(\left(y + t\right) \cdot a + z \cdot \left(x + y\right)\right) - y \cdot b}{y + \left(x + t\right)}\\
\mathbf{if}\;t_1 \leq -4 \cdot 10^{+290} \lor \neg \left(t_1 \leq 10^{+264}\right):\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\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)) < -4.00000000000000025e290 or 1.00000000000000004e264 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 7.8%
Taylor expanded in y around inf 74.4%
if -4.00000000000000025e290 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 1.00000000000000004e264Initial program 98.6%
Final simplification89.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ y (/ (+ y (+ x t)) (- a b)))) (t_2 (- (+ z a) b)))
(if (<= y -1.8e+124)
t_2
(if (<= y -1.15e+87)
t_1
(if (<= y -4.2e-81)
t_2
(if (<= y 5.4e-129)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 0.029)
(+ z (/ (* y a) (+ x y)))
(if (<= y 3.3e+35)
(/ a (/ (+ t (+ x y)) (+ y t)))
(if (<= y 8.8e+83)
(+ z (* a (+ (/ t x) (/ y x))))
(if (<= y 1.2e+103)
(/ y (/ (+ x y) (- a b)))
(if (<= y 8.2e+132) t_1 t_2)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y / ((y + (x + t)) / (a - b));
double t_2 = (z + a) - b;
double tmp;
if (y <= -1.8e+124) {
tmp = t_2;
} else if (y <= -1.15e+87) {
tmp = t_1;
} else if (y <= -4.2e-81) {
tmp = t_2;
} else if (y <= 5.4e-129) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 0.029) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 3.3e+35) {
tmp = a / ((t + (x + y)) / (y + t));
} else if (y <= 8.8e+83) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 1.2e+103) {
tmp = y / ((x + y) / (a - b));
} else if (y <= 8.2e+132) {
tmp = t_1;
} 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 / ((y + (x + t)) / (a - b))
t_2 = (z + a) - b
if (y <= (-1.8d+124)) then
tmp = t_2
else if (y <= (-1.15d+87)) then
tmp = t_1
else if (y <= (-4.2d-81)) then
tmp = t_2
else if (y <= 5.4d-129) then
tmp = a + (x / ((x + t) / z))
else if (y <= 0.029d0) then
tmp = z + ((y * a) / (x + y))
else if (y <= 3.3d+35) then
tmp = a / ((t + (x + y)) / (y + t))
else if (y <= 8.8d+83) then
tmp = z + (a * ((t / x) + (y / x)))
else if (y <= 1.2d+103) then
tmp = y / ((x + y) / (a - b))
else if (y <= 8.2d+132) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y / ((y + (x + t)) / (a - b));
double t_2 = (z + a) - b;
double tmp;
if (y <= -1.8e+124) {
tmp = t_2;
} else if (y <= -1.15e+87) {
tmp = t_1;
} else if (y <= -4.2e-81) {
tmp = t_2;
} else if (y <= 5.4e-129) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 0.029) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 3.3e+35) {
tmp = a / ((t + (x + y)) / (y + t));
} else if (y <= 8.8e+83) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 1.2e+103) {
tmp = y / ((x + y) / (a - b));
} else if (y <= 8.2e+132) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y / ((y + (x + t)) / (a - b)) t_2 = (z + a) - b tmp = 0 if y <= -1.8e+124: tmp = t_2 elif y <= -1.15e+87: tmp = t_1 elif y <= -4.2e-81: tmp = t_2 elif y <= 5.4e-129: tmp = a + (x / ((x + t) / z)) elif y <= 0.029: tmp = z + ((y * a) / (x + y)) elif y <= 3.3e+35: tmp = a / ((t + (x + y)) / (y + t)) elif y <= 8.8e+83: tmp = z + (a * ((t / x) + (y / x))) elif y <= 1.2e+103: tmp = y / ((x + y) / (a - b)) elif y <= 8.2e+132: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y / Float64(Float64(y + Float64(x + t)) / Float64(a - b))) t_2 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -1.8e+124) tmp = t_2; elseif (y <= -1.15e+87) tmp = t_1; elseif (y <= -4.2e-81) tmp = t_2; elseif (y <= 5.4e-129) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 0.029) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 3.3e+35) tmp = Float64(a / Float64(Float64(t + Float64(x + y)) / Float64(y + t))); elseif (y <= 8.8e+83) tmp = Float64(z + Float64(a * Float64(Float64(t / x) + Float64(y / x)))); elseif (y <= 1.2e+103) tmp = Float64(y / Float64(Float64(x + y) / Float64(a - b))); elseif (y <= 8.2e+132) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y / ((y + (x + t)) / (a - b)); t_2 = (z + a) - b; tmp = 0.0; if (y <= -1.8e+124) tmp = t_2; elseif (y <= -1.15e+87) tmp = t_1; elseif (y <= -4.2e-81) tmp = t_2; elseif (y <= 5.4e-129) tmp = a + (x / ((x + t) / z)); elseif (y <= 0.029) tmp = z + ((y * a) / (x + y)); elseif (y <= 3.3e+35) tmp = a / ((t + (x + y)) / (y + t)); elseif (y <= 8.8e+83) tmp = z + (a * ((t / x) + (y / x))); elseif (y <= 1.2e+103) tmp = y / ((x + y) / (a - b)); elseif (y <= 8.2e+132) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y / N[(N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision] / N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -1.8e+124], t$95$2, If[LessEqual[y, -1.15e+87], t$95$1, If[LessEqual[y, -4.2e-81], t$95$2, If[LessEqual[y, 5.4e-129], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.029], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+35], N[(a / N[(N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.8e+83], N[(z + N[(a * N[(N[(t / x), $MachinePrecision] + N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.2e+103], N[(y / N[(N[(x + y), $MachinePrecision] / N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e+132], t$95$1, t$95$2]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{y + \left(x + t\right)}{a - b}}\\
t_2 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -1.8 \cdot 10^{+124}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.15 \cdot 10^{+87}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -4.2 \cdot 10^{-81}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 5.4 \cdot 10^{-129}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 0.029:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+35}:\\
\;\;\;\;\frac{a}{\frac{t + \left(x + y\right)}{y + t}}\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{+83}:\\
\;\;\;\;z + a \cdot \left(\frac{t}{x} + \frac{y}{x}\right)\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{+103}:\\
\;\;\;\;\frac{y}{\frac{x + y}{a - b}}\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{+132}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -1.79999999999999993e124 or -1.1500000000000001e87 < y < -4.1999999999999998e-81 or 8.19999999999999983e132 < y Initial program 48.9%
Taylor expanded in y around inf 75.0%
if -1.79999999999999993e124 < y < -1.1500000000000001e87 or 1.1999999999999999e103 < y < 8.19999999999999983e132Initial program 62.5%
Taylor expanded in y around inf 55.6%
Taylor expanded in z around 0 51.6%
associate-/l*85.1%
+-commutative85.1%
+-commutative85.1%
associate-+l+85.1%
+-commutative85.1%
Simplified85.1%
if -4.1999999999999998e-81 < y < 5.39999999999999998e-129Initial program 80.2%
Taylor expanded in a around 0 89.3%
associate--l+89.3%
+-commutative89.3%
+-commutative89.3%
+-commutative89.3%
div-sub89.3%
+-commutative89.3%
*-commutative89.3%
+-commutative89.3%
Simplified89.3%
Taylor expanded in y around 0 74.8%
associate-/l*78.1%
Simplified78.1%
Taylor expanded in y around inf 63.9%
if 5.39999999999999998e-129 < y < 0.0290000000000000015Initial program 74.6%
Taylor expanded in a around 0 80.4%
associate--l+80.4%
+-commutative80.4%
+-commutative80.4%
+-commutative80.4%
div-sub80.4%
+-commutative80.4%
*-commutative80.4%
+-commutative80.4%
Simplified80.4%
Taylor expanded in y around 0 63.4%
associate-/l*76.2%
Simplified76.2%
Taylor expanded in t around 0 69.3%
if 0.0290000000000000015 < y < 3.3000000000000002e35Initial program 34.5%
Taylor expanded in a around inf 34.5%
associate-/l*100.0%
+-commutative100.0%
Simplified100.0%
if 3.3000000000000002e35 < y < 8.79999999999999995e83Initial program 68.7%
Taylor expanded in x around inf 57.7%
associate--r+57.7%
sub-neg57.7%
mul-1-neg57.7%
associate-+r+57.7%
+-commutative57.7%
associate--l+57.7%
Simplified88.8%
Taylor expanded in a around inf 88.5%
if 8.79999999999999995e83 < y < 1.1999999999999999e103Initial program 1.8%
Taylor expanded in y around inf 1.9%
Taylor expanded in z around 0 2.1%
associate-/l*50.4%
+-commutative50.4%
+-commutative50.4%
associate-+l+50.4%
+-commutative50.4%
Simplified50.4%
Taylor expanded in t around 0 51.8%
associate-/l*100.0%
Simplified100.0%
Final simplification73.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ z (* a (+ (/ t x) (/ y x)))))
(t_2 (+ a (/ (- (* z (+ x y)) (* y b)) (+ t (+ x y))))))
(if (<= x -5.6e+199)
t_1
(if (<= x -2.25e-29)
(+ a (/ x (/ (+ x t) z)))
(if (<= x 2.95e-64)
t_2
(if (<= x 2.15e-10) (- (+ z a) b) (if (<= x 1.5e+130) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z + (a * ((t / x) + (y / x)));
double t_2 = a + (((z * (x + y)) - (y * b)) / (t + (x + y)));
double tmp;
if (x <= -5.6e+199) {
tmp = t_1;
} else if (x <= -2.25e-29) {
tmp = a + (x / ((x + t) / z));
} else if (x <= 2.95e-64) {
tmp = t_2;
} else if (x <= 2.15e-10) {
tmp = (z + a) - b;
} else if (x <= 1.5e+130) {
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 = z + (a * ((t / x) + (y / x)))
t_2 = a + (((z * (x + y)) - (y * b)) / (t + (x + y)))
if (x <= (-5.6d+199)) then
tmp = t_1
else if (x <= (-2.25d-29)) then
tmp = a + (x / ((x + t) / z))
else if (x <= 2.95d-64) then
tmp = t_2
else if (x <= 2.15d-10) then
tmp = (z + a) - b
else if (x <= 1.5d+130) 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 = z + (a * ((t / x) + (y / x)));
double t_2 = a + (((z * (x + y)) - (y * b)) / (t + (x + y)));
double tmp;
if (x <= -5.6e+199) {
tmp = t_1;
} else if (x <= -2.25e-29) {
tmp = a + (x / ((x + t) / z));
} else if (x <= 2.95e-64) {
tmp = t_2;
} else if (x <= 2.15e-10) {
tmp = (z + a) - b;
} else if (x <= 1.5e+130) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z + (a * ((t / x) + (y / x))) t_2 = a + (((z * (x + y)) - (y * b)) / (t + (x + y))) tmp = 0 if x <= -5.6e+199: tmp = t_1 elif x <= -2.25e-29: tmp = a + (x / ((x + t) / z)) elif x <= 2.95e-64: tmp = t_2 elif x <= 2.15e-10: tmp = (z + a) - b elif x <= 1.5e+130: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z + Float64(a * Float64(Float64(t / x) + Float64(y / x)))) t_2 = Float64(a + Float64(Float64(Float64(z * Float64(x + y)) - Float64(y * b)) / Float64(t + Float64(x + y)))) tmp = 0.0 if (x <= -5.6e+199) tmp = t_1; elseif (x <= -2.25e-29) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (x <= 2.95e-64) tmp = t_2; elseif (x <= 2.15e-10) tmp = Float64(Float64(z + a) - b); elseif (x <= 1.5e+130) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z + (a * ((t / x) + (y / x))); t_2 = a + (((z * (x + y)) - (y * b)) / (t + (x + y))); tmp = 0.0; if (x <= -5.6e+199) tmp = t_1; elseif (x <= -2.25e-29) tmp = a + (x / ((x + t) / z)); elseif (x <= 2.95e-64) tmp = t_2; elseif (x <= 2.15e-10) tmp = (z + a) - b; elseif (x <= 1.5e+130) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z + N[(a * N[(N[(t / x), $MachinePrecision] + N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a + N[(N[(N[(z * N[(x + y), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.6e+199], t$95$1, If[LessEqual[x, -2.25e-29], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.95e-64], t$95$2, If[LessEqual[x, 2.15e-10], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[x, 1.5e+130], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z + a \cdot \left(\frac{t}{x} + \frac{y}{x}\right)\\
t_2 := a + \frac{z \cdot \left(x + y\right) - y \cdot b}{t + \left(x + y\right)}\\
\mathbf{if}\;x \leq -5.6 \cdot 10^{+199}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq -2.25 \cdot 10^{-29}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;x \leq 2.95 \cdot 10^{-64}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \leq 2.15 \cdot 10^{-10}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;x \leq 1.5 \cdot 10^{+130}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -5.6000000000000002e199 or 1.5e130 < x Initial program 52.5%
Taylor expanded in x around inf 59.0%
associate--r+59.0%
sub-neg59.0%
mul-1-neg59.0%
associate-+r+59.0%
+-commutative59.0%
associate--l+61.1%
Simplified85.0%
Taylor expanded in a around inf 78.4%
if -5.6000000000000002e199 < x < -2.2499999999999999e-29Initial program 65.0%
Taylor expanded in a around 0 72.8%
associate--l+72.8%
+-commutative72.8%
+-commutative72.8%
+-commutative72.8%
div-sub72.8%
+-commutative72.8%
*-commutative72.8%
+-commutative72.8%
Simplified72.8%
Taylor expanded in y around 0 71.1%
associate-/l*81.8%
Simplified81.8%
Taylor expanded in y around inf 67.5%
if -2.2499999999999999e-29 < x < 2.94999999999999997e-64 or 2.15000000000000007e-10 < x < 1.5e130Initial program 66.9%
Taylor expanded in a around 0 79.9%
associate--l+79.9%
+-commutative79.9%
+-commutative79.9%
+-commutative79.9%
div-sub79.9%
+-commutative79.9%
*-commutative79.9%
+-commutative79.9%
Simplified79.9%
Taylor expanded in y around inf 75.8%
if 2.94999999999999997e-64 < x < 2.15000000000000007e-10Initial program 37.8%
Taylor expanded in y around inf 77.9%
Final simplification74.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)))
(if (<= y -4.2e+123)
t_1
(if (<= y -5e+111)
(/ a (/ (+ x y) y))
(if (<= y -6.5e-79)
t_1
(if (<= y 1.1e-127)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 0.016)
(+ z (/ (* y a) (+ x y)))
(if (<= y 2.3e+33)
a
(if (<= y 2.7e+93)
(+ z (* a (+ (/ t x) (/ y x))))
(if (<= y 4.1e+122)
(/ (- b) (/ (+ t (+ x y)) y))
t_1))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 1.1e-127) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 0.016) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 2.3e+33) {
tmp = a;
} else if (y <= 2.7e+93) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 4.1e+122) {
tmp = -b / ((t + (x + y)) / y);
} 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 = (z + a) - b
if (y <= (-4.2d+123)) then
tmp = t_1
else if (y <= (-5d+111)) then
tmp = a / ((x + y) / y)
else if (y <= (-6.5d-79)) then
tmp = t_1
else if (y <= 1.1d-127) then
tmp = a + (x / ((x + t) / z))
else if (y <= 0.016d0) then
tmp = z + ((y * a) / (x + y))
else if (y <= 2.3d+33) then
tmp = a
else if (y <= 2.7d+93) then
tmp = z + (a * ((t / x) + (y / x)))
else if (y <= 4.1d+122) then
tmp = -b / ((t + (x + y)) / y)
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 = (z + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 1.1e-127) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 0.016) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 2.3e+33) {
tmp = a;
} else if (y <= 2.7e+93) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 4.1e+122) {
tmp = -b / ((t + (x + y)) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b tmp = 0 if y <= -4.2e+123: tmp = t_1 elif y <= -5e+111: tmp = a / ((x + y) / y) elif y <= -6.5e-79: tmp = t_1 elif y <= 1.1e-127: tmp = a + (x / ((x + t) / z)) elif y <= 0.016: tmp = z + ((y * a) / (x + y)) elif y <= 2.3e+33: tmp = a elif y <= 2.7e+93: tmp = z + (a * ((t / x) + (y / x))) elif y <= 4.1e+122: tmp = -b / ((t + (x + y)) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 1.1e-127) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 0.016) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 2.3e+33) tmp = a; elseif (y <= 2.7e+93) tmp = Float64(z + Float64(a * Float64(Float64(t / x) + Float64(y / x)))); elseif (y <= 4.1e+122) tmp = Float64(Float64(-b) / Float64(Float64(t + Float64(x + y)) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; tmp = 0.0; if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = a / ((x + y) / y); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 1.1e-127) tmp = a + (x / ((x + t) / z)); elseif (y <= 0.016) tmp = z + ((y * a) / (x + y)); elseif (y <= 2.3e+33) tmp = a; elseif (y <= 2.7e+93) tmp = z + (a * ((t / x) + (y / x))); elseif (y <= 4.1e+122) tmp = -b / ((t + (x + y)) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -4.2e+123], t$95$1, If[LessEqual[y, -5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.5e-79], t$95$1, If[LessEqual[y, 1.1e-127], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.016], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.3e+33], a, If[LessEqual[y, 2.7e+93], N[(z + N[(a * N[(N[(t / x), $MachinePrecision] + N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.1e+122], N[((-b) / N[(N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -6.5 \cdot 10^{-79}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{-127}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 0.016:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 2.3 \cdot 10^{+33}:\\
\;\;\;\;a\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{+93}:\\
\;\;\;\;z + a \cdot \left(\frac{t}{x} + \frac{y}{x}\right)\\
\mathbf{elif}\;y \leq 4.1 \cdot 10^{+122}:\\
\;\;\;\;\frac{-b}{\frac{t + \left(x + y\right)}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.19999999999999988e123 or -4.9999999999999997e111 < y < -6.5000000000000003e-79 or 4.1000000000000002e122 < y Initial program 49.8%
Taylor expanded in y around inf 74.9%
if -4.19999999999999988e123 < y < -4.9999999999999997e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -6.5000000000000003e-79 < y < 1.1000000000000001e-127Initial program 80.2%
Taylor expanded in a around 0 89.3%
associate--l+89.3%
+-commutative89.3%
+-commutative89.3%
+-commutative89.3%
div-sub89.3%
+-commutative89.3%
*-commutative89.3%
+-commutative89.3%
Simplified89.3%
Taylor expanded in y around 0 74.8%
associate-/l*78.1%
Simplified78.1%
Taylor expanded in y around inf 63.9%
if 1.1000000000000001e-127 < y < 0.016Initial program 74.6%
Taylor expanded in a around 0 80.4%
associate--l+80.4%
+-commutative80.4%
+-commutative80.4%
+-commutative80.4%
div-sub80.4%
+-commutative80.4%
*-commutative80.4%
+-commutative80.4%
Simplified80.4%
Taylor expanded in y around 0 63.4%
associate-/l*76.2%
Simplified76.2%
Taylor expanded in t around 0 69.3%
if 0.016 < y < 2.30000000000000011e33Initial program 34.5%
Taylor expanded in t around inf 86.2%
if 2.30000000000000011e33 < y < 2.6999999999999999e93Initial program 68.7%
Taylor expanded in x around inf 57.7%
associate--r+57.7%
sub-neg57.7%
mul-1-neg57.7%
associate-+r+57.7%
+-commutative57.7%
associate--l+57.7%
Simplified88.8%
Taylor expanded in a around inf 88.5%
if 2.6999999999999999e93 < y < 4.1000000000000002e122Initial program 58.5%
Taylor expanded in b around inf 38.5%
mul-1-neg38.5%
associate-/l*65.5%
distribute-neg-frac65.5%
+-commutative65.5%
Simplified65.5%
Final simplification71.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)) (t_2 (+ t (+ x y))))
(if (<= y -4.2e+123)
t_1
(if (<= y -5e+111)
(/ a (/ (+ x y) y))
(if (<= y -6.5e-79)
t_1
(if (<= y 6.6e-128)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 6.4e-7)
(+ z (/ (* y a) (+ x y)))
(if (<= y 1.1e+33)
(/ a (/ t_2 (+ y t)))
(if (<= y 1.2e+95)
(+ z (* a (+ (/ t x) (/ y x))))
(if (<= y 8.2e+132) (/ (- b) (/ t_2 y)) t_1))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double t_2 = t + (x + y);
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 6.6e-128) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 6.4e-7) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 1.1e+33) {
tmp = a / (t_2 / (y + t));
} else if (y <= 1.2e+95) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 8.2e+132) {
tmp = -b / (t_2 / y);
} 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 = (z + a) - b
t_2 = t + (x + y)
if (y <= (-4.2d+123)) then
tmp = t_1
else if (y <= (-5d+111)) then
tmp = a / ((x + y) / y)
else if (y <= (-6.5d-79)) then
tmp = t_1
else if (y <= 6.6d-128) then
tmp = a + (x / ((x + t) / z))
else if (y <= 6.4d-7) then
tmp = z + ((y * a) / (x + y))
else if (y <= 1.1d+33) then
tmp = a / (t_2 / (y + t))
else if (y <= 1.2d+95) then
tmp = z + (a * ((t / x) + (y / x)))
else if (y <= 8.2d+132) then
tmp = -b / (t_2 / y)
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 = (z + a) - b;
double t_2 = t + (x + y);
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 6.6e-128) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 6.4e-7) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 1.1e+33) {
tmp = a / (t_2 / (y + t));
} else if (y <= 1.2e+95) {
tmp = z + (a * ((t / x) + (y / x)));
} else if (y <= 8.2e+132) {
tmp = -b / (t_2 / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b t_2 = t + (x + y) tmp = 0 if y <= -4.2e+123: tmp = t_1 elif y <= -5e+111: tmp = a / ((x + y) / y) elif y <= -6.5e-79: tmp = t_1 elif y <= 6.6e-128: tmp = a + (x / ((x + t) / z)) elif y <= 6.4e-7: tmp = z + ((y * a) / (x + y)) elif y <= 1.1e+33: tmp = a / (t_2 / (y + t)) elif y <= 1.2e+95: tmp = z + (a * ((t / x) + (y / x))) elif y <= 8.2e+132: tmp = -b / (t_2 / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) t_2 = Float64(t + Float64(x + y)) tmp = 0.0 if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 6.6e-128) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 6.4e-7) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 1.1e+33) tmp = Float64(a / Float64(t_2 / Float64(y + t))); elseif (y <= 1.2e+95) tmp = Float64(z + Float64(a * Float64(Float64(t / x) + Float64(y / x)))); elseif (y <= 8.2e+132) tmp = Float64(Float64(-b) / Float64(t_2 / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; t_2 = t + (x + y); tmp = 0.0; if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = a / ((x + y) / y); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 6.6e-128) tmp = a + (x / ((x + t) / z)); elseif (y <= 6.4e-7) tmp = z + ((y * a) / (x + y)); elseif (y <= 1.1e+33) tmp = a / (t_2 / (y + t)); elseif (y <= 1.2e+95) tmp = z + (a * ((t / x) + (y / x))); elseif (y <= 8.2e+132) tmp = -b / (t_2 / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, Block[{t$95$2 = N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.2e+123], t$95$1, If[LessEqual[y, -5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.5e-79], t$95$1, If[LessEqual[y, 6.6e-128], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.4e-7], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.1e+33], N[(a / N[(t$95$2 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.2e+95], N[(z + N[(a * N[(N[(t / x), $MachinePrecision] + N[(y / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e+132], N[((-b) / N[(t$95$2 / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
t_2 := t + \left(x + y\right)\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -6.5 \cdot 10^{-79}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 6.6 \cdot 10^{-128}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 6.4 \cdot 10^{-7}:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+33}:\\
\;\;\;\;\frac{a}{\frac{t_2}{y + t}}\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{+95}:\\
\;\;\;\;z + a \cdot \left(\frac{t}{x} + \frac{y}{x}\right)\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{+132}:\\
\;\;\;\;\frac{-b}{\frac{t_2}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.19999999999999988e123 or -4.9999999999999997e111 < y < -6.5000000000000003e-79 or 8.19999999999999983e132 < y Initial program 49.3%
Taylor expanded in y around inf 74.6%
if -4.19999999999999988e123 < y < -4.9999999999999997e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -6.5000000000000003e-79 < y < 6.6e-128Initial program 80.2%
Taylor expanded in a around 0 89.3%
associate--l+89.3%
+-commutative89.3%
+-commutative89.3%
+-commutative89.3%
div-sub89.3%
+-commutative89.3%
*-commutative89.3%
+-commutative89.3%
Simplified89.3%
Taylor expanded in y around 0 74.8%
associate-/l*78.1%
Simplified78.1%
Taylor expanded in y around inf 63.9%
if 6.6e-128 < y < 6.4000000000000001e-7Initial program 74.6%
Taylor expanded in a around 0 80.4%
associate--l+80.4%
+-commutative80.4%
+-commutative80.4%
+-commutative80.4%
div-sub80.4%
+-commutative80.4%
*-commutative80.4%
+-commutative80.4%
Simplified80.4%
Taylor expanded in y around 0 63.4%
associate-/l*76.2%
Simplified76.2%
Taylor expanded in t around 0 69.3%
if 6.4000000000000001e-7 < y < 1.09999999999999997e33Initial program 34.5%
Taylor expanded in a around inf 34.5%
associate-/l*100.0%
+-commutative100.0%
Simplified100.0%
if 1.09999999999999997e33 < y < 1.2e95Initial program 68.7%
Taylor expanded in x around inf 57.7%
associate--r+57.7%
sub-neg57.7%
mul-1-neg57.7%
associate-+r+57.7%
+-commutative57.7%
associate--l+57.7%
Simplified88.8%
Taylor expanded in a around inf 88.5%
if 1.2e95 < y < 8.19999999999999983e132Initial program 60.3%
Taylor expanded in b around inf 48.6%
mul-1-neg48.6%
associate-/l*79.7%
distribute-neg-frac79.7%
+-commutative79.7%
Simplified79.7%
Final simplification72.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))) (t_2 (/ y (/ t_1 (- a b)))) (t_3 (- (+ z a) b)))
(if (<= y -1.3e+124)
t_3
(if (<= y -1.08e+87)
t_2
(if (<= y -1.16e+36)
(+ z a)
(if (<= y -7.8e-114)
(- a (/ (* y b) t_1))
(if (<= y 3.2e-230)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 4.2e+65)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 2.1e+133) t_2 t_3)))))))))
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 / (a - b));
double t_3 = (z + a) - b;
double tmp;
if (y <= -1.3e+124) {
tmp = t_3;
} else if (y <= -1.08e+87) {
tmp = t_2;
} else if (y <= -1.16e+36) {
tmp = z + a;
} else if (y <= -7.8e-114) {
tmp = a - ((y * b) / t_1);
} else if (y <= 3.2e-230) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4.2e+65) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.1e+133) {
tmp = t_2;
} else {
tmp = t_3;
}
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 = y + (x + t)
t_2 = y / (t_1 / (a - b))
t_3 = (z + a) - b
if (y <= (-1.3d+124)) then
tmp = t_3
else if (y <= (-1.08d+87)) then
tmp = t_2
else if (y <= (-1.16d+36)) then
tmp = z + a
else if (y <= (-7.8d-114)) then
tmp = a - ((y * b) / t_1)
else if (y <= 3.2d-230) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 4.2d+65) then
tmp = a + (x / ((x + t) / z))
else if (y <= 2.1d+133) then
tmp = t_2
else
tmp = t_3
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 / (a - b));
double t_3 = (z + a) - b;
double tmp;
if (y <= -1.3e+124) {
tmp = t_3;
} else if (y <= -1.08e+87) {
tmp = t_2;
} else if (y <= -1.16e+36) {
tmp = z + a;
} else if (y <= -7.8e-114) {
tmp = a - ((y * b) / t_1);
} else if (y <= 3.2e-230) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4.2e+65) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.1e+133) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = y / (t_1 / (a - b)) t_3 = (z + a) - b tmp = 0 if y <= -1.3e+124: tmp = t_3 elif y <= -1.08e+87: tmp = t_2 elif y <= -1.16e+36: tmp = z + a elif y <= -7.8e-114: tmp = a - ((y * b) / t_1) elif y <= 3.2e-230: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 4.2e+65: tmp = a + (x / ((x + t) / z)) elif y <= 2.1e+133: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(y / Float64(t_1 / Float64(a - b))) t_3 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -1.3e+124) tmp = t_3; elseif (y <= -1.08e+87) tmp = t_2; elseif (y <= -1.16e+36) tmp = Float64(z + a); elseif (y <= -7.8e-114) tmp = Float64(a - Float64(Float64(y * b) / t_1)); elseif (y <= 3.2e-230) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 4.2e+65) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 2.1e+133) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = y / (t_1 / (a - b)); t_3 = (z + a) - b; tmp = 0.0; if (y <= -1.3e+124) tmp = t_3; elseif (y <= -1.08e+87) tmp = t_2; elseif (y <= -1.16e+36) tmp = z + a; elseif (y <= -7.8e-114) tmp = a - ((y * b) / t_1); elseif (y <= 3.2e-230) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 4.2e+65) tmp = a + (x / ((x + t) / z)); elseif (y <= 2.1e+133) tmp = t_2; else tmp = t_3; 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 / N[(t$95$1 / N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -1.3e+124], t$95$3, If[LessEqual[y, -1.08e+87], t$95$2, If[LessEqual[y, -1.16e+36], N[(z + a), $MachinePrecision], If[LessEqual[y, -7.8e-114], N[(a - N[(N[(y * b), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.2e-230], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.2e+65], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.1e+133], t$95$2, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := \frac{y}{\frac{t_1}{a - b}}\\
t_3 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -1.3 \cdot 10^{+124}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -1.08 \cdot 10^{+87}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -1.16 \cdot 10^{+36}:\\
\;\;\;\;z + a\\
\mathbf{elif}\;y \leq -7.8 \cdot 10^{-114}:\\
\;\;\;\;a - \frac{y \cdot b}{t_1}\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{-230}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 4.2 \cdot 10^{+65}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+133}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if y < -1.3e124 or 2.1e133 < y Initial program 38.8%
Taylor expanded in y around inf 83.8%
if -1.3e124 < y < -1.08000000000000007e87 or 4.19999999999999983e65 < y < 2.1e133Initial program 60.3%
Taylor expanded in y around inf 54.8%
Taylor expanded in z around 0 48.4%
associate-/l*78.7%
+-commutative78.7%
+-commutative78.7%
associate-+l+78.7%
+-commutative78.7%
Simplified78.7%
if -1.08000000000000007e87 < y < -1.15999999999999998e36Initial program 68.4%
Taylor expanded in y around inf 69.0%
Taylor expanded in b around 0 79.2%
+-commutative79.2%
Simplified79.2%
if -1.15999999999999998e36 < y < -7.80000000000000003e-114Initial program 73.8%
Taylor expanded in a around 0 93.3%
associate--l+93.3%
+-commutative93.3%
+-commutative93.3%
+-commutative93.3%
div-sub93.3%
+-commutative93.3%
*-commutative93.3%
+-commutative93.3%
Simplified93.3%
Taylor expanded in y around inf 80.2%
Taylor expanded in z around 0 67.3%
associate-*r/67.3%
mul-1-neg67.3%
*-commutative67.3%
distribute-lft-neg-in67.3%
neg-mul-167.3%
*-commutative67.3%
neg-mul-167.3%
+-commutative67.3%
+-commutative67.3%
associate-+l+67.3%
+-commutative67.3%
Simplified67.3%
if -7.80000000000000003e-114 < y < 3.2e-230Initial program 82.9%
Taylor expanded in y around 0 71.9%
if 3.2e-230 < y < 4.19999999999999983e65Initial program 67.3%
Taylor expanded in a around 0 85.0%
associate--l+85.0%
+-commutative85.0%
+-commutative85.0%
+-commutative85.0%
div-sub85.0%
+-commutative85.0%
*-commutative85.0%
+-commutative85.0%
Simplified85.0%
Taylor expanded in y around 0 71.0%
associate-/l*81.5%
Simplified81.5%
Taylor expanded in y around inf 62.7%
Final simplification73.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ y (/ (+ y (+ x t)) (- a b)))) (t_2 (- (+ z a) b)))
(if (<= y -1.85e+126)
t_2
(if (<= y -2.6e+87)
t_1
(if (<= y -6.6e-80)
t_2
(if (<= y 3.4e-225)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 1.62e+59)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 8.2e+132) t_1 t_2))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y / ((y + (x + t)) / (a - b));
double t_2 = (z + a) - b;
double tmp;
if (y <= -1.85e+126) {
tmp = t_2;
} else if (y <= -2.6e+87) {
tmp = t_1;
} else if (y <= -6.6e-80) {
tmp = t_2;
} else if (y <= 3.4e-225) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 1.62e+59) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 8.2e+132) {
tmp = t_1;
} 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 / ((y + (x + t)) / (a - b))
t_2 = (z + a) - b
if (y <= (-1.85d+126)) then
tmp = t_2
else if (y <= (-2.6d+87)) then
tmp = t_1
else if (y <= (-6.6d-80)) then
tmp = t_2
else if (y <= 3.4d-225) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 1.62d+59) then
tmp = a + (x / ((x + t) / z))
else if (y <= 8.2d+132) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y / ((y + (x + t)) / (a - b));
double t_2 = (z + a) - b;
double tmp;
if (y <= -1.85e+126) {
tmp = t_2;
} else if (y <= -2.6e+87) {
tmp = t_1;
} else if (y <= -6.6e-80) {
tmp = t_2;
} else if (y <= 3.4e-225) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 1.62e+59) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 8.2e+132) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y / ((y + (x + t)) / (a - b)) t_2 = (z + a) - b tmp = 0 if y <= -1.85e+126: tmp = t_2 elif y <= -2.6e+87: tmp = t_1 elif y <= -6.6e-80: tmp = t_2 elif y <= 3.4e-225: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 1.62e+59: tmp = a + (x / ((x + t) / z)) elif y <= 8.2e+132: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y / Float64(Float64(y + Float64(x + t)) / Float64(a - b))) t_2 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -1.85e+126) tmp = t_2; elseif (y <= -2.6e+87) tmp = t_1; elseif (y <= -6.6e-80) tmp = t_2; elseif (y <= 3.4e-225) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 1.62e+59) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 8.2e+132) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y / ((y + (x + t)) / (a - b)); t_2 = (z + a) - b; tmp = 0.0; if (y <= -1.85e+126) tmp = t_2; elseif (y <= -2.6e+87) tmp = t_1; elseif (y <= -6.6e-80) tmp = t_2; elseif (y <= 3.4e-225) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 1.62e+59) tmp = a + (x / ((x + t) / z)); elseif (y <= 8.2e+132) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y / N[(N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision] / N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -1.85e+126], t$95$2, If[LessEqual[y, -2.6e+87], t$95$1, If[LessEqual[y, -6.6e-80], t$95$2, If[LessEqual[y, 3.4e-225], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.62e+59], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e+132], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y}{\frac{y + \left(x + t\right)}{a - b}}\\
t_2 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -1.85 \cdot 10^{+126}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -2.6 \cdot 10^{+87}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -6.6 \cdot 10^{-80}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 3.4 \cdot 10^{-225}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 1.62 \cdot 10^{+59}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{+132}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -1.8499999999999999e126 or -2.59999999999999998e87 < y < -6.5999999999999999e-80 or 8.19999999999999983e132 < y Initial program 48.9%
Taylor expanded in y around inf 75.0%
if -1.8499999999999999e126 < y < -2.59999999999999998e87 or 1.6200000000000001e59 < y < 8.19999999999999983e132Initial program 60.3%
Taylor expanded in y around inf 54.8%
Taylor expanded in z around 0 48.4%
associate-/l*78.7%
+-commutative78.7%
+-commutative78.7%
associate-+l+78.7%
+-commutative78.7%
Simplified78.7%
if -6.5999999999999999e-80 < y < 3.3999999999999999e-225Initial program 82.8%
Taylor expanded in y around 0 69.7%
if 3.3999999999999999e-225 < y < 1.6200000000000001e59Initial program 67.3%
Taylor expanded in a around 0 85.0%
associate--l+85.0%
+-commutative85.0%
+-commutative85.0%
+-commutative85.0%
div-sub85.0%
+-commutative85.0%
*-commutative85.0%
+-commutative85.0%
Simplified85.0%
Taylor expanded in y around 0 71.0%
associate-/l*81.5%
Simplified81.5%
Taylor expanded in y around inf 62.7%
Final simplification71.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)))
(if (<= y -7.8e+124)
t_1
(if (<= y -1.5e+111)
(/ a (/ (+ x y) y))
(if (<= y -3.6e-88)
t_1
(if (<= y 2.3e-128)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 2.5e+101)
(+ z (/ (* y a) (+ x y)))
(if (<= y 2e+123) (/ (- b) (/ (+ t (+ x y)) y)) t_1))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double tmp;
if (y <= -7.8e+124) {
tmp = t_1;
} else if (y <= -1.5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -3.6e-88) {
tmp = t_1;
} else if (y <= 2.3e-128) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.5e+101) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 2e+123) {
tmp = -b / ((t + (x + y)) / y);
} 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 = (z + a) - b
if (y <= (-7.8d+124)) then
tmp = t_1
else if (y <= (-1.5d+111)) then
tmp = a / ((x + y) / y)
else if (y <= (-3.6d-88)) then
tmp = t_1
else if (y <= 2.3d-128) then
tmp = a + (x / ((x + t) / z))
else if (y <= 2.5d+101) then
tmp = z + ((y * a) / (x + y))
else if (y <= 2d+123) then
tmp = -b / ((t + (x + y)) / y)
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 = (z + a) - b;
double tmp;
if (y <= -7.8e+124) {
tmp = t_1;
} else if (y <= -1.5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -3.6e-88) {
tmp = t_1;
} else if (y <= 2.3e-128) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.5e+101) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 2e+123) {
tmp = -b / ((t + (x + y)) / y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b tmp = 0 if y <= -7.8e+124: tmp = t_1 elif y <= -1.5e+111: tmp = a / ((x + y) / y) elif y <= -3.6e-88: tmp = t_1 elif y <= 2.3e-128: tmp = a + (x / ((x + t) / z)) elif y <= 2.5e+101: tmp = z + ((y * a) / (x + y)) elif y <= 2e+123: tmp = -b / ((t + (x + y)) / y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -7.8e+124) tmp = t_1; elseif (y <= -1.5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif (y <= -3.6e-88) tmp = t_1; elseif (y <= 2.3e-128) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 2.5e+101) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 2e+123) tmp = Float64(Float64(-b) / Float64(Float64(t + Float64(x + y)) / y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; tmp = 0.0; if (y <= -7.8e+124) tmp = t_1; elseif (y <= -1.5e+111) tmp = a / ((x + y) / y); elseif (y <= -3.6e-88) tmp = t_1; elseif (y <= 2.3e-128) tmp = a + (x / ((x + t) / z)); elseif (y <= 2.5e+101) tmp = z + ((y * a) / (x + y)); elseif (y <= 2e+123) tmp = -b / ((t + (x + y)) / y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -7.8e+124], t$95$1, If[LessEqual[y, -1.5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -3.6e-88], t$95$1, If[LessEqual[y, 2.3e-128], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e+101], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2e+123], N[((-b) / N[(N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -7.8 \cdot 10^{+124}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -1.5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -3.6 \cdot 10^{-88}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.3 \cdot 10^{-128}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+101}:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+123}:\\
\;\;\;\;\frac{-b}{\frac{t + \left(x + y\right)}{y}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -7.8000000000000001e124 or -1.5e111 < y < -3.5999999999999999e-88 or 1.99999999999999996e123 < y Initial program 49.8%
Taylor expanded in y around inf 74.9%
if -7.8000000000000001e124 < y < -1.5e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -3.5999999999999999e-88 < y < 2.3000000000000001e-128Initial program 80.2%
Taylor expanded in a around 0 89.3%
associate--l+89.3%
+-commutative89.3%
+-commutative89.3%
+-commutative89.3%
div-sub89.3%
+-commutative89.3%
*-commutative89.3%
+-commutative89.3%
Simplified89.3%
Taylor expanded in y around 0 74.8%
associate-/l*78.1%
Simplified78.1%
Taylor expanded in y around inf 63.9%
if 2.3000000000000001e-128 < y < 2.49999999999999994e101Initial program 65.8%
Taylor expanded in a around 0 81.3%
associate--l+81.3%
+-commutative81.3%
+-commutative81.3%
+-commutative81.3%
div-sub81.3%
+-commutative81.3%
*-commutative81.3%
+-commutative81.3%
Simplified81.3%
Taylor expanded in y around 0 68.9%
associate-/l*81.0%
Simplified81.0%
Taylor expanded in t around 0 64.5%
if 2.49999999999999994e101 < y < 1.99999999999999996e123Initial program 58.5%
Taylor expanded in b around inf 38.5%
mul-1-neg38.5%
associate-/l*65.5%
distribute-neg-frac65.5%
+-commutative65.5%
Simplified65.5%
Final simplification69.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)) (t_2 (+ a (/ x (/ (+ x t) z)))))
(if (<= y -4.2e+123)
t_1
(if (<= y -5e+111)
(/ a (/ (+ x y) y))
(if (<= y -6.5e-79)
t_1
(if (<= y 2.9e-127)
t_2
(if (<= y 0.0028)
(+ z (/ (* y a) (+ x y)))
(if (<= y 4.4e+101) t_2 t_1))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double t_2 = a + (x / ((x + t) / z));
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 2.9e-127) {
tmp = t_2;
} else if (y <= 0.0028) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 4.4e+101) {
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 = (z + a) - b
t_2 = a + (x / ((x + t) / z))
if (y <= (-4.2d+123)) then
tmp = t_1
else if (y <= (-5d+111)) then
tmp = a / ((x + y) / y)
else if (y <= (-6.5d-79)) then
tmp = t_1
else if (y <= 2.9d-127) then
tmp = t_2
else if (y <= 0.0028d0) then
tmp = z + ((y * a) / (x + y))
else if (y <= 4.4d+101) 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 = (z + a) - b;
double t_2 = a + (x / ((x + t) / z));
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -6.5e-79) {
tmp = t_1;
} else if (y <= 2.9e-127) {
tmp = t_2;
} else if (y <= 0.0028) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 4.4e+101) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b t_2 = a + (x / ((x + t) / z)) tmp = 0 if y <= -4.2e+123: tmp = t_1 elif y <= -5e+111: tmp = a / ((x + y) / y) elif y <= -6.5e-79: tmp = t_1 elif y <= 2.9e-127: tmp = t_2 elif y <= 0.0028: tmp = z + ((y * a) / (x + y)) elif y <= 4.4e+101: tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) t_2 = Float64(a + Float64(x / Float64(Float64(x + t) / z))) tmp = 0.0 if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 2.9e-127) tmp = t_2; elseif (y <= 0.0028) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 4.4e+101) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; t_2 = a + (x / ((x + t) / z)); tmp = 0.0; if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = a / ((x + y) / y); elseif (y <= -6.5e-79) tmp = t_1; elseif (y <= 2.9e-127) tmp = t_2; elseif (y <= 0.0028) tmp = z + ((y * a) / (x + y)); elseif (y <= 4.4e+101) 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[(z + a), $MachinePrecision] - b), $MachinePrecision]}, Block[{t$95$2 = N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.2e+123], t$95$1, If[LessEqual[y, -5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.5e-79], t$95$1, If[LessEqual[y, 2.9e-127], t$95$2, If[LessEqual[y, 0.0028], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.4e+101], t$95$2, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
t_2 := a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -6.5 \cdot 10^{-79}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.9 \cdot 10^{-127}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 0.0028:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 4.4 \cdot 10^{+101}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.19999999999999988e123 or -4.9999999999999997e111 < y < -6.5000000000000003e-79 or 4.4000000000000001e101 < y Initial program 51.1%
Taylor expanded in y around inf 73.6%
if -4.19999999999999988e123 < y < -4.9999999999999997e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -6.5000000000000003e-79 < y < 2.9e-127 or 0.00279999999999999997 < y < 4.4000000000000001e101Initial program 74.6%
Taylor expanded in a around 0 86.5%
associate--l+86.5%
+-commutative86.5%
+-commutative86.5%
+-commutative86.5%
div-sub86.5%
+-commutative86.5%
*-commutative86.5%
+-commutative86.5%
Simplified86.5%
Taylor expanded in y around 0 74.6%
associate-/l*79.1%
Simplified79.1%
Taylor expanded in y around inf 62.9%
if 2.9e-127 < y < 0.00279999999999999997Initial program 74.6%
Taylor expanded in a around 0 80.4%
associate--l+80.4%
+-commutative80.4%
+-commutative80.4%
+-commutative80.4%
div-sub80.4%
+-commutative80.4%
*-commutative80.4%
+-commutative80.4%
Simplified80.4%
Taylor expanded in y around 0 63.4%
associate-/l*76.2%
Simplified76.2%
Taylor expanded in t around 0 69.3%
Final simplification69.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)))
(if (<= y -4.2e+123)
t_1
(if (<= y -5e+111)
(/ a (/ (+ x y) y))
(if (<= y -5.5e-86)
t_1
(if (<= y 4.5e-127)
(+ a (/ x (/ (+ x t) z)))
(if (<= y 2.4e+95)
(+ z (/ (* y a) (+ x y)))
(if (<= y 1.22e+124) (/ y (/ (+ x y) (- a b))) t_1))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -5.5e-86) {
tmp = t_1;
} else if (y <= 4.5e-127) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.4e+95) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 1.22e+124) {
tmp = y / ((x + y) / (a - 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 = (z + a) - b
if (y <= (-4.2d+123)) then
tmp = t_1
else if (y <= (-5d+111)) then
tmp = a / ((x + y) / y)
else if (y <= (-5.5d-86)) then
tmp = t_1
else if (y <= 4.5d-127) then
tmp = a + (x / ((x + t) / z))
else if (y <= 2.4d+95) then
tmp = z + ((y * a) / (x + y))
else if (y <= 1.22d+124) then
tmp = y / ((x + y) / (a - 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 = (z + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if (y <= -5.5e-86) {
tmp = t_1;
} else if (y <= 4.5e-127) {
tmp = a + (x / ((x + t) / z));
} else if (y <= 2.4e+95) {
tmp = z + ((y * a) / (x + y));
} else if (y <= 1.22e+124) {
tmp = y / ((x + y) / (a - b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b tmp = 0 if y <= -4.2e+123: tmp = t_1 elif y <= -5e+111: tmp = a / ((x + y) / y) elif y <= -5.5e-86: tmp = t_1 elif y <= 4.5e-127: tmp = a + (x / ((x + t) / z)) elif y <= 2.4e+95: tmp = z + ((y * a) / (x + y)) elif y <= 1.22e+124: tmp = y / ((x + y) / (a - b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif (y <= -5.5e-86) tmp = t_1; elseif (y <= 4.5e-127) tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); elseif (y <= 2.4e+95) tmp = Float64(z + Float64(Float64(y * a) / Float64(x + y))); elseif (y <= 1.22e+124) tmp = Float64(y / Float64(Float64(x + y) / Float64(a - b))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; tmp = 0.0; if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = a / ((x + y) / y); elseif (y <= -5.5e-86) tmp = t_1; elseif (y <= 4.5e-127) tmp = a + (x / ((x + t) / z)); elseif (y <= 2.4e+95) tmp = z + ((y * a) / (x + y)); elseif (y <= 1.22e+124) tmp = y / ((x + y) / (a - b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -4.2e+123], t$95$1, If[LessEqual[y, -5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -5.5e-86], t$95$1, If[LessEqual[y, 4.5e-127], N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.4e+95], N[(z + N[(N[(y * a), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.22e+124], N[(y / N[(N[(x + y), $MachinePrecision] / N[(a - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -5.5 \cdot 10^{-86}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{-127}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\mathbf{elif}\;y \leq 2.4 \cdot 10^{+95}:\\
\;\;\;\;z + \frac{y \cdot a}{x + y}\\
\mathbf{elif}\;y \leq 1.22 \cdot 10^{+124}:\\
\;\;\;\;\frac{y}{\frac{x + y}{a - b}}\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if y < -4.19999999999999988e123 or -4.9999999999999997e111 < y < -5.5e-86 or 1.22e124 < y Initial program 49.8%
Taylor expanded in y around inf 74.9%
if -4.19999999999999988e123 < y < -4.9999999999999997e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -5.5e-86 < y < 4.4999999999999999e-127Initial program 80.2%
Taylor expanded in a around 0 89.3%
associate--l+89.3%
+-commutative89.3%
+-commutative89.3%
+-commutative89.3%
div-sub89.3%
+-commutative89.3%
*-commutative89.3%
+-commutative89.3%
Simplified89.3%
Taylor expanded in y around 0 74.8%
associate-/l*78.1%
Simplified78.1%
Taylor expanded in y around inf 63.9%
if 4.4999999999999999e-127 < y < 2.4e95Initial program 65.8%
Taylor expanded in a around 0 81.3%
associate--l+81.3%
+-commutative81.3%
+-commutative81.3%
+-commutative81.3%
div-sub81.3%
+-commutative81.3%
*-commutative81.3%
+-commutative81.3%
Simplified81.3%
Taylor expanded in y around 0 68.9%
associate-/l*81.0%
Simplified81.0%
Taylor expanded in t around 0 64.5%
if 2.4e95 < y < 1.22e124Initial program 58.5%
Taylor expanded in y around inf 45.6%
Taylor expanded in z around 0 45.4%
associate-/l*72.6%
+-commutative72.6%
+-commutative72.6%
associate-+l+72.6%
+-commutative72.6%
Simplified72.6%
Taylor expanded in t around 0 45.5%
associate-/l*59.6%
Simplified59.6%
Final simplification69.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)))
(if (<= y -4.2e+123)
t_1
(if (<= y -5e+111)
(/ a (/ (+ x y) y))
(if (or (<= y -1.2e-87) (not (<= y 4.4e+101)))
t_1
(+ a (/ x (/ (+ x t) z))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if ((y <= -1.2e-87) || !(y <= 4.4e+101)) {
tmp = t_1;
} else {
tmp = a + (x / ((x + t) / z));
}
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 + a) - b
if (y <= (-4.2d+123)) then
tmp = t_1
else if (y <= (-5d+111)) then
tmp = a / ((x + y) / y)
else if ((y <= (-1.2d-87)) .or. (.not. (y <= 4.4d+101))) then
tmp = t_1
else
tmp = a + (x / ((x + t) / z))
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 + a) - b;
double tmp;
if (y <= -4.2e+123) {
tmp = t_1;
} else if (y <= -5e+111) {
tmp = a / ((x + y) / y);
} else if ((y <= -1.2e-87) || !(y <= 4.4e+101)) {
tmp = t_1;
} else {
tmp = a + (x / ((x + t) / z));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b tmp = 0 if y <= -4.2e+123: tmp = t_1 elif y <= -5e+111: tmp = a / ((x + y) / y) elif (y <= -1.2e-87) or not (y <= 4.4e+101): tmp = t_1 else: tmp = a + (x / ((x + t) / z)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) tmp = 0.0 if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = Float64(a / Float64(Float64(x + y) / y)); elseif ((y <= -1.2e-87) || !(y <= 4.4e+101)) tmp = t_1; else tmp = Float64(a + Float64(x / Float64(Float64(x + t) / z))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; tmp = 0.0; if (y <= -4.2e+123) tmp = t_1; elseif (y <= -5e+111) tmp = a / ((x + y) / y); elseif ((y <= -1.2e-87) || ~((y <= 4.4e+101))) tmp = t_1; else tmp = a + (x / ((x + t) / z)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -4.2e+123], t$95$1, If[LessEqual[y, -5e+111], N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y, -1.2e-87], N[Not[LessEqual[y, 4.4e+101]], $MachinePrecision]], t$95$1, N[(a + N[(x / N[(N[(x + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+123}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -5 \cdot 10^{+111}:\\
\;\;\;\;\frac{a}{\frac{x + y}{y}}\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{-87} \lor \neg \left(y \leq 4.4 \cdot 10^{+101}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;a + \frac{x}{\frac{x + t}{z}}\\
\end{array}
\end{array}
if y < -4.19999999999999988e123 or -4.9999999999999997e111 < y < -1.2e-87 or 4.4000000000000001e101 < y Initial program 51.1%
Taylor expanded in y around inf 73.6%
if -4.19999999999999988e123 < y < -4.9999999999999997e111Initial program 61.9%
Taylor expanded in a around inf 61.9%
associate-/l*99.7%
+-commutative99.7%
Simplified99.7%
Taylor expanded in t around 0 99.7%
+-commutative99.7%
Simplified99.7%
if -1.2e-87 < y < 4.4000000000000001e101Initial program 74.6%
Taylor expanded in a around 0 85.4%
associate--l+85.4%
+-commutative85.4%
+-commutative85.4%
+-commutative85.4%
div-sub85.4%
+-commutative85.4%
*-commutative85.4%
+-commutative85.4%
Simplified85.4%
Taylor expanded in y around 0 72.6%
associate-/l*78.6%
Simplified78.6%
Taylor expanded in y around inf 60.1%
Final simplification67.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z a) b)) (t_2 (/ a (+ 1.0 (/ x t)))))
(if (<= t -1.3e+196)
t_2
(if (<= t -1.8e-238)
t_1
(if (<= t -8.8e-277)
(- z (/ (* y b) x))
(if (<= t 8.8e+104) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double t_2 = a / (1.0 + (x / t));
double tmp;
if (t <= -1.3e+196) {
tmp = t_2;
} else if (t <= -1.8e-238) {
tmp = t_1;
} else if (t <= -8.8e-277) {
tmp = z - ((y * b) / x);
} else if (t <= 8.8e+104) {
tmp = t_1;
} 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 = (z + a) - b
t_2 = a / (1.0d0 + (x / t))
if (t <= (-1.3d+196)) then
tmp = t_2
else if (t <= (-1.8d-238)) then
tmp = t_1
else if (t <= (-8.8d-277)) then
tmp = z - ((y * b) / x)
else if (t <= 8.8d+104) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + a) - b;
double t_2 = a / (1.0 + (x / t));
double tmp;
if (t <= -1.3e+196) {
tmp = t_2;
} else if (t <= -1.8e-238) {
tmp = t_1;
} else if (t <= -8.8e-277) {
tmp = z - ((y * b) / x);
} else if (t <= 8.8e+104) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + a) - b t_2 = a / (1.0 + (x / t)) tmp = 0 if t <= -1.3e+196: tmp = t_2 elif t <= -1.8e-238: tmp = t_1 elif t <= -8.8e-277: tmp = z - ((y * b) / x) elif t <= 8.8e+104: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + a) - b) t_2 = Float64(a / Float64(1.0 + Float64(x / t))) tmp = 0.0 if (t <= -1.3e+196) tmp = t_2; elseif (t <= -1.8e-238) tmp = t_1; elseif (t <= -8.8e-277) tmp = Float64(z - Float64(Float64(y * b) / x)); elseif (t <= 8.8e+104) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + a) - b; t_2 = a / (1.0 + (x / t)); tmp = 0.0; if (t <= -1.3e+196) tmp = t_2; elseif (t <= -1.8e-238) tmp = t_1; elseif (t <= -8.8e-277) tmp = z - ((y * b) / x); elseif (t <= 8.8e+104) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]}, Block[{t$95$2 = N[(a / N[(1.0 + N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.3e+196], t$95$2, If[LessEqual[t, -1.8e-238], t$95$1, If[LessEqual[t, -8.8e-277], N[(z - N[(N[(y * b), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.8e+104], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + a\right) - b\\
t_2 := \frac{a}{1 + \frac{x}{t}}\\
\mathbf{if}\;t \leq -1.3 \cdot 10^{+196}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-238}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -8.8 \cdot 10^{-277}:\\
\;\;\;\;z - \frac{y \cdot b}{x}\\
\mathbf{elif}\;t \leq 8.8 \cdot 10^{+104}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.30000000000000006e196 or 8.80000000000000002e104 < t Initial program 57.1%
Taylor expanded in a around inf 35.9%
associate-/l*65.6%
+-commutative65.6%
Simplified65.6%
Taylor expanded in t around inf 64.6%
if -1.30000000000000006e196 < t < -1.80000000000000005e-238 or -8.79999999999999983e-277 < t < 8.80000000000000002e104Initial program 63.2%
Taylor expanded in y around inf 65.4%
if -1.80000000000000005e-238 < t < -8.79999999999999983e-277Initial program 99.8%
Taylor expanded in x around inf 99.8%
associate--r+99.8%
sub-neg99.8%
mul-1-neg99.8%
associate-+r+99.8%
+-commutative99.8%
associate--l+99.8%
Simplified99.6%
Taylor expanded in b around inf 84.7%
associate-*r/84.7%
mul-1-neg84.7%
*-commutative84.7%
distribute-lft-neg-in84.7%
neg-mul-184.7%
*-commutative84.7%
neg-mul-184.7%
Simplified84.7%
Final simplification65.7%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -1.82e+196) (not (<= t 1.9e+102))) (/ a (+ 1.0 (/ x t))) (- (+ z a) b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -1.82e+196) || !(t <= 1.9e+102)) {
tmp = a / (1.0 + (x / t));
} else {
tmp = (z + a) - 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.82d+196)) .or. (.not. (t <= 1.9d+102))) then
tmp = a / (1.0d0 + (x / t))
else
tmp = (z + a) - 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.82e+196) || !(t <= 1.9e+102)) {
tmp = a / (1.0 + (x / t));
} else {
tmp = (z + a) - b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -1.82e+196) or not (t <= 1.9e+102): tmp = a / (1.0 + (x / t)) else: tmp = (z + a) - b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -1.82e+196) || !(t <= 1.9e+102)) tmp = Float64(a / Float64(1.0 + Float64(x / t))); else tmp = Float64(Float64(z + a) - b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((t <= -1.82e+196) || ~((t <= 1.9e+102))) tmp = a / (1.0 + (x / t)); else tmp = (z + a) - b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -1.82e+196], N[Not[LessEqual[t, 1.9e+102]], $MachinePrecision]], N[(a / N[(1.0 + N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.82 \cdot 10^{+196} \lor \neg \left(t \leq 1.9 \cdot 10^{+102}\right):\\
\;\;\;\;\frac{a}{1 + \frac{x}{t}}\\
\mathbf{else}:\\
\;\;\;\;\left(z + a\right) - b\\
\end{array}
\end{array}
if t < -1.82e196 or 1.89999999999999989e102 < t Initial program 57.1%
Taylor expanded in a around inf 35.9%
associate-/l*65.6%
+-commutative65.6%
Simplified65.6%
Taylor expanded in t around inf 64.6%
if -1.82e196 < t < 1.89999999999999989e102Initial program 64.5%
Taylor expanded in y around inf 63.3%
Final simplification63.6%
(FPCore (x y z t a b) :precision binary64 (if (<= t 4.2e+99) (- (+ z a) b) a))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= 4.2e+99) {
tmp = (z + a) - b;
} 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.2d+99) then
tmp = (z + a) - b
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.2e+99) {
tmp = (z + a) - b;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= 4.2e+99: tmp = (z + a) - b else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= 4.2e+99) tmp = Float64(Float64(z + a) - b); else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= 4.2e+99) tmp = (z + a) - b; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, 4.2e+99], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], a]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq 4.2 \cdot 10^{+99}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if t < 4.2000000000000002e99Initial program 63.2%
Taylor expanded in y around inf 61.2%
if 4.2000000000000002e99 < t Initial program 60.4%
Taylor expanded in t around inf 47.0%
Final simplification58.9%
(FPCore (x y z t a b) :precision binary64 (if (<= t -2.05e-16) a (if (<= t 1.25e-96) z a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.05e-16) {
tmp = a;
} else if (t <= 1.25e-96) {
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 <= (-2.05d-16)) then
tmp = a
else if (t <= 1.25d-96) 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 <= -2.05e-16) {
tmp = a;
} else if (t <= 1.25e-96) {
tmp = z;
} else {
tmp = a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -2.05e-16: tmp = a elif t <= 1.25e-96: tmp = z else: tmp = a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -2.05e-16) tmp = a; elseif (t <= 1.25e-96) tmp = z; else tmp = a; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -2.05e-16) tmp = a; elseif (t <= 1.25e-96) tmp = z; else tmp = a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.05e-16], a, If[LessEqual[t, 1.25e-96], z, a]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.05 \cdot 10^{-16}:\\
\;\;\;\;a\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-96}:\\
\;\;\;\;z\\
\mathbf{else}:\\
\;\;\;\;a\\
\end{array}
\end{array}
if t < -2.05000000000000003e-16 or 1.24999999999999999e-96 < t Initial program 62.3%
Taylor expanded in t around inf 43.1%
if -2.05000000000000003e-16 < t < 1.24999999999999999e-96Initial program 63.3%
Taylor expanded in x around inf 47.9%
Final simplification45.1%
(FPCore (x y z t a b) :precision binary64 (if (<= b -9.5e+153) (- b) (+ z a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.5e+153) {
tmp = -b;
} else {
tmp = z + 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 (b <= (-9.5d+153)) then
tmp = -b
else
tmp = z + 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 (b <= -9.5e+153) {
tmp = -b;
} else {
tmp = z + a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -9.5e+153: tmp = -b else: tmp = z + a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.5e+153) tmp = Float64(-b); else tmp = Float64(z + a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -9.5e+153) tmp = -b; else tmp = z + a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.5e+153], (-b), N[(z + a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{+153}:\\
\;\;\;\;-b\\
\mathbf{else}:\\
\;\;\;\;z + a\\
\end{array}
\end{array}
if b < -9.4999999999999995e153Initial program 49.0%
Taylor expanded in y around inf 51.7%
Taylor expanded in b around inf 36.1%
neg-mul-136.1%
Simplified36.1%
if -9.4999999999999995e153 < b Initial program 64.9%
Taylor expanded in y around inf 55.2%
Taylor expanded in b around 0 52.0%
+-commutative52.0%
Simplified52.0%
Final simplification49.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -7e+152) (- a b) (+ z a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -7e+152) {
tmp = a - b;
} else {
tmp = z + 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 (b <= (-7d+152)) then
tmp = a - b
else
tmp = z + 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 (b <= -7e+152) {
tmp = a - b;
} else {
tmp = z + a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -7e+152: tmp = a - b else: tmp = z + a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -7e+152) tmp = Float64(a - b); else tmp = Float64(z + a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -7e+152) tmp = a - b; else tmp = z + a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -7e+152], N[(a - b), $MachinePrecision], N[(z + a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7 \cdot 10^{+152}:\\
\;\;\;\;a - b\\
\mathbf{else}:\\
\;\;\;\;z + a\\
\end{array}
\end{array}
if b < -6.99999999999999963e152Initial program 49.0%
Taylor expanded in y around inf 51.7%
Taylor expanded in z around 0 46.2%
if -6.99999999999999963e152 < b Initial program 64.9%
Taylor expanded in y around inf 55.2%
Taylor expanded in b around 0 52.0%
+-commutative52.0%
Simplified52.0%
Final simplification51.2%
(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 62.8%
Taylor expanded in t around inf 31.5%
Final simplification31.5%
(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 2023310
(FPCore (x y z t a b)
:name "AI.Clustering.Hierarchical.Internal:ward from clustering-0.2.1"
:precision binary64
:herbie-target
(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)))