
(FPCore (x y z t a b c i) :precision binary64 (/ (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}
def code(x, y, z, t, a, b, c, i): return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
function code(x, y, z, t, a, b, c, i) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i) :precision binary64 (/ (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
code = ((((((((x * y) + z) * y) + 27464.7644705d0) * y) + 230661.510616d0) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i);
}
def code(x, y, z, t, a, b, c, i): return ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i)
function code(x, y, z, t, a, b, c, i) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / Float64(Float64(Float64(Float64(Float64(Float64(Float64(y + a) * y) + b) * y) + c) * y) + i)) end
function tmp = code(x, y, z, t, a, b, c, i) tmp = ((((((((x * y) + z) * y) + 27464.7644705) * y) + 230661.510616) * y) + t) / (((((((y + a) * y) + b) * y) + c) * y) + i); end
code[x_, y_, z_, t_, a_, b_, c_, i_] := N[(N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision] * y), $MachinePrecision] + 27464.7644705), $MachinePrecision] * y), $MachinePrecision] + 230661.510616), $MachinePrecision] * y), $MachinePrecision] + t), $MachinePrecision] / N[(N[(N[(N[(N[(N[(N[(y + a), $MachinePrecision] * y), $MachinePrecision] + b), $MachinePrecision] * y), $MachinePrecision] + c), $MachinePrecision] * y), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\left(\left(x \cdot y + z\right) \cdot y + 27464.7644705\right) \cdot y + 230661.510616\right) \cdot y + t}{\left(\left(\left(y + a\right) \cdot y + b\right) \cdot y + c\right) \cdot y + i}
\end{array}
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)) (t_2 (+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i)))
(if (<= y -6.2e+48)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 5.3e+45)
(+
(/ t t_2)
(/
(* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x)))))))
t_2))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double t_2 = (y * (c + (y * ((y * (y + a)) + b)))) + i;
double tmp;
if (y <= -6.2e+48) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 5.3e+45) {
tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * a) / y
t_2 = (y * (c + (y * ((y * (y + a)) + b)))) + i
if (y <= (-6.2d+48)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 5.3d+45) then
tmp = (t / t_2) + ((y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x))))))) / t_2)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double t_2 = (y * (c + (y * ((y * (y + a)) + b)))) + i;
double tmp;
if (y <= -6.2e+48) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 5.3e+45) {
tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y t_2 = (y * (c + (y * ((y * (y + a)) + b)))) + i tmp = 0 if y <= -6.2e+48: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 5.3e+45: tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) t_2 = Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i) tmp = 0.0 if (y <= -6.2e+48) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 5.3e+45) tmp = Float64(Float64(t / t_2) + Float64(Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x))))))) / t_2)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; t_2 = (y * (c + (y * ((y * (y + a)) + b)))) + i; tmp = 0.0; if (y <= -6.2e+48) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 5.3e+45) tmp = (t / t_2) + ((y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x))))))) / t_2); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]}, If[LessEqual[y, -6.2e+48], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.3e+45], N[(N[(t / t$95$2), $MachinePrecision] + N[(N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
t_2 := y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i\\
\mathbf{if}\;y \leq -6.2 \cdot 10^{+48}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{+45}:\\
\;\;\;\;\frac{t}{t_2} + \frac{y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{t_2}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -6.20000000000000011e48Initial program 0.6%
Taylor expanded in y around inf 52.2%
associate--l+52.2%
+-commutative52.2%
associate-*r/52.2%
metadata-eval52.2%
unpow252.2%
associate-/l*55.8%
unpow255.8%
associate-/l*55.7%
unpow255.7%
Simplified55.7%
Taylor expanded in y around inf 62.9%
if -6.20000000000000011e48 < y < 5.29999999999999991e45Initial program 95.0%
Taylor expanded in t around inf 95.0%
if 5.29999999999999991e45 < y Initial program 3.9%
Taylor expanded in y around inf 75.0%
Final simplification83.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.02e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 1.14e+46)
(/
(+
t
(* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.02e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 1.14e+46) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.02d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 1.14d+46) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.02e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 1.14e+46) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.02e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 1.14e+46: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.02e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 1.14e+46) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.02e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 1.14e+46) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.02e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.14e+46], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.02 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 1.14 \cdot 10^{+46}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.02e49Initial program 0.6%
Taylor expanded in y around inf 52.2%
associate--l+52.2%
+-commutative52.2%
associate-*r/52.2%
metadata-eval52.2%
unpow252.2%
associate-/l*55.8%
unpow255.8%
associate-/l*55.7%
unpow255.7%
Simplified55.7%
Taylor expanded in y around inf 62.9%
if -1.02e49 < y < 1.14000000000000005e46Initial program 95.0%
if 1.14000000000000005e46 < y Initial program 3.9%
Taylor expanded in y around inf 75.0%
Final simplification83.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.7e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 5.4e+43)
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* x (* y y)))))))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.7e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 5.4e+43) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (x * (y * y))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.7d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 5.4d+43) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (x * (y * y))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.7e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 5.4e+43) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (x * (y * y))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.7e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 5.4e+43: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (x * (y * y))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.7e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 5.4e+43) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(x * Float64(y * y))))))) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.7e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 5.4e+43) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (x * (y * y))))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.7e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.4e+43], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.7 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 5.4 \cdot 10^{+43}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + x \cdot \left(y \cdot y\right)\right)\right)}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.7e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.7e49 < y < 5.4000000000000004e43Initial program 94.3%
Taylor expanded in x around inf 88.5%
*-commutative88.5%
unpow288.5%
Simplified88.5%
if 5.4000000000000004e43 < y Initial program 3.9%
Taylor expanded in y around inf 75.0%
Final simplification79.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2.5e+32)
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2.5d+32) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2.5e+32: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2.5e+32) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2.5e+32) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e+32], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -9.99999999999999946e48Initial program 0.6%
Taylor expanded in y around inf 52.2%
associate--l+52.2%
+-commutative52.2%
associate-*r/52.2%
metadata-eval52.2%
unpow252.2%
associate-/l*55.8%
unpow255.8%
associate-/l*55.7%
unpow255.7%
Simplified55.7%
Taylor expanded in y around inf 62.9%
if -9.99999999999999946e48 < y < 2.4999999999999999e32Initial program 95.5%
Taylor expanded in x around 0 88.1%
if 2.4999999999999999e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification78.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -5.2e+48)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2.5e+32)
(/
(+ t (* y (+ 230661.510616 (* z (* y y)))))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -5.2e+48) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (z * (y * y))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-5.2d+48)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2.5d+32) then
tmp = (t + (y * (230661.510616d0 + (z * (y * y))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -5.2e+48) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (z * (y * y))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -5.2e+48: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2.5e+32: tmp = (t + (y * (230661.510616 + (z * (y * y))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -5.2e+48) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2.5e+32) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(z * Float64(y * y))))) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -5.2e+48) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2.5e+32) tmp = (t + (y * (230661.510616 + (z * (y * y))))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -5.2e+48], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e+32], N[(N[(t + N[(y * N[(230661.510616 + N[(z * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -5.2 \cdot 10^{+48}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + z \cdot \left(y \cdot y\right)\right)}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -5.1999999999999999e48Initial program 0.6%
Taylor expanded in y around inf 52.2%
associate--l+52.2%
+-commutative52.2%
associate-*r/52.2%
metadata-eval52.2%
unpow252.2%
associate-/l*55.8%
unpow255.8%
associate-/l*55.7%
unpow255.7%
Simplified55.7%
Taylor expanded in y around inf 62.9%
if -5.1999999999999999e48 < y < 2.4999999999999999e32Initial program 95.5%
Taylor expanded in z around inf 87.2%
*-commutative87.2%
unpow287.2%
Simplified87.2%
if 2.4999999999999999e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification78.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.5e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2e+32)
(/
(+ t (* y (+ 230661.510616 (* y 27464.7644705))))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2e+32) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.5d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2d+32) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2e+32) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.5e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2e+32: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.5e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2e+32) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.5e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2e+32) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.5e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2e+32], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+32}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.5000000000000001e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.5000000000000001e49 < y < 2.00000000000000011e32Initial program 94.8%
Taylor expanded in y around 0 82.1%
*-commutative82.1%
Simplified82.1%
if 2.00000000000000011e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification75.8%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.6e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 1.95e+32)
(/
(+ t (* y 230661.510616))
(+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.6e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 1.95e+32) {
tmp = (t + (y * 230661.510616)) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.6d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 1.95d+32) then
tmp = (t + (y * 230661.510616d0)) / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.6e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 1.95e+32) {
tmp = (t + (y * 230661.510616)) / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.6e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 1.95e+32: tmp = (t + (y * 230661.510616)) / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.6e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 1.95e+32) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.6e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 1.95e+32) tmp = (t + (y * 230661.510616)) / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.6e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.95e+32], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.6 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{+32}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.60000000000000007e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.60000000000000007e49 < y < 1.95e32Initial program 94.8%
Taylor expanded in y around 0 81.5%
*-commutative81.5%
Simplified81.5%
if 1.95e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification75.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.75e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2.5e+32)
(/
(+ t (* y (+ 230661.510616 (* y 27464.7644705))))
(+ i (* y (+ c (* y b)))))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.75e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))));
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.75d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2.5d+32) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / (i + (y * (c + (y * b))))
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.75e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.5e+32) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b))));
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.75e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2.5e+32: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b)))) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.75e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2.5e+32) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(i + Float64(y * Float64(c + Float64(y * b))))); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.75e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2.5e+32) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / (i + (y * (c + (y * b)))); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.75e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e+32], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.75 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{i + y \cdot \left(c + y \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.74999999999999987e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.74999999999999987e49 < y < 2.4999999999999999e32Initial program 94.8%
Taylor expanded in x around 0 87.5%
Taylor expanded in y around 0 77.9%
Taylor expanded in z around 0 74.9%
if 2.4999999999999999e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification71.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.5e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2.05e+32)
(/ t (+ (* y (+ c (* y (+ (* y (+ y a)) b)))) i))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.05e+32) {
tmp = t / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.5d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2.05d+32) then
tmp = t / ((y * (c + (y * ((y * (y + a)) + b)))) + i)
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.05e+32) {
tmp = t / ((y * (c + (y * ((y * (y + a)) + b)))) + i);
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.5e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2.05e+32: tmp = t / ((y * (c + (y * ((y * (y + a)) + b)))) + i) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.5e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2.05e+32) tmp = Float64(t / Float64(Float64(y * Float64(c + Float64(y * Float64(Float64(y * Float64(y + a)) + b)))) + i)); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.5e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2.05e+32) tmp = t / ((y * (c + (y * ((y * (y + a)) + b)))) + i); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.5e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.05e+32], N[(t / N[(N[(y * N[(c + N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2.05 \cdot 10^{+32}:\\
\;\;\;\;\frac{t}{y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right) + b\right)\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.5000000000000001e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.5000000000000001e49 < y < 2.0499999999999999e32Initial program 94.8%
Taylor expanded in t around inf 67.3%
if 2.0499999999999999e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification67.8%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -1.35e+49) (not (<= y 1.35e+31))) (- (+ (/ z y) x) (/ (* x a) y)) (/ t (+ i (* y (+ c (* y (* y (+ y a)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.35e+49) || !(y <= 1.35e+31)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + (y * (y * (y + a))))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((y <= (-1.35d+49)) .or. (.not. (y <= 1.35d+31))) then
tmp = ((z / y) + x) - ((x * a) / y)
else
tmp = t / (i + (y * (c + (y * (y * (y + a))))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.35e+49) || !(y <= 1.35e+31)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + (y * (y * (y + a))))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -1.35e+49) or not (y <= 1.35e+31): tmp = ((z / y) + x) - ((x * a) / y) else: tmp = t / (i + (y * (c + (y * (y * (y + a)))))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -1.35e+49) || !(y <= 1.35e+31)) tmp = Float64(Float64(Float64(z / y) + x) - Float64(Float64(x * a) / y)); else tmp = Float64(t / Float64(i + Float64(y * Float64(c + Float64(y * Float64(y * Float64(y + a))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -1.35e+49) || ~((y <= 1.35e+31))) tmp = ((z / y) + x) - ((x * a) / y); else tmp = t / (i + (y * (c + (y * (y * (y + a)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -1.35e+49], N[Not[LessEqual[y, 1.35e+31]], $MachinePrecision]], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(t / N[(i + N[(y * N[(c + N[(y * N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.35 \cdot 10^{+49} \lor \neg \left(y \leq 1.35 \cdot 10^{+31}\right):\\
\;\;\;\;\left(\frac{z}{y} + x\right) - \frac{x \cdot a}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{i + y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right)\right)\right)}\\
\end{array}
\end{array}
if y < -1.35000000000000005e49 or 1.34999999999999993e31 < y Initial program 4.0%
Taylor expanded in y around inf 67.0%
if -1.35000000000000005e49 < y < 1.34999999999999993e31Initial program 94.8%
Taylor expanded in t around inf 67.3%
Taylor expanded in b around 0 63.2%
*-commutative63.2%
+-commutative63.2%
*-commutative63.2%
unpow263.2%
+-commutative63.2%
associate-*r*63.2%
Simplified63.2%
Final simplification65.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ (* x a) y)))
(if (<= y -1.5e+49)
(+ (/ z y) (- (+ x (/ 27464.7644705 (* y y))) t_1))
(if (<= y 2.2e+32)
(/ t (+ i (* y (+ c (* y (* y (+ y a)))))))
(- (+ (/ z y) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.2e+32) {
tmp = t / (i + (y * (c + (y * (y * (y + a))))));
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: t_1
real(8) :: tmp
t_1 = (x * a) / y
if (y <= (-1.5d+49)) then
tmp = (z / y) + ((x + (27464.7644705d0 / (y * y))) - t_1)
else if (y <= 2.2d+32) then
tmp = t / (i + (y * (c + (y * (y * (y + a))))))
else
tmp = ((z / y) + x) - t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (x * a) / y;
double tmp;
if (y <= -1.5e+49) {
tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1);
} else if (y <= 2.2e+32) {
tmp = t / (i + (y * (c + (y * (y * (y + a))))));
} else {
tmp = ((z / y) + x) - t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (x * a) / y tmp = 0 if y <= -1.5e+49: tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1) elif y <= 2.2e+32: tmp = t / (i + (y * (c + (y * (y * (y + a)))))) else: tmp = ((z / y) + x) - t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(x * a) / y) tmp = 0.0 if (y <= -1.5e+49) tmp = Float64(Float64(z / y) + Float64(Float64(x + Float64(27464.7644705 / Float64(y * y))) - t_1)); elseif (y <= 2.2e+32) tmp = Float64(t / Float64(i + Float64(y * Float64(c + Float64(y * Float64(y * Float64(y + a))))))); else tmp = Float64(Float64(Float64(z / y) + x) - t_1); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (x * a) / y; tmp = 0.0; if (y <= -1.5e+49) tmp = (z / y) + ((x + (27464.7644705 / (y * y))) - t_1); elseif (y <= 2.2e+32) tmp = t / (i + (y * (c + (y * (y * (y + a)))))); else tmp = ((z / y) + x) - t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -1.5e+49], N[(N[(z / y), $MachinePrecision] + N[(N[(x + N[(27464.7644705 / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.2e+32], N[(t / N[(i + N[(y * N[(c + N[(y * N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - t$95$1), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+49}:\\
\;\;\;\;\frac{z}{y} + \left(\left(x + \frac{27464.7644705}{y \cdot y}\right) - t_1\right)\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{+32}:\\
\;\;\;\;\frac{t}{i + y \cdot \left(c + y \cdot \left(y \cdot \left(y + a\right)\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{z}{y} + x\right) - t_1\\
\end{array}
\end{array}
if y < -1.5000000000000001e49Initial program 0.6%
Taylor expanded in y around inf 53.1%
associate--l+53.1%
+-commutative53.1%
associate-*r/53.1%
metadata-eval53.1%
unpow253.1%
associate-/l*56.7%
unpow256.7%
associate-/l*56.6%
unpow256.6%
Simplified56.6%
Taylor expanded in y around inf 63.9%
if -1.5000000000000001e49 < y < 2.20000000000000001e32Initial program 94.8%
Taylor expanded in t around inf 67.3%
Taylor expanded in b around 0 63.2%
*-commutative63.2%
+-commutative63.2%
*-commutative63.2%
unpow263.2%
+-commutative63.2%
associate-*r*63.2%
Simplified63.2%
if 2.20000000000000001e32 < y Initial program 7.4%
Taylor expanded in y around inf 72.9%
Final simplification65.6%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -1.3e+49) (not (<= y 2.45e+27))) (- (+ (/ z y) x) (/ (* x a) y)) (/ t (+ i (* y (+ c (* (* y y) a)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.3e+49) || !(y <= 2.45e+27)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + ((y * y) * a))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((y <= (-1.3d+49)) .or. (.not. (y <= 2.45d+27))) then
tmp = ((z / y) + x) - ((x * a) / y)
else
tmp = t / (i + (y * (c + ((y * y) * a))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.3e+49) || !(y <= 2.45e+27)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + ((y * y) * a))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -1.3e+49) or not (y <= 2.45e+27): tmp = ((z / y) + x) - ((x * a) / y) else: tmp = t / (i + (y * (c + ((y * y) * a)))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -1.3e+49) || !(y <= 2.45e+27)) tmp = Float64(Float64(Float64(z / y) + x) - Float64(Float64(x * a) / y)); else tmp = Float64(t / Float64(i + Float64(y * Float64(c + Float64(Float64(y * y) * a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -1.3e+49) || ~((y <= 2.45e+27))) tmp = ((z / y) + x) - ((x * a) / y); else tmp = t / (i + (y * (c + ((y * y) * a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -1.3e+49], N[Not[LessEqual[y, 2.45e+27]], $MachinePrecision]], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(t / N[(i + N[(y * N[(c + N[(N[(y * y), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.3 \cdot 10^{+49} \lor \neg \left(y \leq 2.45 \cdot 10^{+27}\right):\\
\;\;\;\;\left(\frac{z}{y} + x\right) - \frac{x \cdot a}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{i + y \cdot \left(c + \left(y \cdot y\right) \cdot a\right)}\\
\end{array}
\end{array}
if y < -1.29999999999999994e49 or 2.45000000000000007e27 < y Initial program 4.0%
Taylor expanded in y around inf 67.0%
if -1.29999999999999994e49 < y < 2.45000000000000007e27Initial program 94.8%
Taylor expanded in t around inf 67.3%
Taylor expanded in a around inf 63.1%
unpow263.1%
Simplified63.1%
Final simplification64.9%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -3.8e+48) (not (<= y 7e+31))) (- (+ (/ z y) x) (/ (* x a) y)) (/ t (+ i (* y c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -3.8e+48) || !(y <= 7e+31)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((y <= (-3.8d+48)) .or. (.not. (y <= 7d+31))) then
tmp = ((z / y) + x) - ((x * a) / y)
else
tmp = t / (i + (y * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -3.8e+48) || !(y <= 7e+31)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -3.8e+48) or not (y <= 7e+31): tmp = ((z / y) + x) - ((x * a) / y) else: tmp = t / (i + (y * c)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -3.8e+48) || !(y <= 7e+31)) tmp = Float64(Float64(Float64(z / y) + x) - Float64(Float64(x * a) / y)); else tmp = Float64(t / Float64(i + Float64(y * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -3.8e+48) || ~((y <= 7e+31))) tmp = ((z / y) + x) - ((x * a) / y); else tmp = t / (i + (y * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -3.8e+48], N[Not[LessEqual[y, 7e+31]], $MachinePrecision]], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(t / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+48} \lor \neg \left(y \leq 7 \cdot 10^{+31}\right):\\
\;\;\;\;\left(\frac{z}{y} + x\right) - \frac{x \cdot a}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{i + y \cdot c}\\
\end{array}
\end{array}
if y < -3.8e48 or 7e31 < y Initial program 3.9%
Taylor expanded in y around inf 66.5%
if -3.8e48 < y < 7e31Initial program 95.5%
Taylor expanded in t around inf 67.8%
Taylor expanded in y around 0 58.2%
Final simplification62.0%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -1.3e+49) (not (<= y 1.85e+32))) (- (+ (/ z y) x) (/ (* x a) y)) (/ t (+ i (* y (+ c (* y b)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.3e+49) || !(y <= 1.85e+32)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + (y * b))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if ((y <= (-1.3d+49)) .or. (.not. (y <= 1.85d+32))) then
tmp = ((z / y) + x) - ((x * a) / y)
else
tmp = t / (i + (y * (c + (y * b))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -1.3e+49) || !(y <= 1.85e+32)) {
tmp = ((z / y) + x) - ((x * a) / y);
} else {
tmp = t / (i + (y * (c + (y * b))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -1.3e+49) or not (y <= 1.85e+32): tmp = ((z / y) + x) - ((x * a) / y) else: tmp = t / (i + (y * (c + (y * b)))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -1.3e+49) || !(y <= 1.85e+32)) tmp = Float64(Float64(Float64(z / y) + x) - Float64(Float64(x * a) / y)); else tmp = Float64(t / Float64(i + Float64(y * Float64(c + Float64(y * b))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -1.3e+49) || ~((y <= 1.85e+32))) tmp = ((z / y) + x) - ((x * a) / y); else tmp = t / (i + (y * (c + (y * b)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -1.3e+49], N[Not[LessEqual[y, 1.85e+32]], $MachinePrecision]], N[(N[(N[(z / y), $MachinePrecision] + x), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], N[(t / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.3 \cdot 10^{+49} \lor \neg \left(y \leq 1.85 \cdot 10^{+32}\right):\\
\;\;\;\;\left(\frac{z}{y} + x\right) - \frac{x \cdot a}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{i + y \cdot \left(c + y \cdot b\right)}\\
\end{array}
\end{array}
if y < -1.29999999999999994e49 or 1.85e32 < y Initial program 4.0%
Taylor expanded in y around inf 67.0%
if -1.29999999999999994e49 < y < 1.85e32Initial program 94.8%
Taylor expanded in x around 0 87.5%
Taylor expanded in y around 0 77.9%
Taylor expanded in t around inf 61.8%
Final simplification64.2%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -1.6e+35) x (if (<= y 4.4e-8) (/ t (+ i (* y c))) x)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -1.6e+35) {
tmp = x;
} else if (y <= 4.4e-8) {
tmp = t / (i + (y * c));
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (y <= (-1.6d+35)) then
tmp = x
else if (y <= 4.4d-8) then
tmp = t / (i + (y * c))
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -1.6e+35) {
tmp = x;
} else if (y <= 4.4e-8) {
tmp = t / (i + (y * c));
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -1.6e+35: tmp = x elif y <= 4.4e-8: tmp = t / (i + (y * c)) else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -1.6e+35) tmp = x; elseif (y <= 4.4e-8) tmp = Float64(t / Float64(i + Float64(y * c))); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -1.6e+35) tmp = x; elseif (y <= 4.4e-8) tmp = t / (i + (y * c)); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -1.6e+35], x, If[LessEqual[y, 4.4e-8], N[(t / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.6 \cdot 10^{+35}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 4.4 \cdot 10^{-8}:\\
\;\;\;\;\frac{t}{i + y \cdot c}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -1.59999999999999991e35 or 4.3999999999999997e-8 < y Initial program 9.9%
Taylor expanded in y around inf 47.9%
if -1.59999999999999991e35 < y < 4.3999999999999997e-8Initial program 97.4%
Taylor expanded in t around inf 71.8%
Taylor expanded in y around 0 62.9%
Final simplification55.3%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -2.3e+21) x (if (<= y 3e-8) (/ t i) x)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -2.3e+21) {
tmp = x;
} else if (y <= 3e-8) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (y <= (-2.3d+21)) then
tmp = x
else if (y <= 3d-8) then
tmp = t / i
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -2.3e+21) {
tmp = x;
} else if (y <= 3e-8) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -2.3e+21: tmp = x elif y <= 3e-8: tmp = t / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -2.3e+21) tmp = x; elseif (y <= 3e-8) tmp = Float64(t / i); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -2.3e+21) tmp = x; elseif (y <= 3e-8) tmp = t / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -2.3e+21], x, If[LessEqual[y, 3e-8], N[(t / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.3 \cdot 10^{+21}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-8}:\\
\;\;\;\;\frac{t}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -2.3e21 or 2.99999999999999973e-8 < y Initial program 10.4%
Taylor expanded in y around inf 46.9%
if -2.3e21 < y < 2.99999999999999973e-8Initial program 98.9%
Taylor expanded in y around 0 51.7%
Final simplification49.2%
(FPCore (x y z t a b c i) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return x;
}
real(8) function code(x, y, z, t, a, b, c, i)
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), intent (in) :: c
real(8), intent (in) :: i
code = x
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
return x;
}
def code(x, y, z, t, a, b, c, i): return x
function code(x, y, z, t, a, b, c, i) return x end
function tmp = code(x, y, z, t, a, b, c, i) tmp = x; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 53.3%
Taylor expanded in y around inf 25.8%
Final simplification25.8%
herbie shell --seed 2023274
(FPCore (x y z t a b c i)
:name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2"
:precision binary64
(/ (+ (* (+ (* (+ (* (+ (* x y) z) y) 27464.7644705) y) 230661.510616) y) t) (+ (* (+ (* (+ (* (+ y a) y) b) y) c) y) i)))