
(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 19 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
(+
(* y (+ (* y (+ (* y (+ z (* x y))) 27464.7644705)) 230661.510616))
t))
(t_2 (* y (+ y a))))
(if (<= (/ t_1 (+ (* y (+ (* y (+ b t_2)) c)) i)) 5e+291)
(/ t_1 (+ i (* y (+ c (+ (* y t_2) (* y b))))))
(+ x (- (/ z y) (* a (/ x y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t;
double t_2 = y * (y + a);
double tmp;
if ((t_1 / ((y * ((y * (b + t_2)) + c)) + i)) <= 5e+291) {
tmp = t_1 / (i + (y * (c + ((y * t_2) + (y * b)))));
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
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 = (y * ((y * ((y * (z + (x * y))) + 27464.7644705d0)) + 230661.510616d0)) + t
t_2 = y * (y + a)
if ((t_1 / ((y * ((y * (b + t_2)) + c)) + i)) <= 5d+291) then
tmp = t_1 / (i + (y * (c + ((y * t_2) + (y * b)))))
else
tmp = x + ((z / y) - (a * (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 c, double i) {
double t_1 = (y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t;
double t_2 = y * (y + a);
double tmp;
if ((t_1 / ((y * ((y * (b + t_2)) + c)) + i)) <= 5e+291) {
tmp = t_1 / (i + (y * (c + ((y * t_2) + (y * b)))));
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t t_2 = y * (y + a) tmp = 0 if (t_1 / ((y * ((y * (b + t_2)) + c)) + i)) <= 5e+291: tmp = t_1 / (i + (y * (c + ((y * t_2) + (y * b))))) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(z + Float64(x * y))) + 27464.7644705)) + 230661.510616)) + t) t_2 = Float64(y * Float64(y + a)) tmp = 0.0 if (Float64(t_1 / Float64(Float64(y * Float64(Float64(y * Float64(b + t_2)) + c)) + i)) <= 5e+291) tmp = Float64(t_1 / Float64(i + Float64(y * Float64(c + Float64(Float64(y * t_2) + Float64(y * b)))))); else tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t; t_2 = y * (y + a); tmp = 0.0; if ((t_1 / ((y * ((y * (b + t_2)) + c)) + i)) <= 5e+291) tmp = t_1 / (i + (y * (c + ((y * t_2) + (y * b))))); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(y * N[(N[(y * N[(N[(y * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$1 / N[(N[(y * N[(N[(y * N[(b + t$95$2), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], 5e+291], N[(t$95$1 / N[(i + N[(y * N[(c + N[(N[(y * t$95$2), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot \left(y \cdot \left(z + x \cdot y\right) + 27464.7644705\right) + 230661.510616\right) + t\\
t_2 := y \cdot \left(y + a\right)\\
\mathbf{if}\;\frac{t\_1}{y \cdot \left(y \cdot \left(b + t\_2\right) + c\right) + i} \leq 5 \cdot 10^{+291}:\\
\;\;\;\;\frac{t\_1}{i + y \cdot \left(c + \left(y \cdot t\_2 + y \cdot b\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x y) z) y) #s(literal 54929528941/2000000 binary64)) y) #s(literal 28832688827/125000 binary64)) y) t) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 y a) y) b) y) c) y) i)) < 5.0000000000000001e291Initial program 90.3%
*-commutative90.3%
distribute-rgt-in90.3%
*-commutative90.3%
Applied egg-rr90.3%
if 5.0000000000000001e291 < (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x y) z) y) #s(literal 54929528941/2000000 binary64)) y) #s(literal 28832688827/125000 binary64)) y) t) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 y a) y) b) y) c) y) i)) Initial program 4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
Simplified4.1%
Taylor expanded in y around inf 69.8%
associate--l+69.8%
associate-/l*75.0%
Simplified75.0%
Final simplification84.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1
(/
(+
(* y (+ (* y (+ (* y (+ z (* x y))) 27464.7644705)) 230661.510616))
t)
(+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))))
(if (<= t_1 5e+291) t_1 (+ x (- (/ z y) (* a (/ x y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = ((y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
double tmp;
if (t_1 <= 5e+291) {
tmp = t_1;
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
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 = ((y * ((y * ((y * (z + (x * y))) + 27464.7644705d0)) + 230661.510616d0)) + t) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
if (t_1 <= 5d+291) then
tmp = t_1
else
tmp = x + ((z / y) - (a * (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 c, double i) {
double t_1 = ((y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
double tmp;
if (t_1 <= 5e+291) {
tmp = t_1;
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = ((y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) tmp = 0 if t_1 <= 5e+291: tmp = t_1 else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(z + Float64(x * y))) + 27464.7644705)) + 230661.510616)) + t) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)) tmp = 0.0 if (t_1 <= 5e+291) tmp = t_1; else tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = ((y * ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); tmp = 0.0; if (t_1 <= 5e+291) tmp = t_1; else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(N[(y * N[(N[(y * N[(N[(y * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 5e+291], t$95$1, N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y \cdot \left(y \cdot \left(y \cdot \left(z + x \cdot y\right) + 27464.7644705\right) + 230661.510616\right) + t}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\mathbf{if}\;t\_1 \leq 5 \cdot 10^{+291}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x y) z) y) #s(literal 54929528941/2000000 binary64)) y) #s(literal 28832688827/125000 binary64)) y) t) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 y a) y) b) y) c) y) i)) < 5.0000000000000001e291Initial program 90.3%
if 5.0000000000000001e291 < (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x y) z) y) #s(literal 54929528941/2000000 binary64)) y) #s(literal 28832688827/125000 binary64)) y) t) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 y a) y) b) y) c) y) i)) Initial program 4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
fma-define4.1%
Simplified4.1%
Taylor expanded in y around inf 69.8%
associate--l+69.8%
associate-/l*75.0%
Simplified75.0%
Final simplification84.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ (* y (+ b (* y (+ y a)))) c))
(t_2 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -6.5e+75)
t_2
(if (<= y -7.2e-16)
(/ (+ (* y (+ (* y (+ z (* x y))) 27464.7644705)) 230661.510616) t_1)
(if (<= y 2.7e+27)
(/ (+ t (* y (+ 230661.510616 (* y 27464.7644705)))) (+ (* y t_1) i))
t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (y * (b + (y * (y + a)))) + c;
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -6.5e+75) {
tmp = t_2;
} else if (y <= -7.2e-16) {
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / t_1;
} else if (y <= 2.7e+27) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * t_1) + i);
} else {
tmp = t_2;
}
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 = (y * (b + (y * (y + a)))) + c
t_2 = x + ((z / y) - (a * (x / y)))
if (y <= (-6.5d+75)) then
tmp = t_2
else if (y <= (-7.2d-16)) then
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705d0)) + 230661.510616d0) / t_1
else if (y <= 2.7d+27) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / ((y * t_1) + i)
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 c, double i) {
double t_1 = (y * (b + (y * (y + a)))) + c;
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -6.5e+75) {
tmp = t_2;
} else if (y <= -7.2e-16) {
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / t_1;
} else if (y <= 2.7e+27) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * t_1) + i);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * (b + (y * (y + a)))) + c t_2 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -6.5e+75: tmp = t_2 elif y <= -7.2e-16: tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / t_1 elif y <= 2.7e+27: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * t_1) + i) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c) t_2 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -6.5e+75) tmp = t_2; elseif (y <= -7.2e-16) tmp = Float64(Float64(Float64(y * Float64(Float64(y * Float64(z + Float64(x * y))) + 27464.7644705)) + 230661.510616) / t_1); elseif (y <= 2.7e+27) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(Float64(y * t_1) + i)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * (b + (y * (y + a)))) + c; t_2 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -6.5e+75) tmp = t_2; elseif (y <= -7.2e-16) tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / t_1; elseif (y <= 2.7e+27) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * t_1) + i); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.5e+75], t$95$2, If[LessEqual[y, -7.2e-16], N[(N[(N[(y * N[(N[(y * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[y, 2.7e+27], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * t$95$1), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\\
t_2 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -6.5 \cdot 10^{+75}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -7.2 \cdot 10^{-16}:\\
\;\;\;\;\frac{y \cdot \left(y \cdot \left(z + x \cdot y\right) + 27464.7644705\right) + 230661.510616}{t\_1}\\
\mathbf{elif}\;y \leq 2.7 \cdot 10^{+27}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{y \cdot t\_1 + i}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -6.4999999999999998e75 or 2.6999999999999997e27 < y Initial program 2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
Simplified2.5%
Taylor expanded in y around inf 65.9%
associate--l+65.9%
associate-/l*71.1%
Simplified71.1%
if -6.4999999999999998e75 < y < -7.19999999999999965e-16Initial program 54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
Simplified54.4%
Taylor expanded in i around 0 47.2%
Taylor expanded in t around 0 53.9%
if -7.19999999999999965e-16 < y < 2.6999999999999997e27Initial program 98.1%
Taylor expanded in y around 0 85.2%
*-commutative85.2%
Simplified85.2%
Final simplification77.0%
(FPCore (x y z t a b c i)
:precision binary64
(if (or (<= y -9.5e+74) (not (<= y 7.3e+28)))
(+ x (- (/ z y) (* a (/ x y))))
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
(+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -9.5e+74) || !(y <= 7.3e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
}
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 <= (-9.5d+74)) .or. (.not. (y <= 7.3d+28))) then
tmp = x + ((z / y) - (a * (x / y)))
else
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
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 <= -9.5e+74) || !(y <= 7.3e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -9.5e+74) or not (y <= 7.3e+28): tmp = x + ((z / y) - (a * (x / y))) else: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -9.5e+74) || !(y <= 7.3e+28)) tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); else tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -9.5e+74) || ~((y <= 7.3e+28))) tmp = x + ((z / y) - (a * (x / y))); else tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -9.5e+74], N[Not[LessEqual[y, 7.3e+28]], $MachinePrecision]], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.5 \cdot 10^{+74} \lor \neg \left(y \leq 7.3 \cdot 10^{+28}\right):\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\end{array}
\end{array}
if y < -9.5000000000000006e74 or 7.2999999999999998e28 < y Initial program 2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
Simplified2.5%
Taylor expanded in y around inf 65.9%
associate--l+65.9%
associate-/l*71.1%
Simplified71.1%
if -9.5000000000000006e74 < y < 7.2999999999999998e28Initial program 92.6%
Taylor expanded in x around 0 87.9%
Final simplification80.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (* y (+ y a))) (t_2 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -1.5e+75)
t_2
(if (<= y -5.4e-17)
(/
(+ (* y (+ (* y (+ z (* x y))) 27464.7644705)) 230661.510616)
(+ (* y (+ b t_1)) c))
(if (<= y 6.8e+28)
(/ (+ t (* y 230661.510616)) (+ i (* y (+ c (+ (* y t_1) (* y b))))))
t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = y * (y + a);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.5e+75) {
tmp = t_2;
} else if (y <= -5.4e-17) {
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / ((y * (b + t_1)) + c);
} else if (y <= 6.8e+28) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * t_1) + (y * b)))));
} else {
tmp = t_2;
}
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 = y * (y + a)
t_2 = x + ((z / y) - (a * (x / y)))
if (y <= (-1.5d+75)) then
tmp = t_2
else if (y <= (-5.4d-17)) then
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705d0)) + 230661.510616d0) / ((y * (b + t_1)) + c)
else if (y <= 6.8d+28) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + ((y * t_1) + (y * b)))))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = y * (y + a);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.5e+75) {
tmp = t_2;
} else if (y <= -5.4e-17) {
tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / ((y * (b + t_1)) + c);
} else if (y <= 6.8e+28) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * t_1) + (y * b)))));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = y * (y + a) t_2 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -1.5e+75: tmp = t_2 elif y <= -5.4e-17: tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / ((y * (b + t_1)) + c) elif y <= 6.8e+28: tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * t_1) + (y * b))))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(y * Float64(y + a)) t_2 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -1.5e+75) tmp = t_2; elseif (y <= -5.4e-17) tmp = Float64(Float64(Float64(y * Float64(Float64(y * Float64(z + Float64(x * y))) + 27464.7644705)) + 230661.510616) / Float64(Float64(y * Float64(b + t_1)) + c)); elseif (y <= 6.8e+28) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(Float64(y * t_1) + Float64(y * b)))))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = y * (y + a); t_2 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -1.5e+75) tmp = t_2; elseif (y <= -5.4e-17) tmp = ((y * ((y * (z + (x * y))) + 27464.7644705)) + 230661.510616) / ((y * (b + t_1)) + c); elseif (y <= 6.8e+28) tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * t_1) + (y * b))))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.5e+75], t$95$2, If[LessEqual[y, -5.4e-17], N[(N[(N[(y * N[(N[(y * N[(z + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision] / N[(N[(y * N[(b + t$95$1), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.8e+28], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(N[(y * t$95$1), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y + a\right)\\
t_2 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+75}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -5.4 \cdot 10^{-17}:\\
\;\;\;\;\frac{y \cdot \left(y \cdot \left(z + x \cdot y\right) + 27464.7644705\right) + 230661.510616}{y \cdot \left(b + t\_1\right) + c}\\
\mathbf{elif}\;y \leq 6.8 \cdot 10^{+28}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + \left(y \cdot t\_1 + y \cdot b\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -1.5e75 or 6.8e28 < y Initial program 2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
fma-define2.5%
Simplified2.5%
Taylor expanded in y around inf 65.9%
associate--l+65.9%
associate-/l*71.1%
Simplified71.1%
if -1.5e75 < y < -5.4000000000000002e-17Initial program 54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
fma-define54.4%
Simplified54.4%
Taylor expanded in i around 0 47.2%
Taylor expanded in t around 0 53.9%
if -5.4000000000000002e-17 < y < 6.8e28Initial program 98.1%
*-commutative98.1%
distribute-rgt-in98.1%
*-commutative98.1%
Applied egg-rr98.1%
Taylor expanded in y around 0 85.2%
*-commutative85.2%
Simplified85.2%
Final simplification77.0%
(FPCore (x y z t a b c i)
:precision binary64
(if (or (<= y -8.5e+38) (not (<= y 3.7e+28)))
(+ x (- (/ z y) (* a (/ x y))))
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
(+ i (* y (+ c (* y (+ b (* y a)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -8.5e+38) || !(y <= 3.7e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (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 <= (-8.5d+38)) .or. (.not. (y <= 3.7d+28))) then
tmp = x + ((z / y) - (a * (x / y)))
else
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / (i + (y * (c + (y * (b + (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 <= -8.5e+38) || !(y <= 3.7e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * a))))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -8.5e+38) or not (y <= 3.7e+28): tmp = x + ((z / y) - (a * (x / y))) else: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * a)))))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -8.5e+38) || !(y <= 3.7e+28)) tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); else tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * a))))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -8.5e+38) || ~((y <= 3.7e+28))) tmp = x + ((z / y) - (a * (x / y))); else tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / (i + (y * (c + (y * (b + (y * a)))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -8.5e+38], N[Not[LessEqual[y, 3.7e+28]], $MachinePrecision]], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.5 \cdot 10^{+38} \lor \neg \left(y \leq 3.7 \cdot 10^{+28}\right):\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{i + y \cdot \left(c + y \cdot \left(b + y \cdot a\right)\right)}\\
\end{array}
\end{array}
if y < -8.4999999999999997e38 or 3.6999999999999999e28 < y Initial program 3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
Simplified3.5%
Taylor expanded in y around inf 62.8%
associate--l+62.8%
associate-/l*67.7%
Simplified67.7%
if -8.4999999999999997e38 < y < 3.6999999999999999e28Initial program 96.2%
Taylor expanded in x around 0 91.3%
Taylor expanded in y around 0 88.4%
Final simplification79.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -4.6e+73)
t_1
(if (<= y -6.2e-8)
(/ (+ z (+ (/ 27464.7644705 y) (* x y))) a)
(if (<= y 700000000.0)
(/ (+ t (* y 230661.510616)) (+ i (* y (+ c (* y (+ b (* y a)))))))
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -4.6e+73) {
tmp = t_1;
} else if (y <= -6.2e-8) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= 700000000.0) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * a))))));
} else {
tmp = 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 + ((z / y) - (a * (x / y)))
if (y <= (-4.6d+73)) then
tmp = t_1
else if (y <= (-6.2d-8)) then
tmp = (z + ((27464.7644705d0 / y) + (x * y))) / a
else if (y <= 700000000.0d0) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + (y * (b + (y * a))))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -4.6e+73) {
tmp = t_1;
} else if (y <= -6.2e-8) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= 700000000.0) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * a))))));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -4.6e+73: tmp = t_1 elif y <= -6.2e-8: tmp = (z + ((27464.7644705 / y) + (x * y))) / a elif y <= 700000000.0: tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * a)))))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -4.6e+73) tmp = t_1; elseif (y <= -6.2e-8) tmp = Float64(Float64(z + Float64(Float64(27464.7644705 / y) + Float64(x * y))) / a); elseif (y <= 700000000.0) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * a))))))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -4.6e+73) tmp = t_1; elseif (y <= -6.2e-8) tmp = (z + ((27464.7644705 / y) + (x * y))) / a; elseif (y <= 700000000.0) tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * (b + (y * a)))))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.6e+73], t$95$1, If[LessEqual[y, -6.2e-8], N[(N[(z + N[(N[(27464.7644705 / y), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, 700000000.0], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -4.6 \cdot 10^{+73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{-8}:\\
\;\;\;\;\frac{z + \left(\frac{27464.7644705}{y} + x \cdot y\right)}{a}\\
\mathbf{elif}\;y \leq 700000000:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + y \cdot \left(b + y \cdot a\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -4.6e73 or 7e8 < y Initial program 8.4%
fma-define8.4%
fma-define8.4%
fma-define8.4%
fma-define8.4%
fma-define8.4%
fma-define8.4%
fma-define8.4%
Simplified8.4%
Taylor expanded in y around inf 61.9%
associate--l+61.9%
associate-/l*66.7%
Simplified66.7%
if -4.6e73 < y < -6.2e-8Initial program 45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
Simplified45.9%
Taylor expanded in x around inf 46.0%
Taylor expanded in a around inf 24.2%
Taylor expanded in y around inf 24.5%
associate-*r/24.5%
metadata-eval24.5%
+-commutative24.5%
associate-/r*24.5%
Simplified24.5%
Taylor expanded in x around 0 42.8%
associate-*r/42.8%
metadata-eval42.8%
*-commutative42.8%
Simplified42.8%
if -6.2e-8 < y < 7e8Initial program 99.6%
*-commutative99.6%
distribute-rgt-in99.6%
*-commutative99.6%
Applied egg-rr99.6%
Taylor expanded in y around 0 88.8%
*-commutative88.8%
Simplified88.8%
Taylor expanded in y around 0 88.9%
Final simplification76.0%
(FPCore (x y z t a b c i)
:precision binary64
(if (or (<= y -6.6e+38) (not (<= y 3.8e+28)))
(+ x (- (/ z y) (* a (/ x y))))
(/
(+ t (* y 230661.510616))
(+ i (* y (+ c (+ (* y (* y (+ y a))) (* y b))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -6.6e+38) || !(y <= 3.8e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * (y * (y + a))) + (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 <= (-6.6d+38)) .or. (.not. (y <= 3.8d+28))) then
tmp = x + ((z / y) - (a * (x / y)))
else
tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + ((y * (y * (y + a))) + (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 <= -6.6e+38) || !(y <= 3.8e+28)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * (y * (y + a))) + (y * b)))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -6.6e+38) or not (y <= 3.8e+28): tmp = x + ((z / y) - (a * (x / y))) else: tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * (y * (y + a))) + (y * b))))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -6.6e+38) || !(y <= 3.8e+28)) tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); else tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(Float64(y * Float64(y * Float64(y + a))) + Float64(y * b)))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -6.6e+38) || ~((y <= 3.8e+28))) tmp = x + ((z / y) - (a * (x / y))); else tmp = (t + (y * 230661.510616)) / (i + (y * (c + ((y * (y * (y + a))) + (y * b))))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -6.6e+38], N[Not[LessEqual[y, 3.8e+28]], $MachinePrecision]], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(N[(y * N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.6 \cdot 10^{+38} \lor \neg \left(y \leq 3.8 \cdot 10^{+28}\right):\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + \left(y \cdot \left(y \cdot \left(y + a\right)\right) + y \cdot b\right)\right)}\\
\end{array}
\end{array}
if y < -6.5999999999999998e38 or 3.7999999999999999e28 < y Initial program 3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
Simplified3.5%
Taylor expanded in y around inf 62.8%
associate--l+62.8%
associate-/l*67.7%
Simplified67.7%
if -6.5999999999999998e38 < y < 3.7999999999999999e28Initial program 96.2%
*-commutative96.2%
distribute-rgt-in96.3%
*-commutative96.3%
Applied egg-rr96.3%
Taylor expanded in y around 0 80.3%
*-commutative80.3%
Simplified80.3%
Final simplification74.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ t (* y 230661.510616))) (t_2 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -2.8e+73)
t_2
(if (<= y -4.8e-44)
(/ (+ z (+ (/ 27464.7644705 y) (* x y))) a)
(if (<= y -3.2e-172)
(/ t_1 (* y c))
(if (<= y 5.5e-16) (/ t_1 i) t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = t + (y * 230661.510616);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -2.8e+73) {
tmp = t_2;
} else if (y <= -4.8e-44) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= -3.2e-172) {
tmp = t_1 / (y * c);
} else if (y <= 5.5e-16) {
tmp = t_1 / i;
} else {
tmp = t_2;
}
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 = t + (y * 230661.510616d0)
t_2 = x + ((z / y) - (a * (x / y)))
if (y <= (-2.8d+73)) then
tmp = t_2
else if (y <= (-4.8d-44)) then
tmp = (z + ((27464.7644705d0 / y) + (x * y))) / a
else if (y <= (-3.2d-172)) then
tmp = t_1 / (y * c)
else if (y <= 5.5d-16) then
tmp = t_1 / i
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 c, double i) {
double t_1 = t + (y * 230661.510616);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -2.8e+73) {
tmp = t_2;
} else if (y <= -4.8e-44) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= -3.2e-172) {
tmp = t_1 / (y * c);
} else if (y <= 5.5e-16) {
tmp = t_1 / i;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = t + (y * 230661.510616) t_2 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -2.8e+73: tmp = t_2 elif y <= -4.8e-44: tmp = (z + ((27464.7644705 / y) + (x * y))) / a elif y <= -3.2e-172: tmp = t_1 / (y * c) elif y <= 5.5e-16: tmp = t_1 / i else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(t + Float64(y * 230661.510616)) t_2 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -2.8e+73) tmp = t_2; elseif (y <= -4.8e-44) tmp = Float64(Float64(z + Float64(Float64(27464.7644705 / y) + Float64(x * y))) / a); elseif (y <= -3.2e-172) tmp = Float64(t_1 / Float64(y * c)); elseif (y <= 5.5e-16) tmp = Float64(t_1 / i); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = t + (y * 230661.510616); t_2 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -2.8e+73) tmp = t_2; elseif (y <= -4.8e-44) tmp = (z + ((27464.7644705 / y) + (x * y))) / a; elseif (y <= -3.2e-172) tmp = t_1 / (y * c); elseif (y <= 5.5e-16) tmp = t_1 / i; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.8e+73], t$95$2, If[LessEqual[y, -4.8e-44], N[(N[(z + N[(N[(27464.7644705 / y), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, -3.2e-172], N[(t$95$1 / N[(y * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e-16], N[(t$95$1 / i), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot 230661.510616\\
t_2 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -2.8 \cdot 10^{+73}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{-44}:\\
\;\;\;\;\frac{z + \left(\frac{27464.7644705}{y} + x \cdot y\right)}{a}\\
\mathbf{elif}\;y \leq -3.2 \cdot 10^{-172}:\\
\;\;\;\;\frac{t\_1}{y \cdot c}\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{-16}:\\
\;\;\;\;\frac{t\_1}{i}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -2.80000000000000008e73 or 5.49999999999999964e-16 < y Initial program 12.2%
fma-define12.2%
fma-define12.2%
fma-define12.2%
fma-define12.2%
fma-define12.2%
fma-define12.2%
fma-define12.2%
Simplified12.2%
Taylor expanded in y around inf 59.5%
associate--l+59.5%
associate-/l*64.1%
Simplified64.1%
if -2.80000000000000008e73 < y < -4.80000000000000017e-44Initial program 70.7%
fma-define70.7%
fma-define70.7%
fma-define70.7%
fma-define70.7%
fma-define70.7%
fma-define70.7%
fma-define70.7%
Simplified70.7%
Taylor expanded in x around inf 54.8%
Taylor expanded in a around inf 17.1%
Taylor expanded in y around inf 15.0%
associate-*r/15.0%
metadata-eval15.0%
+-commutative15.0%
associate-/r*15.0%
Simplified15.0%
Taylor expanded in x around 0 28.1%
associate-*r/28.1%
metadata-eval28.1%
*-commutative28.1%
Simplified28.1%
if -4.80000000000000017e-44 < y < -3.2000000000000001e-172Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 96.4%
*-commutative96.4%
Simplified96.4%
Taylor expanded in c around inf 49.6%
if -3.2000000000000001e-172 < y < 5.49999999999999964e-16Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 91.9%
*-commutative91.9%
Simplified91.9%
Taylor expanded in i around inf 69.1%
Final simplification59.7%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -5.8e+35) (not (<= y 2.35e+27))) (+ x (- (/ z y) (* a (/ x y)))) (/ (+ t (* y 230661.510616)) (+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -5.8e+35) || !(y <= 2.35e+27)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
}
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 <= (-5.8d+35)) .or. (.not. (y <= 2.35d+27))) then
tmp = x + ((z / y) - (a * (x / y)))
else
tmp = (t + (y * 230661.510616d0)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
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 <= -5.8e+35) || !(y <= 2.35e+27)) {
tmp = x + ((z / y) - (a * (x / y)));
} else {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -5.8e+35) or not (y <= 2.35e+27): tmp = x + ((z / y) - (a * (x / y))) else: tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -5.8e+35) || !(y <= 2.35e+27)) tmp = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))); else tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -5.8e+35) || ~((y <= 2.35e+27))) tmp = x + ((z / y) - (a * (x / y))); else tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -5.8e+35], N[Not[LessEqual[y, 2.35e+27]], $MachinePrecision]], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.8 \cdot 10^{+35} \lor \neg \left(y \leq 2.35 \cdot 10^{+27}\right):\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\end{array}
\end{array}
if y < -5.79999999999999989e35 or 2.34999999999999988e27 < y Initial program 3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
fma-define3.5%
Simplified3.5%
Taylor expanded in y around inf 62.8%
associate--l+62.8%
associate-/l*67.7%
Simplified67.7%
if -5.79999999999999989e35 < y < 2.34999999999999988e27Initial program 96.2%
Taylor expanded in y around 0 80.3%
*-commutative80.3%
Simplified80.3%
Final simplification74.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -1.65e+73)
t_1
(if (<= y -7e-8)
(/ (+ z (+ (/ 27464.7644705 y) (* x y))) a)
(if (<= y 1.3e+28)
(/ (+ t (* y 230661.510616)) (+ i (* y (+ c (* y b)))))
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.65e+73) {
tmp = t_1;
} else if (y <= -7e-8) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= 1.3e+28) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b))));
} else {
tmp = 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 + ((z / y) - (a * (x / y)))
if (y <= (-1.65d+73)) then
tmp = t_1
else if (y <= (-7d-8)) then
tmp = (z + ((27464.7644705d0 / y) + (x * y))) / a
else if (y <= 1.3d+28) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + (y * b))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.65e+73) {
tmp = t_1;
} else if (y <= -7e-8) {
tmp = (z + ((27464.7644705 / y) + (x * y))) / a;
} else if (y <= 1.3e+28) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b))));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -1.65e+73: tmp = t_1 elif y <= -7e-8: tmp = (z + ((27464.7644705 / y) + (x * y))) / a elif y <= 1.3e+28: tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b)))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -1.65e+73) tmp = t_1; elseif (y <= -7e-8) tmp = Float64(Float64(z + Float64(Float64(27464.7644705 / y) + Float64(x * y))) / a); elseif (y <= 1.3e+28) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(y * b))))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -1.65e+73) tmp = t_1; elseif (y <= -7e-8) tmp = (z + ((27464.7644705 / y) + (x * y))) / a; elseif (y <= 1.3e+28) tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b)))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.65e+73], t$95$1, If[LessEqual[y, -7e-8], N[(N[(z + N[(N[(27464.7644705 / y), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, 1.3e+28], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -1.65 \cdot 10^{+73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -7 \cdot 10^{-8}:\\
\;\;\;\;\frac{z + \left(\frac{27464.7644705}{y} + x \cdot y\right)}{a}\\
\mathbf{elif}\;y \leq 1.3 \cdot 10^{+28}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + y \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.65000000000000015e73 or 1.3000000000000001e28 < y Initial program 3.4%
fma-define3.4%
fma-define3.4%
fma-define3.4%
fma-define3.4%
fma-define3.4%
fma-define3.4%
fma-define3.4%
Simplified3.4%
Taylor expanded in y around inf 65.3%
associate--l+65.3%
associate-/l*70.4%
Simplified70.4%
if -1.65000000000000015e73 < y < -7.00000000000000048e-8Initial program 45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
fma-define45.9%
Simplified45.9%
Taylor expanded in x around inf 46.0%
Taylor expanded in a around inf 24.2%
Taylor expanded in y around inf 24.5%
associate-*r/24.5%
metadata-eval24.5%
+-commutative24.5%
associate-/r*24.5%
Simplified24.5%
Taylor expanded in x around 0 42.8%
associate-*r/42.8%
metadata-eval42.8%
*-commutative42.8%
Simplified42.8%
if -7.00000000000000048e-8 < y < 1.3000000000000001e28Initial program 98.1%
*-commutative98.1%
distribute-rgt-in98.2%
*-commutative98.2%
Applied egg-rr98.2%
Taylor expanded in y around 0 84.6%
*-commutative84.6%
Simplified84.6%
Taylor expanded in y around 0 79.2%
Final simplification73.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -1.15e+37)
t_1
(if (<= y -8.5e-96)
(/ t (* y (+ (* y (+ b (* y (+ y a)))) c)))
(if (<= y 5.3e-15)
(/ (+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z)))))) i)
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.15e+37) {
tmp = t_1;
} else if (y <= -8.5e-96) {
tmp = t / (y * ((y * (b + (y * (y + a)))) + c));
} else if (y <= 5.3e-15) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i;
} else {
tmp = 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 + ((z / y) - (a * (x / y)))
if (y <= (-1.15d+37)) then
tmp = t_1
else if (y <= (-8.5d-96)) then
tmp = t / (y * ((y * (b + (y * (y + a)))) + c))
else if (y <= 5.3d-15) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / i
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -1.15e+37) {
tmp = t_1;
} else if (y <= -8.5e-96) {
tmp = t / (y * ((y * (b + (y * (y + a)))) + c));
} else if (y <= 5.3e-15) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -1.15e+37: tmp = t_1 elif y <= -8.5e-96: tmp = t / (y * ((y * (b + (y * (y + a)))) + c)) elif y <= 5.3e-15: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -1.15e+37) tmp = t_1; elseif (y <= -8.5e-96) tmp = Float64(t / Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c))); elseif (y <= 5.3e-15) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -1.15e+37) tmp = t_1; elseif (y <= -8.5e-96) tmp = t / (y * ((y * (b + (y * (y + a)))) + c)); elseif (y <= 5.3e-15) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.15e+37], t$95$1, If[LessEqual[y, -8.5e-96], N[(t / N[(y * N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.3e-15], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -1.15 \cdot 10^{+37}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -8.5 \cdot 10^{-96}:\\
\;\;\;\;\frac{t}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right)}\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{i}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.15000000000000001e37 or 5.3000000000000001e-15 < y Initial program 11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
Simplified11.8%
Taylor expanded in y around inf 57.5%
associate--l+57.5%
associate-/l*61.9%
Simplified61.9%
if -1.15000000000000001e37 < y < -8.49999999999999983e-96Initial program 92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
Simplified92.0%
Taylor expanded in i around 0 72.1%
Taylor expanded in t around inf 40.1%
if -8.49999999999999983e-96 < y < 5.3000000000000001e-15Initial program 99.7%
Taylor expanded in x around 0 97.9%
Taylor expanded in i around inf 66.1%
Final simplification60.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ t (* y 230661.510616))))
(if (<= y -1.35e+139)
x
(if (<= y -3.9e-44)
(/ (* y (+ x (/ z y))) a)
(if (<= y -2.8e-172) (/ t_1 (* y c)) (if (<= y 3e-15) (/ t_1 i) x))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = t + (y * 230661.510616);
double tmp;
if (y <= -1.35e+139) {
tmp = x;
} else if (y <= -3.9e-44) {
tmp = (y * (x + (z / y))) / a;
} else if (y <= -2.8e-172) {
tmp = t_1 / (y * c);
} else if (y <= 3e-15) {
tmp = t_1 / 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) :: t_1
real(8) :: tmp
t_1 = t + (y * 230661.510616d0)
if (y <= (-1.35d+139)) then
tmp = x
else if (y <= (-3.9d-44)) then
tmp = (y * (x + (z / y))) / a
else if (y <= (-2.8d-172)) then
tmp = t_1 / (y * c)
else if (y <= 3d-15) then
tmp = t_1 / 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 t_1 = t + (y * 230661.510616);
double tmp;
if (y <= -1.35e+139) {
tmp = x;
} else if (y <= -3.9e-44) {
tmp = (y * (x + (z / y))) / a;
} else if (y <= -2.8e-172) {
tmp = t_1 / (y * c);
} else if (y <= 3e-15) {
tmp = t_1 / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = t + (y * 230661.510616) tmp = 0 if y <= -1.35e+139: tmp = x elif y <= -3.9e-44: tmp = (y * (x + (z / y))) / a elif y <= -2.8e-172: tmp = t_1 / (y * c) elif y <= 3e-15: tmp = t_1 / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(t + Float64(y * 230661.510616)) tmp = 0.0 if (y <= -1.35e+139) tmp = x; elseif (y <= -3.9e-44) tmp = Float64(Float64(y * Float64(x + Float64(z / y))) / a); elseif (y <= -2.8e-172) tmp = Float64(t_1 / Float64(y * c)); elseif (y <= 3e-15) tmp = Float64(t_1 / i); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = t + (y * 230661.510616); tmp = 0.0; if (y <= -1.35e+139) tmp = x; elseif (y <= -3.9e-44) tmp = (y * (x + (z / y))) / a; elseif (y <= -2.8e-172) tmp = t_1 / (y * c); elseif (y <= 3e-15) tmp = t_1 / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.35e+139], x, If[LessEqual[y, -3.9e-44], N[(N[(y * N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, -2.8e-172], N[(t$95$1 / N[(y * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3e-15], N[(t$95$1 / i), $MachinePrecision], x]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot 230661.510616\\
\mathbf{if}\;y \leq -1.35 \cdot 10^{+139}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq -3.9 \cdot 10^{-44}:\\
\;\;\;\;\frac{y \cdot \left(x + \frac{z}{y}\right)}{a}\\
\mathbf{elif}\;y \leq -2.8 \cdot 10^{-172}:\\
\;\;\;\;\frac{t\_1}{y \cdot c}\\
\mathbf{elif}\;y \leq 3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t\_1}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -1.3499999999999999e139 or 3e-15 < y Initial program 12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
Simplified12.8%
Taylor expanded in y around inf 49.1%
if -1.3499999999999999e139 < y < -3.9000000000000002e-44Initial program 50.6%
fma-define50.6%
fma-define50.6%
fma-define50.6%
fma-define50.6%
fma-define50.6%
fma-define50.6%
fma-define50.6%
Simplified50.6%
Taylor expanded in x around inf 39.7%
Taylor expanded in a around inf 14.9%
Taylor expanded in y around inf 27.3%
if -3.9000000000000002e-44 < y < -2.80000000000000011e-172Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 96.4%
*-commutative96.4%
Simplified96.4%
Taylor expanded in c around inf 49.6%
if -2.80000000000000011e-172 < y < 3e-15Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 91.9%
*-commutative91.9%
Simplified91.9%
Taylor expanded in i around inf 69.1%
Final simplification51.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -2.8e+40)
t_1
(if (<= y -8.4e-96)
(/ t (* y (+ (* y (+ b (* y (+ y a)))) c)))
(if (<= y 5.3e-15) (/ (+ t (* y 230661.510616)) i) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -2.8e+40) {
tmp = t_1;
} else if (y <= -8.4e-96) {
tmp = t / (y * ((y * (b + (y * (y + a)))) + c));
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / i;
} else {
tmp = 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 + ((z / y) - (a * (x / y)))
if (y <= (-2.8d+40)) then
tmp = t_1
else if (y <= (-8.4d-96)) then
tmp = t / (y * ((y * (b + (y * (y + a)))) + c))
else if (y <= 5.3d-15) then
tmp = (t + (y * 230661.510616d0)) / i
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -2.8e+40) {
tmp = t_1;
} else if (y <= -8.4e-96) {
tmp = t / (y * ((y * (b + (y * (y + a)))) + c));
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -2.8e+40: tmp = t_1 elif y <= -8.4e-96: tmp = t / (y * ((y * (b + (y * (y + a)))) + c)) elif y <= 5.3e-15: tmp = (t + (y * 230661.510616)) / i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -2.8e+40) tmp = t_1; elseif (y <= -8.4e-96) tmp = Float64(t / Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c))); elseif (y <= 5.3e-15) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -2.8e+40) tmp = t_1; elseif (y <= -8.4e-96) tmp = t / (y * ((y * (b + (y * (y + a)))) + c)); elseif (y <= 5.3e-15) tmp = (t + (y * 230661.510616)) / i; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.8e+40], t$95$1, If[LessEqual[y, -8.4e-96], N[(t / N[(y * N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.3e-15], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -2.8 \cdot 10^{+40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -8.4 \cdot 10^{-96}:\\
\;\;\;\;\frac{t}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right)}\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.8000000000000001e40 or 5.3000000000000001e-15 < y Initial program 11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
Simplified11.8%
Taylor expanded in y around inf 57.5%
associate--l+57.5%
associate-/l*61.9%
Simplified61.9%
if -2.8000000000000001e40 < y < -8.40000000000000004e-96Initial program 92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
fma-define92.0%
Simplified92.0%
Taylor expanded in i around 0 72.1%
Taylor expanded in t around inf 40.1%
if -8.40000000000000004e-96 < y < 5.3000000000000001e-15Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 93.2%
*-commutative93.2%
Simplified93.2%
Taylor expanded in i around inf 64.3%
Final simplification59.4%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ t (* y 230661.510616))) (t_2 (+ x (- (/ z y) (* a (/ x y))))))
(if (<= y -4.8e+33)
t_2
(if (<= y -3.2e-172) (/ t_1 (* y c)) (if (<= y 5.3e-15) (/ t_1 i) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = t + (y * 230661.510616);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -4.8e+33) {
tmp = t_2;
} else if (y <= -3.2e-172) {
tmp = t_1 / (y * c);
} else if (y <= 5.3e-15) {
tmp = t_1 / i;
} else {
tmp = t_2;
}
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 = t + (y * 230661.510616d0)
t_2 = x + ((z / y) - (a * (x / y)))
if (y <= (-4.8d+33)) then
tmp = t_2
else if (y <= (-3.2d-172)) then
tmp = t_1 / (y * c)
else if (y <= 5.3d-15) then
tmp = t_1 / i
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 c, double i) {
double t_1 = t + (y * 230661.510616);
double t_2 = x + ((z / y) - (a * (x / y)));
double tmp;
if (y <= -4.8e+33) {
tmp = t_2;
} else if (y <= -3.2e-172) {
tmp = t_1 / (y * c);
} else if (y <= 5.3e-15) {
tmp = t_1 / i;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = t + (y * 230661.510616) t_2 = x + ((z / y) - (a * (x / y))) tmp = 0 if y <= -4.8e+33: tmp = t_2 elif y <= -3.2e-172: tmp = t_1 / (y * c) elif y <= 5.3e-15: tmp = t_1 / i else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(t + Float64(y * 230661.510616)) t_2 = Float64(x + Float64(Float64(z / y) - Float64(a * Float64(x / y)))) tmp = 0.0 if (y <= -4.8e+33) tmp = t_2; elseif (y <= -3.2e-172) tmp = Float64(t_1 / Float64(y * c)); elseif (y <= 5.3e-15) tmp = Float64(t_1 / i); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = t + (y * 230661.510616); t_2 = x + ((z / y) - (a * (x / y))); tmp = 0.0; if (y <= -4.8e+33) tmp = t_2; elseif (y <= -3.2e-172) tmp = t_1 / (y * c); elseif (y <= 5.3e-15) tmp = t_1 / i; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.8e+33], t$95$2, If[LessEqual[y, -3.2e-172], N[(t$95$1 / N[(y * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.3e-15], N[(t$95$1 / i), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot 230661.510616\\
t_2 := x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\mathbf{if}\;y \leq -4.8 \cdot 10^{+33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -3.2 \cdot 10^{-172}:\\
\;\;\;\;\frac{t\_1}{y \cdot c}\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t\_1}{i}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -4.8e33 or 5.3000000000000001e-15 < y Initial program 11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
fma-define11.8%
Simplified11.8%
Taylor expanded in y around inf 57.5%
associate--l+57.5%
associate-/l*61.9%
Simplified61.9%
if -4.8e33 < y < -3.2000000000000001e-172Initial program 94.1%
*-commutative94.1%
distribute-rgt-in94.1%
*-commutative94.1%
Applied egg-rr94.1%
Taylor expanded in y around 0 72.6%
*-commutative72.6%
Simplified72.6%
Taylor expanded in c around inf 32.3%
if -3.2000000000000001e-172 < y < 5.3000000000000001e-15Initial program 99.7%
*-commutative99.7%
distribute-rgt-in99.7%
*-commutative99.7%
Applied egg-rr99.7%
Taylor expanded in y around 0 91.9%
*-commutative91.9%
Simplified91.9%
Taylor expanded in i around inf 69.1%
Final simplification58.0%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -6.5e+139)
x
(if (<= y -1.2e-18)
(/ (* y (+ x (/ z y))) a)
(if (<= y 5.3e-15) (/ (+ t (* y 230661.510616)) i) x))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.5e+139) {
tmp = x;
} else if (y <= -1.2e-18) {
tmp = (y * (x + (z / y))) / a;
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / 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 <= (-6.5d+139)) then
tmp = x
else if (y <= (-1.2d-18)) then
tmp = (y * (x + (z / y))) / a
else if (y <= 5.3d-15) then
tmp = (t + (y * 230661.510616d0)) / 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 <= -6.5e+139) {
tmp = x;
} else if (y <= -1.2e-18) {
tmp = (y * (x + (z / y))) / a;
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -6.5e+139: tmp = x elif y <= -1.2e-18: tmp = (y * (x + (z / y))) / a elif y <= 5.3e-15: tmp = (t + (y * 230661.510616)) / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -6.5e+139) tmp = x; elseif (y <= -1.2e-18) tmp = Float64(Float64(y * Float64(x + Float64(z / y))) / a); elseif (y <= 5.3e-15) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / 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 <= -6.5e+139) tmp = x; elseif (y <= -1.2e-18) tmp = (y * (x + (z / y))) / a; elseif (y <= 5.3e-15) tmp = (t + (y * 230661.510616)) / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -6.5e+139], x, If[LessEqual[y, -1.2e-18], N[(N[(y * N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[y, 5.3e-15], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.5 \cdot 10^{+139}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq -1.2 \cdot 10^{-18}:\\
\;\;\;\;\frac{y \cdot \left(x + \frac{z}{y}\right)}{a}\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -6.5000000000000003e139 or 5.3000000000000001e-15 < y Initial program 12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
fma-define12.8%
Simplified12.8%
Taylor expanded in y around inf 49.1%
if -6.5000000000000003e139 < y < -1.19999999999999997e-18Initial program 34.5%
fma-define34.5%
fma-define34.5%
fma-define34.5%
fma-define34.5%
fma-define34.5%
fma-define34.5%
fma-define34.5%
Simplified34.5%
Taylor expanded in x around inf 28.6%
Taylor expanded in a around inf 16.4%
Taylor expanded in y around inf 32.3%
if -1.19999999999999997e-18 < y < 5.3000000000000001e-15Initial program 99.6%
*-commutative99.6%
distribute-rgt-in99.6%
*-commutative99.6%
Applied egg-rr99.6%
Taylor expanded in y around 0 89.8%
*-commutative89.8%
Simplified89.8%
Taylor expanded in i around inf 54.0%
Final simplification49.2%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -1.1e-11) x (if (<= y 5.3e-15) (/ (+ t (* y 230661.510616)) i) x)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -1.1e-11) {
tmp = x;
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / 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 <= (-1.1d-11)) then
tmp = x
else if (y <= 5.3d-15) then
tmp = (t + (y * 230661.510616d0)) / 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 <= -1.1e-11) {
tmp = x;
} else if (y <= 5.3e-15) {
tmp = (t + (y * 230661.510616)) / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -1.1e-11: tmp = x elif y <= 5.3e-15: tmp = (t + (y * 230661.510616)) / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -1.1e-11) tmp = x; elseif (y <= 5.3e-15) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / 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 <= -1.1e-11) tmp = x; elseif (y <= 5.3e-15) tmp = (t + (y * 230661.510616)) / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -1.1e-11], x, If[LessEqual[y, 5.3e-15], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.1 \cdot 10^{-11}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -1.1000000000000001e-11 or 5.3000000000000001e-15 < y Initial program 16.8%
fma-define16.8%
fma-define16.8%
fma-define16.8%
fma-define16.8%
fma-define16.8%
fma-define16.8%
fma-define16.8%
Simplified16.8%
Taylor expanded in y around inf 41.2%
if -1.1000000000000001e-11 < y < 5.3000000000000001e-15Initial program 99.6%
*-commutative99.6%
distribute-rgt-in99.6%
*-commutative99.6%
Applied egg-rr99.6%
Taylor expanded in y around 0 89.1%
*-commutative89.1%
Simplified89.1%
Taylor expanded in i around inf 53.1%
Final simplification46.8%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -7.2e-16) x (if (<= y 5.3e-15) (/ 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 <= -7.2e-16) {
tmp = x;
} else if (y <= 5.3e-15) {
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 <= (-7.2d-16)) then
tmp = x
else if (y <= 5.3d-15) 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 <= -7.2e-16) {
tmp = x;
} else if (y <= 5.3e-15) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -7.2e-16: tmp = x elif y <= 5.3e-15: tmp = t / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -7.2e-16) tmp = x; elseif (y <= 5.3e-15) 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 <= -7.2e-16) tmp = x; elseif (y <= 5.3e-15) tmp = t / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -7.2e-16], x, If[LessEqual[y, 5.3e-15], N[(t / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7.2 \cdot 10^{-16}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 5.3 \cdot 10^{-15}:\\
\;\;\;\;\frac{t}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -7.19999999999999965e-16 or 5.3000000000000001e-15 < y Initial program 17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
fma-define17.4%
Simplified17.4%
Taylor expanded in y around inf 40.9%
if -7.19999999999999965e-16 < y < 5.3000000000000001e-15Initial program 99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
fma-define99.6%
Simplified99.6%
Taylor expanded in y around 0 47.3%
(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 55.3%
fma-define55.3%
fma-define55.3%
fma-define55.3%
fma-define55.3%
fma-define55.3%
fma-define55.3%
fma-define55.3%
Simplified55.3%
Taylor expanded in y around inf 23.6%
herbie shell --seed 2024132
(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)))