
(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 23 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 (+ y (+ x t)))
(t_2 (* z (+ x y)))
(t_3 (/ (- (+ t_2 (* (+ y t) a)) (* y b)) t_1))
(t_4 (/ y t_1)))
(if (<= t_3 -5e+278)
(+ a (* z (+ (/ x t_1) t_4)))
(if (<= t_3 2e+201)
(+ (* a (+ t_4 (/ t t_1))) (/ (- t_2 (* y b)) t_1))
(- (+ z (/ a (/ (+ x y) y))) (/ b (+ (/ x y) 1.0)))))))
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);
double t_3 = ((t_2 + ((y + t) * a)) - (y * b)) / t_1;
double t_4 = y / t_1;
double tmp;
if (t_3 <= -5e+278) {
tmp = a + (z * ((x / t_1) + t_4));
} else if (t_3 <= 2e+201) {
tmp = (a * (t_4 + (t / t_1))) + ((t_2 - (y * b)) / t_1);
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = y + (x + t)
t_2 = z * (x + y)
t_3 = ((t_2 + ((y + t) * a)) - (y * b)) / t_1
t_4 = y / t_1
if (t_3 <= (-5d+278)) then
tmp = a + (z * ((x / t_1) + t_4))
else if (t_3 <= 2d+201) then
tmp = (a * (t_4 + (t / t_1))) + ((t_2 - (y * b)) / t_1)
else
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = z * (x + y);
double t_3 = ((t_2 + ((y + t) * a)) - (y * b)) / t_1;
double t_4 = y / t_1;
double tmp;
if (t_3 <= -5e+278) {
tmp = a + (z * ((x / t_1) + t_4));
} else if (t_3 <= 2e+201) {
tmp = (a * (t_4 + (t / t_1))) + ((t_2 - (y * b)) / t_1);
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = z * (x + y) t_3 = ((t_2 + ((y + t) * a)) - (y * b)) / t_1 t_4 = y / t_1 tmp = 0 if t_3 <= -5e+278: tmp = a + (z * ((x / t_1) + t_4)) elif t_3 <= 2e+201: tmp = (a * (t_4 + (t / t_1))) + ((t_2 - (y * b)) / t_1) else: tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(z * Float64(x + y)) t_3 = Float64(Float64(Float64(t_2 + Float64(Float64(y + t) * a)) - Float64(y * b)) / t_1) t_4 = Float64(y / t_1) tmp = 0.0 if (t_3 <= -5e+278) tmp = Float64(a + Float64(z * Float64(Float64(x / t_1) + t_4))); elseif (t_3 <= 2e+201) tmp = Float64(Float64(a * Float64(t_4 + Float64(t / t_1))) + Float64(Float64(t_2 - Float64(y * b)) / t_1)); else tmp = Float64(Float64(z + Float64(a / Float64(Float64(x + y) / y))) - Float64(b / Float64(Float64(x / y) + 1.0))); 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_3 = ((t_2 + ((y + t) * a)) - (y * b)) / t_1; t_4 = y / t_1; tmp = 0.0; if (t_3 <= -5e+278) tmp = a + (z * ((x / t_1) + t_4)); elseif (t_3 <= 2e+201) tmp = (a * (t_4 + (t / t_1))) + ((t_2 - (y * b)) / t_1); else tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)); 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[(x + y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(t$95$2 + N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$4 = N[(y / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+278], N[(a + N[(z * N[(N[(x / t$95$1), $MachinePrecision] + t$95$4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2e+201], N[(N[(a * N[(t$95$4 + N[(t / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(t$95$2 - N[(y * b), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b / N[(N[(x / y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := z \cdot \left(x + y\right)\\
t_3 := \frac{\left(t_2 + \left(y + t\right) \cdot a\right) - y \cdot b}{t_1}\\
t_4 := \frac{y}{t_1}\\
\mathbf{if}\;t_3 \leq -5 \cdot 10^{+278}:\\
\;\;\;\;a + z \cdot \left(\frac{x}{t_1} + t_4\right)\\
\mathbf{elif}\;t_3 \leq 2 \cdot 10^{+201}:\\
\;\;\;\;a \cdot \left(t_4 + \frac{t}{t_1}\right) + \frac{t_2 - y \cdot b}{t_1}\\
\mathbf{else}:\\
\;\;\;\;\left(z + \frac{a}{\frac{x + y}{y}}\right) - \frac{b}{\frac{x}{y} + 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)) < -5.00000000000000029e278Initial program 8.8%
Taylor expanded in z around 0 52.4%
associate--l+52.4%
associate-+r+52.4%
associate-+r+52.4%
div-sub52.4%
*-commutative52.4%
associate-+r+52.4%
Simplified52.4%
Taylor expanded in t around inf 80.9%
if -5.00000000000000029e278 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 2.00000000000000008e201Initial program 99.7%
Taylor expanded in a around 0 99.8%
associate--l+99.8%
+-commutative99.8%
associate-+r+99.8%
associate-+r+99.8%
div-sub99.8%
+-commutative99.8%
*-commutative99.8%
associate-+r+99.8%
Simplified99.8%
if 2.00000000000000008e201 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 15.0%
Taylor expanded in z around 0 33.4%
associate--l+33.4%
associate-+r+33.4%
associate-+r+33.4%
div-sub33.4%
*-commutative33.4%
associate-+r+33.4%
Simplified33.4%
Taylor expanded in x around inf 30.2%
Taylor expanded in t around 0 31.9%
associate-/l*46.6%
+-commutative46.6%
associate-/l*74.6%
+-commutative74.6%
Simplified74.6%
Taylor expanded in y around 0 74.6%
+-commutative74.6%
Simplified74.6%
Final simplification88.4%
(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 -5e+278)
(+ a (* z (+ (/ x t_1) (/ y t_1))))
(if (<= t_2 2e+201)
t_2
(- (+ z (/ a (/ (+ x y) y))) (/ b (+ (/ x y) 1.0)))))))
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 <= -5e+278) {
tmp = a + (z * ((x / t_1) + (y / t_1)));
} else if (t_2 <= 2e+201) {
tmp = t_2;
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y + (x + t)
t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1
if (t_2 <= (-5d+278)) then
tmp = a + (z * ((x / t_1) + (y / t_1)))
else if (t_2 <= 2d+201) then
tmp = t_2
else
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = (((z * (x + y)) + ((y + t) * a)) - (y * b)) / t_1;
double tmp;
if (t_2 <= -5e+278) {
tmp = a + (z * ((x / t_1) + (y / t_1)));
} else if (t_2 <= 2e+201) {
tmp = t_2;
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
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 <= -5e+278: tmp = a + (z * ((x / t_1) + (y / t_1))) elif t_2 <= 2e+201: tmp = t_2 else: tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)) 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 <= -5e+278) tmp = Float64(a + Float64(z * Float64(Float64(x / t_1) + Float64(y / t_1)))); elseif (t_2 <= 2e+201) tmp = t_2; else tmp = Float64(Float64(z + Float64(a / Float64(Float64(x + y) / y))) - Float64(b / Float64(Float64(x / y) + 1.0))); 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 <= -5e+278) tmp = a + (z * ((x / t_1) + (y / t_1))); elseif (t_2 <= 2e+201) tmp = t_2; else tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)); 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, -5e+278], N[(a + N[(z * N[(N[(x / t$95$1), $MachinePrecision] + N[(y / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+201], t$95$2, N[(N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b / N[(N[(x / y), $MachinePrecision] + 1.0), $MachinePrecision]), $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 -5 \cdot 10^{+278}:\\
\;\;\;\;a + z \cdot \left(\frac{x}{t_1} + \frac{y}{t_1}\right)\\
\mathbf{elif}\;t_2 \leq 2 \cdot 10^{+201}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\left(z + \frac{a}{\frac{x + y}{y}}\right) - \frac{b}{\frac{x}{y} + 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)) < -5.00000000000000029e278Initial program 8.8%
Taylor expanded in z around 0 52.4%
associate--l+52.4%
associate-+r+52.4%
associate-+r+52.4%
div-sub52.4%
*-commutative52.4%
associate-+r+52.4%
Simplified52.4%
Taylor expanded in t around inf 80.9%
if -5.00000000000000029e278 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) < 2.00000000000000008e201Initial program 99.7%
if 2.00000000000000008e201 < (/.f64 (-.f64 (+.f64 (*.f64 (+.f64 x y) z) (*.f64 (+.f64 t y) a)) (*.f64 y b)) (+.f64 (+.f64 x t) y)) Initial program 15.0%
Taylor expanded in z around 0 33.4%
associate--l+33.4%
associate-+r+33.4%
associate-+r+33.4%
div-sub33.4%
*-commutative33.4%
associate-+r+33.4%
Simplified33.4%
Taylor expanded in x around inf 30.2%
Taylor expanded in t around 0 31.9%
associate-/l*46.6%
+-commutative46.6%
associate-/l*74.6%
+-commutative74.6%
Simplified74.6%
Taylor expanded in y around 0 74.6%
+-commutative74.6%
Simplified74.6%
Final simplification88.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ z (/ (* y (- a b)) (+ x y))))
(t_2 (- (+ z a) (/ (* y b) (+ y t)))))
(if (<= t -7e+166)
(+ a (* z (/ (+ x y) t)))
(if (<= t -9e+118)
(* (+ y t) (/ a (+ t (+ x y))))
(if (<= t -5e-23)
t_2
(if (<= t -2.5e-106)
(- z (/ b (/ (+ x y) y)))
(if (<= t 1.4e-266)
t_1
(if (<= t 7.5e-105)
(- (+ z a) b)
(if (<= t 2.2e+31)
t_1
(if (<= t 7.5e+150) t_2 (+ a (/ z (/ t (+ x y))))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z + ((y * (a - b)) / (x + y));
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -7e+166) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -9e+118) {
tmp = (y + t) * (a / (t + (x + y)));
} else if (t <= -5e-23) {
tmp = t_2;
} else if (t <= -2.5e-106) {
tmp = z - (b / ((x + y) / y));
} else if (t <= 1.4e-266) {
tmp = t_1;
} else if (t <= 7.5e-105) {
tmp = (z + a) - b;
} else if (t <= 2.2e+31) {
tmp = t_1;
} else if (t <= 7.5e+150) {
tmp = t_2;
} else {
tmp = a + (z / (t / (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 = z + ((y * (a - b)) / (x + y))
t_2 = (z + a) - ((y * b) / (y + t))
if (t <= (-7d+166)) then
tmp = a + (z * ((x + y) / t))
else if (t <= (-9d+118)) then
tmp = (y + t) * (a / (t + (x + y)))
else if (t <= (-5d-23)) then
tmp = t_2
else if (t <= (-2.5d-106)) then
tmp = z - (b / ((x + y) / y))
else if (t <= 1.4d-266) then
tmp = t_1
else if (t <= 7.5d-105) then
tmp = (z + a) - b
else if (t <= 2.2d+31) then
tmp = t_1
else if (t <= 7.5d+150) then
tmp = t_2
else
tmp = a + (z / (t / (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 = z + ((y * (a - b)) / (x + y));
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -7e+166) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -9e+118) {
tmp = (y + t) * (a / (t + (x + y)));
} else if (t <= -5e-23) {
tmp = t_2;
} else if (t <= -2.5e-106) {
tmp = z - (b / ((x + y) / y));
} else if (t <= 1.4e-266) {
tmp = t_1;
} else if (t <= 7.5e-105) {
tmp = (z + a) - b;
} else if (t <= 2.2e+31) {
tmp = t_1;
} else if (t <= 7.5e+150) {
tmp = t_2;
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z + ((y * (a - b)) / (x + y)) t_2 = (z + a) - ((y * b) / (y + t)) tmp = 0 if t <= -7e+166: tmp = a + (z * ((x + y) / t)) elif t <= -9e+118: tmp = (y + t) * (a / (t + (x + y))) elif t <= -5e-23: tmp = t_2 elif t <= -2.5e-106: tmp = z - (b / ((x + y) / y)) elif t <= 1.4e-266: tmp = t_1 elif t <= 7.5e-105: tmp = (z + a) - b elif t <= 2.2e+31: tmp = t_1 elif t <= 7.5e+150: tmp = t_2 else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z + Float64(Float64(y * Float64(a - b)) / Float64(x + y))) t_2 = Float64(Float64(z + a) - Float64(Float64(y * b) / Float64(y + t))) tmp = 0.0 if (t <= -7e+166) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= -9e+118) tmp = Float64(Float64(y + t) * Float64(a / Float64(t + Float64(x + y)))); elseif (t <= -5e-23) tmp = t_2; elseif (t <= -2.5e-106) tmp = Float64(z - Float64(b / Float64(Float64(x + y) / y))); elseif (t <= 1.4e-266) tmp = t_1; elseif (t <= 7.5e-105) tmp = Float64(Float64(z + a) - b); elseif (t <= 2.2e+31) tmp = t_1; elseif (t <= 7.5e+150) tmp = t_2; else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z + ((y * (a - b)) / (x + y)); t_2 = (z + a) - ((y * b) / (y + t)); tmp = 0.0; if (t <= -7e+166) tmp = a + (z * ((x + y) / t)); elseif (t <= -9e+118) tmp = (y + t) * (a / (t + (x + y))); elseif (t <= -5e-23) tmp = t_2; elseif (t <= -2.5e-106) tmp = z - (b / ((x + y) / y)); elseif (t <= 1.4e-266) tmp = t_1; elseif (t <= 7.5e-105) tmp = (z + a) - b; elseif (t <= 2.2e+31) tmp = t_1; elseif (t <= 7.5e+150) tmp = t_2; else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z + N[(N[(y * N[(a - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + a), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7e+166], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9e+118], N[(N[(y + t), $MachinePrecision] * N[(a / N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5e-23], t$95$2, If[LessEqual[t, -2.5e-106], N[(z - N[(b / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.4e-266], t$95$1, If[LessEqual[t, 7.5e-105], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[t, 2.2e+31], t$95$1, If[LessEqual[t, 7.5e+150], t$95$2, N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z + \frac{y \cdot \left(a - b\right)}{x + y}\\
t_2 := \left(z + a\right) - \frac{y \cdot b}{y + t}\\
\mathbf{if}\;t \leq -7 \cdot 10^{+166}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq -9 \cdot 10^{+118}:\\
\;\;\;\;\left(y + t\right) \cdot \frac{a}{t + \left(x + y\right)}\\
\mathbf{elif}\;t \leq -5 \cdot 10^{-23}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{-106}:\\
\;\;\;\;z - \frac{b}{\frac{x + y}{y}}\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{-266}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{-105}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{elif}\;t \leq 2.2 \cdot 10^{+31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 7.5 \cdot 10^{+150}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -6.9999999999999997e166Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 70.1%
+-commutative70.1%
Simplified70.1%
if -6.9999999999999997e166 < t < -9.00000000000000004e118Initial program 41.0%
Taylor expanded in a around inf 40.8%
associate-/l*87.7%
associate-+r+87.7%
Simplified87.7%
associate-/r/86.8%
associate-+l+86.8%
+-commutative86.8%
Applied egg-rr86.8%
if -9.00000000000000004e118 < t < -5.0000000000000002e-23 or 2.2000000000000001e31 < t < 7.4999999999999998e150Initial program 66.4%
Taylor expanded in z around 0 80.0%
associate--l+80.0%
associate-+r+80.0%
associate-+r+80.0%
div-sub80.0%
*-commutative80.0%
associate-+r+80.0%
Simplified80.0%
Taylor expanded in x around inf 71.7%
Taylor expanded in x around 0 69.0%
*-commutative69.0%
+-commutative69.0%
Simplified69.0%
if -5.0000000000000002e-23 < t < -2.49999999999999991e-106Initial program 55.4%
Taylor expanded in z around 0 65.1%
associate--l+65.1%
associate-+r+65.1%
associate-+r+65.1%
div-sub65.1%
*-commutative65.1%
associate-+r+65.1%
Simplified65.1%
Taylor expanded in x around inf 65.1%
Taylor expanded in t around 0 54.9%
associate-/l*55.1%
+-commutative55.1%
associate-/l*89.9%
+-commutative89.9%
Simplified89.9%
Taylor expanded in z around inf 88.0%
if -2.49999999999999991e-106 < t < 1.4e-266 or 7.5000000000000006e-105 < t < 2.2000000000000001e31Initial program 71.5%
Taylor expanded in z around 0 83.5%
associate--l+83.5%
associate-+r+83.5%
associate-+r+83.5%
div-sub83.5%
*-commutative83.5%
associate-+r+83.5%
Simplified83.5%
Taylor expanded in x around inf 82.0%
Taylor expanded in t around 0 82.0%
distribute-rgt-out--82.2%
+-commutative82.2%
Simplified82.2%
if 1.4e-266 < t < 7.5000000000000006e-105Initial program 47.9%
Taylor expanded in y around inf 77.6%
if 7.4999999999999998e150 < t Initial program 44.5%
Taylor expanded in z around 0 55.7%
associate--l+55.7%
associate-+r+55.7%
associate-+r+55.7%
div-sub55.8%
*-commutative55.8%
associate-+r+55.8%
Simplified55.8%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 62.4%
associate-/l*74.5%
+-commutative74.5%
Simplified74.5%
Final simplification76.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (+ x t))) (t_2 (+ a (* z (+ (/ x t_1) (/ y t_1))))))
(if (<= t -1.26e+159)
t_2
(if (<= t -8.5e+120)
(/ a (/ t_1 (+ y t)))
(if (or (<= t -540000000000.0) (not (<= t 6.5e+31)))
t_2
(- (+ z (/ a (/ (+ x y) y))) (/ b (+ (/ x y) 1.0))))))))
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 * ((x / t_1) + (y / t_1)));
double tmp;
if (t <= -1.26e+159) {
tmp = t_2;
} else if (t <= -8.5e+120) {
tmp = a / (t_1 / (y + t));
} else if ((t <= -540000000000.0) || !(t <= 6.5e+31)) {
tmp = t_2;
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y + (x + t)
t_2 = a + (z * ((x / t_1) + (y / t_1)))
if (t <= (-1.26d+159)) then
tmp = t_2
else if (t <= (-8.5d+120)) then
tmp = a / (t_1 / (y + t))
else if ((t <= (-540000000000.0d0)) .or. (.not. (t <= 6.5d+31))) then
tmp = t_2
else
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0d0))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (x + t);
double t_2 = a + (z * ((x / t_1) + (y / t_1)));
double tmp;
if (t <= -1.26e+159) {
tmp = t_2;
} else if (t <= -8.5e+120) {
tmp = a / (t_1 / (y + t));
} else if ((t <= -540000000000.0) || !(t <= 6.5e+31)) {
tmp = t_2;
} else {
tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = y + (x + t) t_2 = a + (z * ((x / t_1) + (y / t_1))) tmp = 0 if t <= -1.26e+159: tmp = t_2 elif t <= -8.5e+120: tmp = a / (t_1 / (y + t)) elif (t <= -540000000000.0) or not (t <= 6.5e+31): tmp = t_2 else: tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(x + t)) t_2 = Float64(a + Float64(z * Float64(Float64(x / t_1) + Float64(y / t_1)))) tmp = 0.0 if (t <= -1.26e+159) tmp = t_2; elseif (t <= -8.5e+120) tmp = Float64(a / Float64(t_1 / Float64(y + t))); elseif ((t <= -540000000000.0) || !(t <= 6.5e+31)) tmp = t_2; else tmp = Float64(Float64(z + Float64(a / Float64(Float64(x + y) / y))) - Float64(b / Float64(Float64(x / y) + 1.0))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = y + (x + t); t_2 = a + (z * ((x / t_1) + (y / t_1))); tmp = 0.0; if (t <= -1.26e+159) tmp = t_2; elseif (t <= -8.5e+120) tmp = a / (t_1 / (y + t)); elseif ((t <= -540000000000.0) || ~((t <= 6.5e+31))) tmp = t_2; else tmp = (z + (a / ((x + y) / y))) - (b / ((x / y) + 1.0)); 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 * N[(N[(x / t$95$1), $MachinePrecision] + N[(y / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.26e+159], t$95$2, If[LessEqual[t, -8.5e+120], N[(a / N[(t$95$1 / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -540000000000.0], N[Not[LessEqual[t, 6.5e+31]], $MachinePrecision]], t$95$2, N[(N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b / N[(N[(x / y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \left(x + t\right)\\
t_2 := a + z \cdot \left(\frac{x}{t_1} + \frac{y}{t_1}\right)\\
\mathbf{if}\;t \leq -1.26 \cdot 10^{+159}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -8.5 \cdot 10^{+120}:\\
\;\;\;\;\frac{a}{\frac{t_1}{y + t}}\\
\mathbf{elif}\;t \leq -540000000000 \lor \neg \left(t \leq 6.5 \cdot 10^{+31}\right):\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\left(z + \frac{a}{\frac{x + y}{y}}\right) - \frac{b}{\frac{x}{y} + 1}\\
\end{array}
\end{array}
if t < -1.2599999999999999e159 or -8.50000000000000026e120 < t < -5.4e11 or 6.5000000000000004e31 < t Initial program 52.5%
Taylor expanded in z around 0 65.0%
associate--l+65.0%
associate-+r+65.0%
associate-+r+65.0%
div-sub65.0%
*-commutative65.0%
associate-+r+65.0%
Simplified65.0%
Taylor expanded in t around inf 76.9%
if -1.2599999999999999e159 < t < -8.50000000000000026e120Initial program 41.0%
Taylor expanded in a around inf 40.8%
associate-/l*87.7%
associate-+r+87.7%
Simplified87.7%
if -5.4e11 < t < 6.5000000000000004e31Initial program 62.3%
Taylor expanded in z around 0 77.2%
associate--l+77.2%
associate-+r+77.2%
associate-+r+77.2%
div-sub77.2%
*-commutative77.2%
associate-+r+77.2%
Simplified77.2%
Taylor expanded in x around inf 75.4%
Taylor expanded in t around 0 73.1%
associate-/l*79.8%
+-commutative79.8%
associate-/l*95.0%
+-commutative95.0%
Simplified95.0%
Taylor expanded in y around 0 95.0%
+-commutative95.0%
Simplified95.0%
Final simplification86.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x y) y)) (t_2 (- (+ z a) (/ (* y b) (+ y t)))))
(if (<= t -4.5e+160)
(+ a (* z (/ (+ x y) t)))
(if (<= t -2.5e+120)
(* (+ y t) (/ a (+ t (+ x y))))
(if (<= t -2.7e-29)
t_2
(if (<= t -3e-106)
(- z (/ b t_1))
(if (<= t 1.35e-266)
(+ z (/ (* y (- a b)) (+ x y)))
(if (<= t 1.9e+31)
(- (+ z (/ a t_1)) b)
(if (<= t 5e+154) t_2 (+ a (/ z (/ t (+ x y)))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + y) / y;
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -4.5e+160) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -2.5e+120) {
tmp = (y + t) * (a / (t + (x + y)));
} else if (t <= -2.7e-29) {
tmp = t_2;
} else if (t <= -3e-106) {
tmp = z - (b / t_1);
} else if (t <= 1.35e-266) {
tmp = z + ((y * (a - b)) / (x + y));
} else if (t <= 1.9e+31) {
tmp = (z + (a / t_1)) - b;
} else if (t <= 5e+154) {
tmp = t_2;
} else {
tmp = a + (z / (t / (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 = (x + y) / y
t_2 = (z + a) - ((y * b) / (y + t))
if (t <= (-4.5d+160)) then
tmp = a + (z * ((x + y) / t))
else if (t <= (-2.5d+120)) then
tmp = (y + t) * (a / (t + (x + y)))
else if (t <= (-2.7d-29)) then
tmp = t_2
else if (t <= (-3d-106)) then
tmp = z - (b / t_1)
else if (t <= 1.35d-266) then
tmp = z + ((y * (a - b)) / (x + y))
else if (t <= 1.9d+31) then
tmp = (z + (a / t_1)) - b
else if (t <= 5d+154) then
tmp = t_2
else
tmp = a + (z / (t / (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 = (x + y) / y;
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -4.5e+160) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -2.5e+120) {
tmp = (y + t) * (a / (t + (x + y)));
} else if (t <= -2.7e-29) {
tmp = t_2;
} else if (t <= -3e-106) {
tmp = z - (b / t_1);
} else if (t <= 1.35e-266) {
tmp = z + ((y * (a - b)) / (x + y));
} else if (t <= 1.9e+31) {
tmp = (z + (a / t_1)) - b;
} else if (t <= 5e+154) {
tmp = t_2;
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + y) / y t_2 = (z + a) - ((y * b) / (y + t)) tmp = 0 if t <= -4.5e+160: tmp = a + (z * ((x + y) / t)) elif t <= -2.5e+120: tmp = (y + t) * (a / (t + (x + y))) elif t <= -2.7e-29: tmp = t_2 elif t <= -3e-106: tmp = z - (b / t_1) elif t <= 1.35e-266: tmp = z + ((y * (a - b)) / (x + y)) elif t <= 1.9e+31: tmp = (z + (a / t_1)) - b elif t <= 5e+154: tmp = t_2 else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + y) / y) t_2 = Float64(Float64(z + a) - Float64(Float64(y * b) / Float64(y + t))) tmp = 0.0 if (t <= -4.5e+160) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= -2.5e+120) tmp = Float64(Float64(y + t) * Float64(a / Float64(t + Float64(x + y)))); elseif (t <= -2.7e-29) tmp = t_2; elseif (t <= -3e-106) tmp = Float64(z - Float64(b / t_1)); elseif (t <= 1.35e-266) tmp = Float64(z + Float64(Float64(y * Float64(a - b)) / Float64(x + y))); elseif (t <= 1.9e+31) tmp = Float64(Float64(z + Float64(a / t_1)) - b); elseif (t <= 5e+154) tmp = t_2; else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + y) / y; t_2 = (z + a) - ((y * b) / (y + t)); tmp = 0.0; if (t <= -4.5e+160) tmp = a + (z * ((x + y) / t)); elseif (t <= -2.5e+120) tmp = (y + t) * (a / (t + (x + y))); elseif (t <= -2.7e-29) tmp = t_2; elseif (t <= -3e-106) tmp = z - (b / t_1); elseif (t <= 1.35e-266) tmp = z + ((y * (a - b)) / (x + y)); elseif (t <= 1.9e+31) tmp = (z + (a / t_1)) - b; elseif (t <= 5e+154) tmp = t_2; else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + a), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4.5e+160], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.5e+120], N[(N[(y + t), $MachinePrecision] * N[(a / N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.7e-29], t$95$2, If[LessEqual[t, -3e-106], N[(z - N[(b / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.35e-266], N[(z + N[(N[(y * N[(a - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.9e+31], N[(N[(z + N[(a / t$95$1), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[t, 5e+154], t$95$2, N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + y}{y}\\
t_2 := \left(z + a\right) - \frac{y \cdot b}{y + t}\\
\mathbf{if}\;t \leq -4.5 \cdot 10^{+160}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq -2.5 \cdot 10^{+120}:\\
\;\;\;\;\left(y + t\right) \cdot \frac{a}{t + \left(x + y\right)}\\
\mathbf{elif}\;t \leq -2.7 \cdot 10^{-29}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -3 \cdot 10^{-106}:\\
\;\;\;\;z - \frac{b}{t_1}\\
\mathbf{elif}\;t \leq 1.35 \cdot 10^{-266}:\\
\;\;\;\;z + \frac{y \cdot \left(a - b\right)}{x + y}\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{+31}:\\
\;\;\;\;\left(z + \frac{a}{t_1}\right) - b\\
\mathbf{elif}\;t \leq 5 \cdot 10^{+154}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -4.4999999999999998e160Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 70.1%
+-commutative70.1%
Simplified70.1%
if -4.4999999999999998e160 < t < -2.50000000000000009e120Initial program 41.0%
Taylor expanded in a around inf 40.8%
associate-/l*87.7%
associate-+r+87.7%
Simplified87.7%
associate-/r/86.8%
associate-+l+86.8%
+-commutative86.8%
Applied egg-rr86.8%
if -2.50000000000000009e120 < t < -2.70000000000000023e-29 or 1.9000000000000001e31 < t < 5.00000000000000004e154Initial program 66.4%
Taylor expanded in z around 0 80.0%
associate--l+80.0%
associate-+r+80.0%
associate-+r+80.0%
div-sub80.0%
*-commutative80.0%
associate-+r+80.0%
Simplified80.0%
Taylor expanded in x around inf 71.7%
Taylor expanded in x around 0 69.0%
*-commutative69.0%
+-commutative69.0%
Simplified69.0%
if -2.70000000000000023e-29 < t < -3.00000000000000019e-106Initial program 55.4%
Taylor expanded in z around 0 65.1%
associate--l+65.1%
associate-+r+65.1%
associate-+r+65.1%
div-sub65.1%
*-commutative65.1%
associate-+r+65.1%
Simplified65.1%
Taylor expanded in x around inf 65.1%
Taylor expanded in t around 0 54.9%
associate-/l*55.1%
+-commutative55.1%
associate-/l*89.9%
+-commutative89.9%
Simplified89.9%
Taylor expanded in z around inf 88.0%
if -3.00000000000000019e-106 < t < 1.34999999999999998e-266Initial program 73.0%
Taylor expanded in z around 0 83.5%
associate--l+83.5%
associate-+r+83.5%
associate-+r+83.5%
div-sub83.4%
*-commutative83.4%
associate-+r+83.4%
Simplified83.4%
Taylor expanded in x around inf 83.5%
Taylor expanded in t around 0 83.5%
distribute-rgt-out--83.5%
+-commutative83.5%
Simplified83.5%
if 1.34999999999999998e-266 < t < 1.9000000000000001e31Initial program 54.2%
Taylor expanded in z around 0 74.2%
associate--l+74.2%
associate-+r+74.2%
associate-+r+74.2%
div-sub74.2%
*-commutative74.2%
associate-+r+74.2%
Simplified74.2%
Taylor expanded in x around inf 70.0%
Taylor expanded in t around 0 68.3%
associate-/l*78.4%
+-commutative78.4%
associate-/l*93.9%
+-commutative93.9%
Simplified93.9%
Taylor expanded in y around inf 78.8%
if 5.00000000000000004e154 < t Initial program 44.5%
Taylor expanded in z around 0 55.7%
associate--l+55.7%
associate-+r+55.7%
associate-+r+55.7%
div-sub55.8%
*-commutative55.8%
associate-+r+55.8%
Simplified55.8%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 62.4%
associate-/l*74.5%
+-commutative74.5%
Simplified74.5%
Final simplification76.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x y) y)) (t_2 (- (+ z a) (/ (* y b) (+ y t)))))
(if (<= t -2e+159)
(+ a (* z (/ (+ x y) t)))
(if (<= t -9e+119)
(/ a (/ (+ y (+ x t)) (+ y t)))
(if (<= t -8.6e-23)
t_2
(if (<= t -8.5e-107)
(- z (/ b t_1))
(if (<= t 1.25e-266)
(+ z (/ (* y (- a b)) (+ x y)))
(if (<= t 5.8e+31)
(- (+ z (/ a t_1)) b)
(if (<= t 1.6e+154) t_2 (+ a (/ z (/ t (+ x y)))))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + y) / y;
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -2e+159) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -9e+119) {
tmp = a / ((y + (x + t)) / (y + t));
} else if (t <= -8.6e-23) {
tmp = t_2;
} else if (t <= -8.5e-107) {
tmp = z - (b / t_1);
} else if (t <= 1.25e-266) {
tmp = z + ((y * (a - b)) / (x + y));
} else if (t <= 5.8e+31) {
tmp = (z + (a / t_1)) - b;
} else if (t <= 1.6e+154) {
tmp = t_2;
} else {
tmp = a + (z / (t / (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 = (x + y) / y
t_2 = (z + a) - ((y * b) / (y + t))
if (t <= (-2d+159)) then
tmp = a + (z * ((x + y) / t))
else if (t <= (-9d+119)) then
tmp = a / ((y + (x + t)) / (y + t))
else if (t <= (-8.6d-23)) then
tmp = t_2
else if (t <= (-8.5d-107)) then
tmp = z - (b / t_1)
else if (t <= 1.25d-266) then
tmp = z + ((y * (a - b)) / (x + y))
else if (t <= 5.8d+31) then
tmp = (z + (a / t_1)) - b
else if (t <= 1.6d+154) then
tmp = t_2
else
tmp = a + (z / (t / (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 = (x + y) / y;
double t_2 = (z + a) - ((y * b) / (y + t));
double tmp;
if (t <= -2e+159) {
tmp = a + (z * ((x + y) / t));
} else if (t <= -9e+119) {
tmp = a / ((y + (x + t)) / (y + t));
} else if (t <= -8.6e-23) {
tmp = t_2;
} else if (t <= -8.5e-107) {
tmp = z - (b / t_1);
} else if (t <= 1.25e-266) {
tmp = z + ((y * (a - b)) / (x + y));
} else if (t <= 5.8e+31) {
tmp = (z + (a / t_1)) - b;
} else if (t <= 1.6e+154) {
tmp = t_2;
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x + y) / y t_2 = (z + a) - ((y * b) / (y + t)) tmp = 0 if t <= -2e+159: tmp = a + (z * ((x + y) / t)) elif t <= -9e+119: tmp = a / ((y + (x + t)) / (y + t)) elif t <= -8.6e-23: tmp = t_2 elif t <= -8.5e-107: tmp = z - (b / t_1) elif t <= 1.25e-266: tmp = z + ((y * (a - b)) / (x + y)) elif t <= 5.8e+31: tmp = (z + (a / t_1)) - b elif t <= 1.6e+154: tmp = t_2 else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + y) / y) t_2 = Float64(Float64(z + a) - Float64(Float64(y * b) / Float64(y + t))) tmp = 0.0 if (t <= -2e+159) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= -9e+119) tmp = Float64(a / Float64(Float64(y + Float64(x + t)) / Float64(y + t))); elseif (t <= -8.6e-23) tmp = t_2; elseif (t <= -8.5e-107) tmp = Float64(z - Float64(b / t_1)); elseif (t <= 1.25e-266) tmp = Float64(z + Float64(Float64(y * Float64(a - b)) / Float64(x + y))); elseif (t <= 5.8e+31) tmp = Float64(Float64(z + Float64(a / t_1)) - b); elseif (t <= 1.6e+154) tmp = t_2; else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x + y) / y; t_2 = (z + a) - ((y * b) / (y + t)); tmp = 0.0; if (t <= -2e+159) tmp = a + (z * ((x + y) / t)); elseif (t <= -9e+119) tmp = a / ((y + (x + t)) / (y + t)); elseif (t <= -8.6e-23) tmp = t_2; elseif (t <= -8.5e-107) tmp = z - (b / t_1); elseif (t <= 1.25e-266) tmp = z + ((y * (a - b)) / (x + y)); elseif (t <= 5.8e+31) tmp = (z + (a / t_1)) - b; elseif (t <= 1.6e+154) tmp = t_2; else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + a), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2e+159], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -9e+119], N[(a / N[(N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -8.6e-23], t$95$2, If[LessEqual[t, -8.5e-107], N[(z - N[(b / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e-266], N[(z + N[(N[(y * N[(a - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.8e+31], N[(N[(z + N[(a / t$95$1), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision], If[LessEqual[t, 1.6e+154], t$95$2, N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + y}{y}\\
t_2 := \left(z + a\right) - \frac{y \cdot b}{y + t}\\
\mathbf{if}\;t \leq -2 \cdot 10^{+159}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq -9 \cdot 10^{+119}:\\
\;\;\;\;\frac{a}{\frac{y + \left(x + t\right)}{y + t}}\\
\mathbf{elif}\;t \leq -8.6 \cdot 10^{-23}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -8.5 \cdot 10^{-107}:\\
\;\;\;\;z - \frac{b}{t_1}\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-266}:\\
\;\;\;\;z + \frac{y \cdot \left(a - b\right)}{x + y}\\
\mathbf{elif}\;t \leq 5.8 \cdot 10^{+31}:\\
\;\;\;\;\left(z + \frac{a}{t_1}\right) - b\\
\mathbf{elif}\;t \leq 1.6 \cdot 10^{+154}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -1.9999999999999999e159Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 70.1%
+-commutative70.1%
Simplified70.1%
if -1.9999999999999999e159 < t < -9.00000000000000039e119Initial program 41.0%
Taylor expanded in a around inf 40.8%
associate-/l*87.7%
associate-+r+87.7%
Simplified87.7%
if -9.00000000000000039e119 < t < -8.60000000000000004e-23 or 5.8000000000000001e31 < t < 1.6e154Initial program 66.4%
Taylor expanded in z around 0 80.0%
associate--l+80.0%
associate-+r+80.0%
associate-+r+80.0%
div-sub80.0%
*-commutative80.0%
associate-+r+80.0%
Simplified80.0%
Taylor expanded in x around inf 71.7%
Taylor expanded in x around 0 69.0%
*-commutative69.0%
+-commutative69.0%
Simplified69.0%
if -8.60000000000000004e-23 < t < -8.49999999999999956e-107Initial program 55.4%
Taylor expanded in z around 0 65.1%
associate--l+65.1%
associate-+r+65.1%
associate-+r+65.1%
div-sub65.1%
*-commutative65.1%
associate-+r+65.1%
Simplified65.1%
Taylor expanded in x around inf 65.1%
Taylor expanded in t around 0 54.9%
associate-/l*55.1%
+-commutative55.1%
associate-/l*89.9%
+-commutative89.9%
Simplified89.9%
Taylor expanded in z around inf 88.0%
if -8.49999999999999956e-107 < t < 1.24999999999999998e-266Initial program 73.0%
Taylor expanded in z around 0 83.5%
associate--l+83.5%
associate-+r+83.5%
associate-+r+83.5%
div-sub83.4%
*-commutative83.4%
associate-+r+83.4%
Simplified83.4%
Taylor expanded in x around inf 83.5%
Taylor expanded in t around 0 83.5%
distribute-rgt-out--83.5%
+-commutative83.5%
Simplified83.5%
if 1.24999999999999998e-266 < t < 5.8000000000000001e31Initial program 54.2%
Taylor expanded in z around 0 74.2%
associate--l+74.2%
associate-+r+74.2%
associate-+r+74.2%
div-sub74.2%
*-commutative74.2%
associate-+r+74.2%
Simplified74.2%
Taylor expanded in x around inf 70.0%
Taylor expanded in t around 0 68.3%
associate-/l*78.4%
+-commutative78.4%
associate-/l*93.9%
+-commutative93.9%
Simplified93.9%
Taylor expanded in y around inf 78.8%
if 1.6e154 < t Initial program 44.5%
Taylor expanded in z around 0 55.7%
associate--l+55.7%
associate-+r+55.7%
associate-+r+55.7%
div-sub55.8%
*-commutative55.8%
associate-+r+55.8%
Simplified55.8%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 62.4%
associate-/l*74.5%
+-commutative74.5%
Simplified74.5%
Final simplification76.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ z (/ (- (* (+ y t) a) (* y b)) (+ y (+ x t)))))
(t_2 (- (+ z (/ a (/ (+ x y) y))) b)))
(if (<= y -2.4e+73)
t_2
(if (<= y 2.55e-288)
t_1
(if (<= y 2.3e-106)
(/ (+ (* t a) (* x z)) (+ x t))
(if (<= y 4e+106) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z + ((((y + t) * a) - (y * b)) / (y + (x + t)));
double t_2 = (z + (a / ((x + y) / y))) - b;
double tmp;
if (y <= -2.4e+73) {
tmp = t_2;
} else if (y <= 2.55e-288) {
tmp = t_1;
} else if (y <= 2.3e-106) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4e+106) {
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 + ((((y + t) * a) - (y * b)) / (y + (x + t)))
t_2 = (z + (a / ((x + y) / y))) - b
if (y <= (-2.4d+73)) then
tmp = t_2
else if (y <= 2.55d-288) then
tmp = t_1
else if (y <= 2.3d-106) then
tmp = ((t * a) + (x * z)) / (x + t)
else if (y <= 4d+106) 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 + ((((y + t) * a) - (y * b)) / (y + (x + t)));
double t_2 = (z + (a / ((x + y) / y))) - b;
double tmp;
if (y <= -2.4e+73) {
tmp = t_2;
} else if (y <= 2.55e-288) {
tmp = t_1;
} else if (y <= 2.3e-106) {
tmp = ((t * a) + (x * z)) / (x + t);
} else if (y <= 4e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z + ((((y + t) * a) - (y * b)) / (y + (x + t))) t_2 = (z + (a / ((x + y) / y))) - b tmp = 0 if y <= -2.4e+73: tmp = t_2 elif y <= 2.55e-288: tmp = t_1 elif y <= 2.3e-106: tmp = ((t * a) + (x * z)) / (x + t) elif y <= 4e+106: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z + Float64(Float64(Float64(Float64(y + t) * a) - Float64(y * b)) / Float64(y + Float64(x + t)))) t_2 = Float64(Float64(z + Float64(a / Float64(Float64(x + y) / y))) - b) tmp = 0.0 if (y <= -2.4e+73) tmp = t_2; elseif (y <= 2.55e-288) tmp = t_1; elseif (y <= 2.3e-106) tmp = Float64(Float64(Float64(t * a) + Float64(x * z)) / Float64(x + t)); elseif (y <= 4e+106) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z + ((((y + t) * a) - (y * b)) / (y + (x + t))); t_2 = (z + (a / ((x + y) / y))) - b; tmp = 0.0; if (y <= -2.4e+73) tmp = t_2; elseif (y <= 2.55e-288) tmp = t_1; elseif (y <= 2.3e-106) tmp = ((t * a) + (x * z)) / (x + t); elseif (y <= 4e+106) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z + N[(N[(N[(N[(y + t), $MachinePrecision] * a), $MachinePrecision] - N[(y * b), $MachinePrecision]), $MachinePrecision] / N[(y + N[(x + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]}, If[LessEqual[y, -2.4e+73], t$95$2, If[LessEqual[y, 2.55e-288], t$95$1, If[LessEqual[y, 2.3e-106], N[(N[(N[(t * a), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] / N[(x + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4e+106], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z + \frac{\left(y + t\right) \cdot a - y \cdot b}{y + \left(x + t\right)}\\
t_2 := \left(z + \frac{a}{\frac{x + y}{y}}\right) - b\\
\mathbf{if}\;y \leq -2.4 \cdot 10^{+73}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 2.55 \cdot 10^{-288}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 2.3 \cdot 10^{-106}:\\
\;\;\;\;\frac{t \cdot a + x \cdot z}{x + t}\\
\mathbf{elif}\;y \leq 4 \cdot 10^{+106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -2.40000000000000002e73 or 4.00000000000000036e106 < y Initial program 33.5%
Taylor expanded in z around 0 49.2%
associate--l+49.2%
associate-+r+49.2%
associate-+r+49.2%
div-sub49.2%
*-commutative49.2%
associate-+r+49.2%
Simplified49.2%
Taylor expanded in x around inf 41.9%
Taylor expanded in t around 0 43.6%
associate-/l*60.8%
+-commutative60.8%
associate-/l*86.9%
+-commutative86.9%
Simplified86.9%
Taylor expanded in y around inf 82.0%
if -2.40000000000000002e73 < y < 2.54999999999999997e-288 or 2.3000000000000001e-106 < y < 4.00000000000000036e106Initial program 71.3%
Taylor expanded in z around 0 84.0%
associate--l+84.0%
associate-+r+84.0%
associate-+r+84.0%
div-sub84.0%
*-commutative84.0%
associate-+r+84.0%
Simplified84.0%
Taylor expanded in x around inf 72.5%
if 2.54999999999999997e-288 < y < 2.3000000000000001e-106Initial program 77.8%
Taylor expanded in y around 0 77.6%
Final simplification77.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- (+ z (/ a (/ (+ x y) y))) (* y (/ b (+ x y))))))
(if (<= t -9.5e+187)
(+ a (* z (/ (+ x y) t)))
(if (<= t 7e+31)
t_1
(if (<= t 3.6e+77)
(- (+ z a) (/ (* y b) (+ y t)))
(if (<= t 8e+180) t_1 (+ a (/ z (/ t (+ x y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z + (a / ((x + y) / y))) - (y * (b / (x + y)));
double tmp;
if (t <= -9.5e+187) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 7e+31) {
tmp = t_1;
} else if (t <= 3.6e+77) {
tmp = (z + a) - ((y * b) / (y + t));
} else if (t <= 8e+180) {
tmp = t_1;
} else {
tmp = a + (z / (t / (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 = (z + (a / ((x + y) / y))) - (y * (b / (x + y)))
if (t <= (-9.5d+187)) then
tmp = a + (z * ((x + y) / t))
else if (t <= 7d+31) then
tmp = t_1
else if (t <= 3.6d+77) then
tmp = (z + a) - ((y * b) / (y + t))
else if (t <= 8d+180) then
tmp = t_1
else
tmp = a + (z / (t / (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 = (z + (a / ((x + y) / y))) - (y * (b / (x + y)));
double tmp;
if (t <= -9.5e+187) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 7e+31) {
tmp = t_1;
} else if (t <= 3.6e+77) {
tmp = (z + a) - ((y * b) / (y + t));
} else if (t <= 8e+180) {
tmp = t_1;
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (z + (a / ((x + y) / y))) - (y * (b / (x + y))) tmp = 0 if t <= -9.5e+187: tmp = a + (z * ((x + y) / t)) elif t <= 7e+31: tmp = t_1 elif t <= 3.6e+77: tmp = (z + a) - ((y * b) / (y + t)) elif t <= 8e+180: tmp = t_1 else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z + Float64(a / Float64(Float64(x + y) / y))) - Float64(y * Float64(b / Float64(x + y)))) tmp = 0.0 if (t <= -9.5e+187) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= 7e+31) tmp = t_1; elseif (t <= 3.6e+77) tmp = Float64(Float64(z + a) - Float64(Float64(y * b) / Float64(y + t))); elseif (t <= 8e+180) tmp = t_1; else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (z + (a / ((x + y) / y))) - (y * (b / (x + y))); tmp = 0.0; if (t <= -9.5e+187) tmp = a + (z * ((x + y) / t)); elseif (t <= 7e+31) tmp = t_1; elseif (t <= 3.6e+77) tmp = (z + a) - ((y * b) / (y + t)); elseif (t <= 8e+180) tmp = t_1; else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y * N[(b / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.5e+187], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7e+31], t$95$1, If[LessEqual[t, 3.6e+77], N[(N[(z + a), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+180], t$95$1, N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z + \frac{a}{\frac{x + y}{y}}\right) - y \cdot \frac{b}{x + y}\\
\mathbf{if}\;t \leq -9.5 \cdot 10^{+187}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq 7 \cdot 10^{+31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+77}:\\
\;\;\;\;\left(z + a\right) - \frac{y \cdot b}{y + t}\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+180}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -9.4999999999999996e187Initial program 40.8%
Taylor expanded in z around 0 52.2%
associate--l+52.2%
associate-+r+52.2%
associate-+r+52.2%
div-sub52.2%
*-commutative52.2%
associate-+r+52.2%
Simplified52.2%
Taylor expanded in t around inf 80.4%
Taylor expanded in t around inf 76.6%
+-commutative76.6%
Simplified76.6%
if -9.4999999999999996e187 < t < 7e31 or 3.5999999999999998e77 < t < 8.0000000000000001e180Initial program 59.0%
Taylor expanded in z around 0 73.1%
associate--l+73.1%
associate-+r+73.1%
associate-+r+73.1%
div-sub73.1%
*-commutative73.1%
associate-+r+73.1%
Simplified73.1%
Taylor expanded in x around inf 69.7%
Taylor expanded in t around 0 64.7%
associate-/l*72.6%
+-commutative72.6%
associate-/l*86.4%
+-commutative86.4%
Simplified86.4%
associate-/r/84.8%
Applied egg-rr84.8%
if 7e31 < t < 3.5999999999999998e77Initial program 85.7%
Taylor expanded in z around 0 93.0%
associate--l+93.0%
associate-+r+93.0%
associate-+r+93.0%
div-sub93.0%
*-commutative93.0%
associate-+r+93.0%
Simplified93.0%
Taylor expanded in x around inf 78.8%
Taylor expanded in x around 0 82.7%
*-commutative82.7%
+-commutative82.7%
Simplified82.7%
if 8.0000000000000001e180 < t Initial program 48.5%
Taylor expanded in z around 0 61.0%
associate--l+61.0%
associate-+r+61.0%
associate-+r+61.0%
div-sub61.0%
*-commutative61.0%
associate-+r+61.0%
Simplified61.0%
Taylor expanded in t around inf 80.9%
Taylor expanded in t around inf 61.1%
associate-/l*74.4%
+-commutative74.4%
Simplified74.4%
Final simplification82.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ z (/ a (/ (+ x y) y)))))
(if (<= t -2.9e+189)
(+ a (* z (/ (+ x y) t)))
(if (<= t 4.8e+31)
(- t_1 (/ b (+ (/ x y) 1.0)))
(if (<= t 3.6e+77)
(- (+ z a) (/ (* y b) (+ y t)))
(if (<= t 1.9e+180)
(- t_1 (* y (/ b (+ x y))))
(+ a (/ z (/ t (+ x y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z + (a / ((x + y) / y));
double tmp;
if (t <= -2.9e+189) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 4.8e+31) {
tmp = t_1 - (b / ((x / y) + 1.0));
} else if (t <= 3.6e+77) {
tmp = (z + a) - ((y * b) / (y + t));
} else if (t <= 1.9e+180) {
tmp = t_1 - (y * (b / (x + y)));
} else {
tmp = a + (z / (t / (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 = z + (a / ((x + y) / y))
if (t <= (-2.9d+189)) then
tmp = a + (z * ((x + y) / t))
else if (t <= 4.8d+31) then
tmp = t_1 - (b / ((x / y) + 1.0d0))
else if (t <= 3.6d+77) then
tmp = (z + a) - ((y * b) / (y + t))
else if (t <= 1.9d+180) then
tmp = t_1 - (y * (b / (x + y)))
else
tmp = a + (z / (t / (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 = z + (a / ((x + y) / y));
double tmp;
if (t <= -2.9e+189) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 4.8e+31) {
tmp = t_1 - (b / ((x / y) + 1.0));
} else if (t <= 3.6e+77) {
tmp = (z + a) - ((y * b) / (y + t));
} else if (t <= 1.9e+180) {
tmp = t_1 - (y * (b / (x + y)));
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z + (a / ((x + y) / y)) tmp = 0 if t <= -2.9e+189: tmp = a + (z * ((x + y) / t)) elif t <= 4.8e+31: tmp = t_1 - (b / ((x / y) + 1.0)) elif t <= 3.6e+77: tmp = (z + a) - ((y * b) / (y + t)) elif t <= 1.9e+180: tmp = t_1 - (y * (b / (x + y))) else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z + Float64(a / Float64(Float64(x + y) / y))) tmp = 0.0 if (t <= -2.9e+189) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= 4.8e+31) tmp = Float64(t_1 - Float64(b / Float64(Float64(x / y) + 1.0))); elseif (t <= 3.6e+77) tmp = Float64(Float64(z + a) - Float64(Float64(y * b) / Float64(y + t))); elseif (t <= 1.9e+180) tmp = Float64(t_1 - Float64(y * Float64(b / Float64(x + y)))); else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z + (a / ((x + y) / y)); tmp = 0.0; if (t <= -2.9e+189) tmp = a + (z * ((x + y) / t)); elseif (t <= 4.8e+31) tmp = t_1 - (b / ((x / y) + 1.0)); elseif (t <= 3.6e+77) tmp = (z + a) - ((y * b) / (y + t)); elseif (t <= 1.9e+180) tmp = t_1 - (y * (b / (x + y))); else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z + N[(a / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.9e+189], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.8e+31], N[(t$95$1 - N[(b / N[(N[(x / y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.6e+77], N[(N[(z + a), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] / N[(y + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.9e+180], N[(t$95$1 - N[(y * N[(b / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z + \frac{a}{\frac{x + y}{y}}\\
\mathbf{if}\;t \leq -2.9 \cdot 10^{+189}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{+31}:\\
\;\;\;\;t_1 - \frac{b}{\frac{x}{y} + 1}\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+77}:\\
\;\;\;\;\left(z + a\right) - \frac{y \cdot b}{y + t}\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{+180}:\\
\;\;\;\;t_1 - y \cdot \frac{b}{x + y}\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -2.90000000000000019e189Initial program 40.8%
Taylor expanded in z around 0 52.2%
associate--l+52.2%
associate-+r+52.2%
associate-+r+52.2%
div-sub52.2%
*-commutative52.2%
associate-+r+52.2%
Simplified52.2%
Taylor expanded in t around inf 80.4%
Taylor expanded in t around inf 76.6%
+-commutative76.6%
Simplified76.6%
if -2.90000000000000019e189 < t < 4.79999999999999965e31Initial program 61.4%
Taylor expanded in z around 0 75.4%
associate--l+75.4%
associate-+r+75.4%
associate-+r+75.4%
div-sub75.3%
*-commutative75.3%
associate-+r+75.3%
Simplified75.3%
Taylor expanded in x around inf 72.2%
Taylor expanded in t around 0 66.1%
associate-/l*73.1%
+-commutative73.1%
associate-/l*86.6%
+-commutative86.6%
Simplified86.6%
Taylor expanded in y around 0 86.7%
+-commutative86.7%
Simplified86.7%
if 4.79999999999999965e31 < t < 3.5999999999999998e77Initial program 85.7%
Taylor expanded in z around 0 93.0%
associate--l+93.0%
associate-+r+93.0%
associate-+r+93.0%
div-sub93.0%
*-commutative93.0%
associate-+r+93.0%
Simplified93.0%
Taylor expanded in x around inf 78.8%
Taylor expanded in x around 0 82.7%
*-commutative82.7%
+-commutative82.7%
Simplified82.7%
if 3.5999999999999998e77 < t < 1.9e180Initial program 37.1%
Taylor expanded in z around 0 53.1%
associate--l+53.1%
associate-+r+53.1%
associate-+r+53.1%
div-sub53.1%
*-commutative53.1%
associate-+r+53.1%
Simplified53.1%
Taylor expanded in x around inf 47.5%
Taylor expanded in t around 0 52.2%
associate-/l*68.0%
+-commutative68.0%
associate-/l*84.1%
+-commutative84.1%
Simplified84.1%
associate-/r/84.2%
Applied egg-rr84.2%
if 1.9e180 < t Initial program 48.5%
Taylor expanded in z around 0 61.0%
associate--l+61.0%
associate-+r+61.0%
associate-+r+61.0%
div-sub61.0%
*-commutative61.0%
associate-+r+61.0%
Simplified61.0%
Taylor expanded in t around inf 80.9%
Taylor expanded in t around inf 61.1%
associate-/l*74.4%
+-commutative74.4%
Simplified74.4%
Final simplification83.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (- z (/ b (/ (+ x y) y)))))
(if (<= a -5.4e-5)
(+ z a)
(if (<= a 9.2e+46)
t_1
(if (<= a 3e+96)
(+ a (/ y (/ (+ y t) z)))
(if (<= a 2.1e+109) t_1 (* (+ y t) (/ a (+ t (+ x y))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = z - (b / ((x + y) / y));
double tmp;
if (a <= -5.4e-5) {
tmp = z + a;
} else if (a <= 9.2e+46) {
tmp = t_1;
} else if (a <= 3e+96) {
tmp = a + (y / ((y + t) / z));
} else if (a <= 2.1e+109) {
tmp = t_1;
} else {
tmp = (y + t) * (a / (t + (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 = z - (b / ((x + y) / y))
if (a <= (-5.4d-5)) then
tmp = z + a
else if (a <= 9.2d+46) then
tmp = t_1
else if (a <= 3d+96) then
tmp = a + (y / ((y + t) / z))
else if (a <= 2.1d+109) then
tmp = t_1
else
tmp = (y + t) * (a / (t + (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 = z - (b / ((x + y) / y));
double tmp;
if (a <= -5.4e-5) {
tmp = z + a;
} else if (a <= 9.2e+46) {
tmp = t_1;
} else if (a <= 3e+96) {
tmp = a + (y / ((y + t) / z));
} else if (a <= 2.1e+109) {
tmp = t_1;
} else {
tmp = (y + t) * (a / (t + (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = z - (b / ((x + y) / y)) tmp = 0 if a <= -5.4e-5: tmp = z + a elif a <= 9.2e+46: tmp = t_1 elif a <= 3e+96: tmp = a + (y / ((y + t) / z)) elif a <= 2.1e+109: tmp = t_1 else: tmp = (y + t) * (a / (t + (x + y))) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(z - Float64(b / Float64(Float64(x + y) / y))) tmp = 0.0 if (a <= -5.4e-5) tmp = Float64(z + a); elseif (a <= 9.2e+46) tmp = t_1; elseif (a <= 3e+96) tmp = Float64(a + Float64(y / Float64(Float64(y + t) / z))); elseif (a <= 2.1e+109) tmp = t_1; else tmp = Float64(Float64(y + t) * Float64(a / Float64(t + Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = z - (b / ((x + y) / y)); tmp = 0.0; if (a <= -5.4e-5) tmp = z + a; elseif (a <= 9.2e+46) tmp = t_1; elseif (a <= 3e+96) tmp = a + (y / ((y + t) / z)); elseif (a <= 2.1e+109) tmp = t_1; else tmp = (y + t) * (a / (t + (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z - N[(b / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.4e-5], N[(z + a), $MachinePrecision], If[LessEqual[a, 9.2e+46], t$95$1, If[LessEqual[a, 3e+96], N[(a + N[(y / N[(N[(y + t), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e+109], t$95$1, N[(N[(y + t), $MachinePrecision] * N[(a / N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z - \frac{b}{\frac{x + y}{y}}\\
\mathbf{if}\;a \leq -5.4 \cdot 10^{-5}:\\
\;\;\;\;z + a\\
\mathbf{elif}\;a \leq 9.2 \cdot 10^{+46}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 3 \cdot 10^{+96}:\\
\;\;\;\;a + \frac{y}{\frac{y + t}{z}}\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+109}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\left(y + t\right) \cdot \frac{a}{t + \left(x + y\right)}\\
\end{array}
\end{array}
if a < -5.3999999999999998e-5Initial program 51.2%
Taylor expanded in z around 0 62.0%
associate--l+62.0%
associate-+r+62.0%
associate-+r+62.0%
div-sub62.0%
*-commutative62.0%
associate-+r+62.0%
Simplified62.0%
Taylor expanded in t around inf 74.1%
Taylor expanded in x around inf 68.3%
if -5.3999999999999998e-5 < a < 9.2000000000000002e46 or 3e96 < a < 2.1000000000000001e109Initial program 66.9%
Taylor expanded in z around 0 84.2%
associate--l+84.2%
associate-+r+84.2%
associate-+r+84.2%
div-sub84.2%
*-commutative84.2%
associate-+r+84.2%
Simplified84.2%
Taylor expanded in x around inf 65.1%
Taylor expanded in t around 0 56.1%
associate-/l*56.1%
+-commutative56.1%
associate-/l*67.2%
+-commutative67.2%
Simplified67.2%
Taylor expanded in z around inf 63.9%
if 9.2000000000000002e46 < a < 3e96Initial program 67.7%
Taylor expanded in z around 0 67.9%
associate--l+67.9%
associate-+r+67.9%
associate-+r+67.9%
div-sub67.9%
*-commutative67.9%
associate-+r+67.9%
Simplified67.9%
Taylor expanded in t around inf 82.8%
Taylor expanded in x around 0 82.8%
associate-/l*82.8%
+-commutative82.8%
Simplified82.8%
if 2.1000000000000001e109 < a Initial program 28.4%
Taylor expanded in a around inf 26.5%
associate-/l*82.5%
associate-+r+82.5%
Simplified82.5%
associate-/r/80.3%
associate-+l+80.3%
+-commutative80.3%
Applied egg-rr80.3%
Final simplification68.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= a -1e-5)
(+ z a)
(if (<= a 60000.0)
(- z (/ b (/ (+ x y) y)))
(if (<= a 2e+109)
(+ z (/ (* y (- a b)) (+ x y)))
(* (+ y t) (/ a (+ t (+ x y))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (a <= -1e-5) {
tmp = z + a;
} else if (a <= 60000.0) {
tmp = z - (b / ((x + y) / y));
} else if (a <= 2e+109) {
tmp = z + ((y * (a - b)) / (x + y));
} else {
tmp = (y + t) * (a / (t + (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) :: tmp
if (a <= (-1d-5)) then
tmp = z + a
else if (a <= 60000.0d0) then
tmp = z - (b / ((x + y) / y))
else if (a <= 2d+109) then
tmp = z + ((y * (a - b)) / (x + y))
else
tmp = (y + t) * (a / (t + (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 tmp;
if (a <= -1e-5) {
tmp = z + a;
} else if (a <= 60000.0) {
tmp = z - (b / ((x + y) / y));
} else if (a <= 2e+109) {
tmp = z + ((y * (a - b)) / (x + y));
} else {
tmp = (y + t) * (a / (t + (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if a <= -1e-5: tmp = z + a elif a <= 60000.0: tmp = z - (b / ((x + y) / y)) elif a <= 2e+109: tmp = z + ((y * (a - b)) / (x + y)) else: tmp = (y + t) * (a / (t + (x + y))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (a <= -1e-5) tmp = Float64(z + a); elseif (a <= 60000.0) tmp = Float64(z - Float64(b / Float64(Float64(x + y) / y))); elseif (a <= 2e+109) tmp = Float64(z + Float64(Float64(y * Float64(a - b)) / Float64(x + y))); else tmp = Float64(Float64(y + t) * Float64(a / Float64(t + Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (a <= -1e-5) tmp = z + a; elseif (a <= 60000.0) tmp = z - (b / ((x + y) / y)); elseif (a <= 2e+109) tmp = z + ((y * (a - b)) / (x + y)); else tmp = (y + t) * (a / (t + (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[a, -1e-5], N[(z + a), $MachinePrecision], If[LessEqual[a, 60000.0], N[(z - N[(b / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2e+109], N[(z + N[(N[(y * N[(a - b), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y + t), $MachinePrecision] * N[(a / N[(t + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1 \cdot 10^{-5}:\\
\;\;\;\;z + a\\
\mathbf{elif}\;a \leq 60000:\\
\;\;\;\;z - \frac{b}{\frac{x + y}{y}}\\
\mathbf{elif}\;a \leq 2 \cdot 10^{+109}:\\
\;\;\;\;z + \frac{y \cdot \left(a - b\right)}{x + y}\\
\mathbf{else}:\\
\;\;\;\;\left(y + t\right) \cdot \frac{a}{t + \left(x + y\right)}\\
\end{array}
\end{array}
if a < -1.00000000000000008e-5Initial program 51.2%
Taylor expanded in z around 0 62.0%
associate--l+62.0%
associate-+r+62.0%
associate-+r+62.0%
div-sub62.0%
*-commutative62.0%
associate-+r+62.0%
Simplified62.0%
Taylor expanded in t around inf 74.1%
Taylor expanded in x around inf 68.3%
if -1.00000000000000008e-5 < a < 6e4Initial program 65.2%
Taylor expanded in z around 0 83.9%
associate--l+83.9%
associate-+r+83.9%
associate-+r+83.9%
div-sub83.9%
*-commutative83.9%
associate-+r+83.9%
Simplified83.9%
Taylor expanded in x around inf 62.6%
Taylor expanded in t around 0 52.6%
associate-/l*52.6%
+-commutative52.6%
associate-/l*64.2%
+-commutative64.2%
Simplified64.2%
Taylor expanded in z around inf 63.5%
if 6e4 < a < 1.99999999999999996e109Initial program 75.2%
Taylor expanded in z around 0 78.6%
associate--l+78.6%
associate-+r+78.6%
associate-+r+78.6%
div-sub78.6%
*-commutative78.6%
associate-+r+78.6%
Simplified78.6%
Taylor expanded in x around inf 78.6%
Taylor expanded in t around 0 74.8%
distribute-rgt-out--74.8%
+-commutative74.8%
Simplified74.8%
if 1.99999999999999996e109 < a Initial program 28.4%
Taylor expanded in a around inf 26.5%
associate-/l*82.5%
associate-+r+82.5%
Simplified82.5%
associate-/r/80.3%
associate-+l+80.3%
+-commutative80.3%
Applied egg-rr80.3%
Final simplification68.6%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -2.8e+169) (not (<= t 2.6e+152))) (+ a (* z (/ (+ x y) t))) (- (+ z a) b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -2.8e+169) || !(t <= 2.6e+152)) {
tmp = a + (z * ((x + y) / 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 <= (-2.8d+169)) .or. (.not. (t <= 2.6d+152))) then
tmp = a + (z * ((x + y) / 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 <= -2.8e+169) || !(t <= 2.6e+152)) {
tmp = a + (z * ((x + y) / t));
} else {
tmp = (z + a) - b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -2.8e+169) or not (t <= 2.6e+152): tmp = a + (z * ((x + y) / t)) else: tmp = (z + a) - b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -2.8e+169) || !(t <= 2.6e+152)) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / 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 <= -2.8e+169) || ~((t <= 2.6e+152))) tmp = a + (z * ((x + y) / t)); else tmp = (z + a) - b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -2.8e+169], N[Not[LessEqual[t, 2.6e+152]], $MachinePrecision]], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.8 \cdot 10^{+169} \lor \neg \left(t \leq 2.6 \cdot 10^{+152}\right):\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{else}:\\
\;\;\;\;\left(z + a\right) - b\\
\end{array}
\end{array}
if t < -2.8000000000000002e169 or 2.6000000000000001e152 < t Initial program 43.6%
Taylor expanded in z around 0 55.6%
associate--l+55.6%
associate-+r+55.6%
associate-+r+55.6%
div-sub55.6%
*-commutative55.6%
associate-+r+55.6%
Simplified55.6%
Taylor expanded in t around inf 78.7%
Taylor expanded in t around inf 72.6%
+-commutative72.6%
Simplified72.6%
if -2.8000000000000002e169 < t < 2.6000000000000001e152Initial program 62.1%
Taylor expanded in y around inf 63.3%
Final simplification65.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= a -8e-6) (not (<= a 6.5e+16))) (+ z a) (- z (/ b (/ (+ x y) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a <= -8e-6) || !(a <= 6.5e+16)) {
tmp = z + a;
} else {
tmp = z - (b / ((x + y) / 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) :: tmp
if ((a <= (-8d-6)) .or. (.not. (a <= 6.5d+16))) then
tmp = z + a
else
tmp = z - (b / ((x + y) / y))
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 <= -8e-6) || !(a <= 6.5e+16)) {
tmp = z + a;
} else {
tmp = z - (b / ((x + y) / y));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (a <= -8e-6) or not (a <= 6.5e+16): tmp = z + a else: tmp = z - (b / ((x + y) / y)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((a <= -8e-6) || !(a <= 6.5e+16)) tmp = Float64(z + a); else tmp = Float64(z - Float64(b / Float64(Float64(x + y) / y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((a <= -8e-6) || ~((a <= 6.5e+16))) tmp = z + a; else tmp = z - (b / ((x + y) / y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[a, -8e-6], N[Not[LessEqual[a, 6.5e+16]], $MachinePrecision]], N[(z + a), $MachinePrecision], N[(z - N[(b / N[(N[(x + y), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8 \cdot 10^{-6} \lor \neg \left(a \leq 6.5 \cdot 10^{+16}\right):\\
\;\;\;\;z + a\\
\mathbf{else}:\\
\;\;\;\;z - \frac{b}{\frac{x + y}{y}}\\
\end{array}
\end{array}
if a < -7.99999999999999964e-6 or 6.5e16 < a Initial program 46.9%
Taylor expanded in z around 0 54.7%
associate--l+54.7%
associate-+r+54.7%
associate-+r+54.7%
div-sub54.7%
*-commutative54.7%
associate-+r+54.7%
Simplified54.7%
Taylor expanded in t around inf 69.5%
Taylor expanded in x around inf 65.4%
if -7.99999999999999964e-6 < a < 6.5e16Initial program 66.0%
Taylor expanded in z around 0 84.2%
associate--l+84.2%
associate-+r+84.2%
associate-+r+84.2%
div-sub84.2%
*-commutative84.2%
associate-+r+84.2%
Simplified84.2%
Taylor expanded in x around inf 63.4%
Taylor expanded in t around 0 53.6%
associate-/l*53.6%
+-commutative53.6%
associate-/l*65.0%
+-commutative65.0%
Simplified65.0%
Taylor expanded in z around inf 63.6%
Final simplification64.4%
(FPCore (x y z t a b) :precision binary64 (if (<= t -4.1e+160) (+ a (* z (/ (+ x y) t))) (if (<= t 1.16e+148) (- (+ z a) b) (+ a (/ z (/ t (+ x y)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -4.1e+160) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 1.16e+148) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / (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) :: tmp
if (t <= (-4.1d+160)) then
tmp = a + (z * ((x + y) / t))
else if (t <= 1.16d+148) then
tmp = (z + a) - b
else
tmp = a + (z / (t / (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 tmp;
if (t <= -4.1e+160) {
tmp = a + (z * ((x + y) / t));
} else if (t <= 1.16e+148) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / (x + y)));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -4.1e+160: tmp = a + (z * ((x + y) / t)) elif t <= 1.16e+148: tmp = (z + a) - b else: tmp = a + (z / (t / (x + y))) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -4.1e+160) tmp = Float64(a + Float64(z * Float64(Float64(x + y) / t))); elseif (t <= 1.16e+148) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a + Float64(z / Float64(t / Float64(x + y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -4.1e+160) tmp = a + (z * ((x + y) / t)); elseif (t <= 1.16e+148) tmp = (z + a) - b; else tmp = a + (z / (t / (x + y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -4.1e+160], N[(a + N[(z * N[(N[(x + y), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.16e+148], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a + N[(z / N[(t / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.1 \cdot 10^{+160}:\\
\;\;\;\;a + z \cdot \frac{x + y}{t}\\
\mathbf{elif}\;t \leq 1.16 \cdot 10^{+148}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x + y}}\\
\end{array}
\end{array}
if t < -4.09999999999999998e160Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 70.1%
+-commutative70.1%
Simplified70.1%
if -4.09999999999999998e160 < t < 1.1599999999999999e148Initial program 62.1%
Taylor expanded in y around inf 63.3%
if 1.1599999999999999e148 < t Initial program 44.5%
Taylor expanded in z around 0 55.7%
associate--l+55.7%
associate-+r+55.7%
associate-+r+55.7%
div-sub55.8%
*-commutative55.8%
associate-+r+55.8%
Simplified55.8%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 62.4%
associate-/l*74.5%
+-commutative74.5%
Simplified74.5%
Final simplification65.9%
(FPCore (x y z t a b) :precision binary64 (if (or (<= t -6e+164) (not (<= t 3.2e+152))) (+ a (/ y (/ t z))) (- (+ z a) b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((t <= -6e+164) || !(t <= 3.2e+152)) {
tmp = a + (y / (t / z));
} 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 <= (-6d+164)) .or. (.not. (t <= 3.2d+152))) then
tmp = a + (y / (t / z))
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 <= -6e+164) || !(t <= 3.2e+152)) {
tmp = a + (y / (t / z));
} else {
tmp = (z + a) - b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (t <= -6e+164) or not (t <= 3.2e+152): tmp = a + (y / (t / z)) else: tmp = (z + a) - b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((t <= -6e+164) || !(t <= 3.2e+152)) tmp = Float64(a + Float64(y / Float64(t / z))); 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 <= -6e+164) || ~((t <= 3.2e+152))) tmp = a + (y / (t / z)); else tmp = (z + a) - b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[t, -6e+164], N[Not[LessEqual[t, 3.2e+152]], $MachinePrecision]], N[(a + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6 \cdot 10^{+164} \lor \neg \left(t \leq 3.2 \cdot 10^{+152}\right):\\
\;\;\;\;a + \frac{y}{\frac{t}{z}}\\
\mathbf{else}:\\
\;\;\;\;\left(z + a\right) - b\\
\end{array}
\end{array}
if t < -6.00000000000000001e164 or 3.20000000000000005e152 < t Initial program 43.6%
Taylor expanded in z around 0 55.6%
associate--l+55.6%
associate-+r+55.6%
associate-+r+55.6%
div-sub55.6%
*-commutative55.6%
associate-+r+55.6%
Simplified55.6%
Taylor expanded in t around inf 78.7%
Taylor expanded in t around inf 60.5%
associate-/l*72.6%
+-commutative72.6%
Simplified72.6%
Taylor expanded in y around inf 52.6%
associate-/l*59.7%
Simplified59.7%
if -6.00000000000000001e164 < t < 3.20000000000000005e152Initial program 62.1%
Taylor expanded in y around inf 63.3%
Final simplification62.3%
(FPCore (x y z t a b) :precision binary64 (if (<= t -5e+161) (+ a (/ y (/ t z))) (if (<= t 5.5e+182) (- (+ z a) b) (+ a (/ z (/ t x))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -5e+161) {
tmp = a + (y / (t / z));
} else if (t <= 5.5e+182) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
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 <= (-5d+161)) then
tmp = a + (y / (t / z))
else if (t <= 5.5d+182) then
tmp = (z + a) - b
else
tmp = a + (z / (t / x))
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 <= -5e+161) {
tmp = a + (y / (t / z));
} else if (t <= 5.5e+182) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -5e+161: tmp = a + (y / (t / z)) elif t <= 5.5e+182: tmp = (z + a) - b else: tmp = a + (z / (t / x)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -5e+161) tmp = Float64(a + Float64(y / Float64(t / z))); elseif (t <= 5.5e+182) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a + Float64(z / Float64(t / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -5e+161) tmp = a + (y / (t / z)); elseif (t <= 5.5e+182) tmp = (z + a) - b; else tmp = a + (z / (t / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -5e+161], N[(a + N[(y / N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e+182], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a + N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5 \cdot 10^{+161}:\\
\;\;\;\;a + \frac{y}{\frac{t}{z}}\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{+182}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x}}\\
\end{array}
\end{array}
if t < -4.9999999999999997e161Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 57.9%
associate-/l*70.1%
+-commutative70.1%
Simplified70.1%
Taylor expanded in y around inf 49.7%
associate-/l*59.0%
Simplified59.0%
if -4.9999999999999997e161 < t < 5.49999999999999977e182Initial program 61.2%
Taylor expanded in y around inf 63.2%
if 5.49999999999999977e182 < t Initial program 47.2%
Taylor expanded in z around 0 59.9%
associate--l+59.9%
associate-+r+59.9%
associate-+r+59.9%
div-sub60.0%
*-commutative60.0%
associate-+r+60.0%
Simplified60.0%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 60.0%
associate-/l*73.8%
+-commutative73.8%
Simplified73.8%
Taylor expanded in y around 0 63.3%
Final simplification62.7%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.58e+165) (+ a (/ z (/ t y))) (if (<= t 7.6e+182) (- (+ z a) b) (+ a (/ z (/ t x))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.58e+165) {
tmp = a + (z / (t / y));
} else if (t <= 7.6e+182) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
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.58d+165)) then
tmp = a + (z / (t / y))
else if (t <= 7.6d+182) then
tmp = (z + a) - b
else
tmp = a + (z / (t / x))
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.58e+165) {
tmp = a + (z / (t / y));
} else if (t <= 7.6e+182) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.58e+165: tmp = a + (z / (t / y)) elif t <= 7.6e+182: tmp = (z + a) - b else: tmp = a + (z / (t / x)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.58e+165) tmp = Float64(a + Float64(z / Float64(t / y))); elseif (t <= 7.6e+182) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a + Float64(z / Float64(t / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.58e+165) tmp = a + (z / (t / y)); elseif (t <= 7.6e+182) tmp = (z + a) - b; else tmp = a + (z / (t / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.58e+165], N[(a + N[(z / N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.6e+182], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a + N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.58 \cdot 10^{+165}:\\
\;\;\;\;a + \frac{z}{\frac{t}{y}}\\
\mathbf{elif}\;t \leq 7.6 \cdot 10^{+182}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x}}\\
\end{array}
\end{array}
if t < -1.58000000000000007e165Initial program 42.3%
Taylor expanded in z around 0 55.4%
associate--l+55.4%
associate-+r+55.4%
associate-+r+55.4%
div-sub55.4%
*-commutative55.4%
associate-+r+55.4%
Simplified55.4%
Taylor expanded in t around inf 76.5%
Taylor expanded in t around inf 57.9%
associate-/l*70.1%
+-commutative70.1%
Simplified70.1%
Taylor expanded in y around inf 59.0%
if -1.58000000000000007e165 < t < 7.60000000000000025e182Initial program 61.2%
Taylor expanded in y around inf 63.2%
if 7.60000000000000025e182 < t Initial program 47.2%
Taylor expanded in z around 0 59.9%
associate--l+59.9%
associate-+r+59.9%
associate-+r+59.9%
div-sub60.0%
*-commutative60.0%
associate-+r+60.0%
Simplified60.0%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 60.0%
associate-/l*73.8%
+-commutative73.8%
Simplified73.8%
Taylor expanded in y around 0 63.3%
Final simplification62.7%
(FPCore (x y z t a b) :precision binary64 (if (<= t -1.06e+117) (/ a (+ 1.0 (/ x t))) (if (<= t 1.95e+183) (- (+ z a) b) (+ a (/ z (/ t x))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -1.06e+117) {
tmp = a / (1.0 + (x / t));
} else if (t <= 1.95e+183) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
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.06d+117)) then
tmp = a / (1.0d0 + (x / t))
else if (t <= 1.95d+183) then
tmp = (z + a) - b
else
tmp = a + (z / (t / x))
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.06e+117) {
tmp = a / (1.0 + (x / t));
} else if (t <= 1.95e+183) {
tmp = (z + a) - b;
} else {
tmp = a + (z / (t / x));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -1.06e+117: tmp = a / (1.0 + (x / t)) elif t <= 1.95e+183: tmp = (z + a) - b else: tmp = a + (z / (t / x)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -1.06e+117) tmp = Float64(a / Float64(1.0 + Float64(x / t))); elseif (t <= 1.95e+183) tmp = Float64(Float64(z + a) - b); else tmp = Float64(a + Float64(z / Float64(t / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -1.06e+117) tmp = a / (1.0 + (x / t)); elseif (t <= 1.95e+183) tmp = (z + a) - b; else tmp = a + (z / (t / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -1.06e+117], N[(a / N[(1.0 + N[(x / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.95e+183], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], N[(a + N[(z / N[(t / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.06 \cdot 10^{+117}:\\
\;\;\;\;\frac{a}{1 + \frac{x}{t}}\\
\mathbf{elif}\;t \leq 1.95 \cdot 10^{+183}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;a + \frac{z}{\frac{t}{x}}\\
\end{array}
\end{array}
if t < -1.06e117Initial program 42.0%
Taylor expanded in a around inf 26.0%
associate-/l*62.7%
associate-+r+62.7%
Simplified62.7%
Taylor expanded in t around inf 60.4%
if -1.06e117 < t < 1.9499999999999999e183Initial program 62.0%
Taylor expanded in y around inf 64.2%
if 1.9499999999999999e183 < t Initial program 47.2%
Taylor expanded in z around 0 59.9%
associate--l+59.9%
associate-+r+59.9%
associate-+r+59.9%
div-sub60.0%
*-commutative60.0%
associate-+r+60.0%
Simplified60.0%
Taylor expanded in t around inf 80.3%
Taylor expanded in t around inf 60.0%
associate-/l*73.8%
+-commutative73.8%
Simplified73.8%
Taylor expanded in y around 0 63.3%
Final simplification63.5%
(FPCore (x y z t a b) :precision binary64 (if (<= x -2.1e+119) (+ z a) (if (<= x 7e+190) (- (+ z a) b) z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -2.1e+119) {
tmp = z + a;
} else if (x <= 7e+190) {
tmp = (z + a) - b;
} else {
tmp = 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) :: tmp
if (x <= (-2.1d+119)) then
tmp = z + a
else if (x <= 7d+190) then
tmp = (z + a) - b
else
tmp = z
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 (x <= -2.1e+119) {
tmp = z + a;
} else if (x <= 7e+190) {
tmp = (z + a) - b;
} else {
tmp = z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -2.1e+119: tmp = z + a elif x <= 7e+190: tmp = (z + a) - b else: tmp = z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -2.1e+119) tmp = Float64(z + a); elseif (x <= 7e+190) tmp = Float64(Float64(z + a) - b); else tmp = z; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -2.1e+119) tmp = z + a; elseif (x <= 7e+190) tmp = (z + a) - b; else tmp = z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -2.1e+119], N[(z + a), $MachinePrecision], If[LessEqual[x, 7e+190], N[(N[(z + a), $MachinePrecision] - b), $MachinePrecision], z]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.1 \cdot 10^{+119}:\\
\;\;\;\;z + a\\
\mathbf{elif}\;x \leq 7 \cdot 10^{+190}:\\
\;\;\;\;\left(z + a\right) - b\\
\mathbf{else}:\\
\;\;\;\;z\\
\end{array}
\end{array}
if x < -2.09999999999999983e119Initial program 49.0%
Taylor expanded in z around 0 70.7%
associate--l+70.7%
associate-+r+70.7%
associate-+r+70.7%
div-sub70.7%
*-commutative70.7%
associate-+r+70.7%
Simplified70.7%
Taylor expanded in t around inf 57.9%
Taylor expanded in x around inf 45.0%
if -2.09999999999999983e119 < x < 6.9999999999999997e190Initial program 60.6%
Taylor expanded in y around inf 63.4%
if 6.9999999999999997e190 < x Initial program 45.3%
Taylor expanded in x around inf 63.1%
Final simplification59.6%
(FPCore (x y z t a b) :precision binary64 (if (or (<= y -1.55e+231) (not (<= y 8.2e+219))) (- a b) (+ z a)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((y <= -1.55e+231) || !(y <= 8.2e+219)) {
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 ((y <= (-1.55d+231)) .or. (.not. (y <= 8.2d+219))) 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 ((y <= -1.55e+231) || !(y <= 8.2e+219)) {
tmp = a - b;
} else {
tmp = z + a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (y <= -1.55e+231) or not (y <= 8.2e+219): tmp = a - b else: tmp = z + a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if ((y <= -1.55e+231) || !(y <= 8.2e+219)) 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 ((y <= -1.55e+231) || ~((y <= 8.2e+219))) tmp = a - b; else tmp = z + a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[Or[LessEqual[y, -1.55e+231], N[Not[LessEqual[y, 8.2e+219]], $MachinePrecision]], N[(a - b), $MachinePrecision], N[(z + a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.55 \cdot 10^{+231} \lor \neg \left(y \leq 8.2 \cdot 10^{+219}\right):\\
\;\;\;\;a - b\\
\mathbf{else}:\\
\;\;\;\;z + a\\
\end{array}
\end{array}
if y < -1.54999999999999995e231 or 8.1999999999999996e219 < y Initial program 20.5%
Taylor expanded in z around 0 33.7%
associate--l+33.7%
associate-+r+33.7%
associate-+r+33.7%
div-sub33.7%
*-commutative33.7%
associate-+r+33.7%
Simplified33.7%
Taylor expanded in x around inf 28.5%
Taylor expanded in z around 0 20.2%
div-sub20.2%
*-commutative20.2%
+-commutative20.2%
*-commutative20.2%
+-commutative20.2%
Simplified20.2%
Taylor expanded in y around inf 77.4%
if -1.54999999999999995e231 < y < 8.1999999999999996e219Initial program 62.9%
Taylor expanded in z around 0 76.3%
associate--l+76.3%
associate-+r+76.3%
associate-+r+76.3%
div-sub76.3%
*-commutative76.3%
associate-+r+76.3%
Simplified76.3%
Taylor expanded in t around inf 68.8%
Taylor expanded in x around inf 54.7%
Final simplification57.9%
(FPCore (x y z t a b) :precision binary64 (if (<= x -6.5e+23) z (if (<= x 1.2e+76) a z)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (x <= -6.5e+23) {
tmp = z;
} else if (x <= 1.2e+76) {
tmp = a;
} else {
tmp = 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) :: tmp
if (x <= (-6.5d+23)) then
tmp = z
else if (x <= 1.2d+76) then
tmp = a
else
tmp = z
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 (x <= -6.5e+23) {
tmp = z;
} else if (x <= 1.2e+76) {
tmp = a;
} else {
tmp = z;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if x <= -6.5e+23: tmp = z elif x <= 1.2e+76: tmp = a else: tmp = z return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (x <= -6.5e+23) tmp = z; elseif (x <= 1.2e+76) tmp = a; else tmp = z; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (x <= -6.5e+23) tmp = z; elseif (x <= 1.2e+76) tmp = a; else tmp = z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[x, -6.5e+23], z, If[LessEqual[x, 1.2e+76], a, z]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -6.5 \cdot 10^{+23}:\\
\;\;\;\;z\\
\mathbf{elif}\;x \leq 1.2 \cdot 10^{+76}:\\
\;\;\;\;a\\
\mathbf{else}:\\
\;\;\;\;z\\
\end{array}
\end{array}
if x < -6.4999999999999996e23 or 1.2e76 < x Initial program 49.3%
Taylor expanded in x around inf 47.0%
if -6.4999999999999996e23 < x < 1.2e76Initial program 63.9%
Taylor expanded in t around inf 50.7%
Final simplification48.9%
(FPCore (x y z t a b) :precision binary64 (+ z a))
double code(double x, double y, double z, double t, double a, double b) {
return z + 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 = z + a
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return z + a;
}
def code(x, y, z, t, a, b): return z + a
function code(x, y, z, t, a, b) return Float64(z + a) end
function tmp = code(x, y, z, t, a, b) tmp = z + a; end
code[x_, y_, z_, t_, a_, b_] := N[(z + a), $MachinePrecision]
\begin{array}{l}
\\
z + a
\end{array}
Initial program 57.0%
Taylor expanded in z around 0 70.3%
associate--l+70.3%
associate-+r+70.3%
associate-+r+70.3%
div-sub70.3%
*-commutative70.3%
associate-+r+70.3%
Simplified70.3%
Taylor expanded in t around inf 66.1%
Taylor expanded in x around inf 53.3%
Final simplification53.3%
(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 57.0%
Taylor expanded in t around inf 32.9%
Final simplification32.9%
(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 2023322
(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)))