
(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 14 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 (+ y a)) b)) c)) i))
(t_2
(* y (+ (* y (+ (* y (+ (* x y) z)) 27464.7644705)) 230661.510616))))
(if (<= (/ (+ t_2 t) t_1) 2e+238) (+ (/ t t_1) (/ t_2 t_1)) (+ x (/ z 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 * (y + a)) + b)) + c)) + i;
double t_2 = y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616);
double tmp;
if (((t_2 + t) / t_1) <= 2e+238) {
tmp = (t / t_1) + (t_2 / t_1);
} else {
tmp = x + (z / 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 * (y + a)) + b)) + c)) + i
t_2 = y * ((y * ((y * ((x * y) + z)) + 27464.7644705d0)) + 230661.510616d0)
if (((t_2 + t) / t_1) <= 2d+238) then
tmp = (t / t_1) + (t_2 / t_1)
else
tmp = x + (z / 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 * (y + a)) + b)) + c)) + i;
double t_2 = y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616);
double tmp;
if (((t_2 + t) / t_1) <= 2e+238) {
tmp = (t / t_1) + (t_2 / t_1);
} else {
tmp = x + (z / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * ((y * ((y * (y + a)) + b)) + c)) + i t_2 = y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616) tmp = 0 if ((t_2 + t) / t_1) <= 2e+238: tmp = (t / t_1) + (t_2 / t_1) else: tmp = x + (z / 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(y + a)) + b)) + c)) + i) t_2 = Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(Float64(x * y) + z)) + 27464.7644705)) + 230661.510616)) tmp = 0.0 if (Float64(Float64(t_2 + t) / t_1) <= 2e+238) tmp = Float64(Float64(t / t_1) + Float64(t_2 / t_1)); else tmp = Float64(x + Float64(z / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * ((y * ((y * (y + a)) + b)) + c)) + i; t_2 = y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616); tmp = 0.0; if (((t_2 + t) / t_1) <= 2e+238) tmp = (t / t_1) + (t_2 / t_1); else tmp = x + (z / 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[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(y * N[(N[(y * N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(t$95$2 + t), $MachinePrecision] / t$95$1), $MachinePrecision], 2e+238], N[(N[(t / t$95$1), $MachinePrecision] + N[(t$95$2 / t$95$1), $MachinePrecision]), $MachinePrecision], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i\\
t_2 := y \cdot \left(y \cdot \left(y \cdot \left(x \cdot y + z\right) + 27464.7644705\right) + 230661.510616\right)\\
\mathbf{if}\;\frac{t\_2 + t}{t\_1} \leq 2 \cdot 10^{+238}:\\
\;\;\;\;\frac{t}{t\_1} + \frac{t\_2}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z}{y}\\
\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)) < 2.0000000000000001e238Initial program 95.1%
fma-define95.1%
fma-define95.1%
fma-define95.1%
fma-define95.1%
fma-define95.1%
fma-define95.1%
fma-define95.1%
Simplified95.1%
Taylor expanded in t around 0 95.1%
if 2.0000000000000001e238 < (/.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 0.4%
Taylor expanded in a around 0 0.4%
+-commutative0.4%
distribute-lft-in0.4%
unpow20.4%
cube-mult0.4%
Simplified0.4%
Taylor expanded in y around inf 71.2%
Final simplification84.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i)))
(if (<=
(/
(+
(* y (+ (* y (+ (* y (+ (* x y) z)) 27464.7644705)) 230661.510616))
t)
t_1)
2e+238)
(/
(+
t
(*
y
(+ 230661.510616 (* y (+ 27464.7644705 (+ (* y (* x y)) (* y z)))))))
t_1)
(+ x (/ z 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 * (y + a)) + b)) + c)) + i;
double tmp;
if ((((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / t_1) <= 2e+238) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + ((y * (x * y)) + (y * z))))))) / t_1;
} else {
tmp = x + (z / 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 * (y + a)) + b)) + c)) + i
if ((((y * ((y * ((y * ((x * y) + z)) + 27464.7644705d0)) + 230661.510616d0)) + t) / t_1) <= 2d+238) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + ((y * (x * y)) + (y * z))))))) / t_1
else
tmp = x + (z / 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 * (y + a)) + b)) + c)) + i;
double tmp;
if ((((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / t_1) <= 2e+238) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + ((y * (x * y)) + (y * z))))))) / t_1;
} else {
tmp = x + (z / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * ((y * ((y * (y + a)) + b)) + c)) + i tmp = 0 if (((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / t_1) <= 2e+238: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + ((y * (x * y)) + (y * z))))))) / t_1 else: tmp = x + (z / 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(y + a)) + b)) + c)) + i) tmp = 0.0 if (Float64(Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(Float64(x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / t_1) <= 2e+238) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(Float64(y * Float64(x * y)) + Float64(y * z))))))) / t_1); else tmp = Float64(x + Float64(z / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * ((y * ((y * (y + a)) + b)) + c)) + i; tmp = 0.0; if ((((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / t_1) <= 2e+238) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + ((y * (x * y)) + (y * z))))))) / t_1; else tmp = x + (z / 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[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]}, If[LessEqual[N[(N[(N[(y * N[(N[(y * N[(N[(y * N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] / t$95$1), $MachinePrecision], 2e+238], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(N[(y * N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i\\
\mathbf{if}\;\frac{y \cdot \left(y \cdot \left(y \cdot \left(x \cdot y + z\right) + 27464.7644705\right) + 230661.510616\right) + t}{t\_1} \leq 2 \cdot 10^{+238}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + \left(y \cdot \left(x \cdot y\right) + y \cdot z\right)\right)\right)}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z}{y}\\
\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)) < 2.0000000000000001e238Initial program 95.1%
*-commutative95.1%
distribute-rgt-in95.1%
Applied egg-rr95.1%
if 2.0000000000000001e238 < (/.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 0.4%
Taylor expanded in a around 0 0.4%
+-commutative0.4%
distribute-lft-in0.4%
unpow20.4%
cube-mult0.4%
Simplified0.4%
Taylor expanded in y around inf 71.2%
Final simplification84.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1
(/
(+
(* y (+ (* y (+ (* y (+ (* x y) z)) 27464.7644705)) 230661.510616))
t)
(+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i))))
(if (<= t_1 2e+238) t_1 (+ x (/ z 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 * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
double tmp;
if (t_1 <= 2e+238) {
tmp = t_1;
} else {
tmp = x + (z / 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 * ((x * y) + z)) + 27464.7644705d0)) + 230661.510616d0)) + t) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i)
if (t_1 <= 2d+238) then
tmp = t_1
else
tmp = x + (z / 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 * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
double tmp;
if (t_1 <= 2e+238) {
tmp = t_1;
} else {
tmp = x + (z / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i) tmp = 0 if t_1 <= 2e+238: tmp = t_1 else: tmp = x + (z / 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(Float64(x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(y + a)) + b)) + c)) + i)) tmp = 0.0 if (t_1 <= 2e+238) tmp = t_1; else tmp = Float64(x + Float64(z / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i); tmp = 0.0; if (t_1 <= 2e+238) tmp = t_1; else tmp = x + (z / 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[(N[(x * y), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e+238], t$95$1, N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{y \cdot \left(y \cdot \left(y \cdot \left(x \cdot y + z\right) + 27464.7644705\right) + 230661.510616\right) + t}{y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{+238}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x + \frac{z}{y}\\
\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)) < 2.0000000000000001e238Initial program 95.1%
if 2.0000000000000001e238 < (/.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 0.4%
Taylor expanded in a around 0 0.4%
+-commutative0.4%
distribute-lft-in0.4%
unpow20.4%
cube-mult0.4%
Simplified0.4%
Taylor expanded in y around inf 71.2%
Final simplification84.9%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -3.8e+58)
(+ x (/ z y))
(if (<= y 9.8e+39)
(/
(+ (* y (+ (* y (+ (* y (+ (* x y) z)) 27464.7644705)) 230661.510616)) t)
(+ i (* y (+ c (* y (+ b (* y a)))))))
(+ 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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 9.8e+39) {
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * (b + (y * a))))));
} 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) :: tmp
if (y <= (-3.8d+58)) then
tmp = x + (z / y)
else if (y <= 9.8d+39) then
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705d0)) + 230661.510616d0)) + t) / (i + (y * (c + (y * (b + (y * a))))))
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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 9.8e+39) {
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * (b + (y * a))))));
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -3.8e+58: tmp = x + (z / y) elif y <= 9.8e+39: tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * (b + (y * a)))))) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -3.8e+58) tmp = Float64(x + Float64(z / y)); elseif (y <= 9.8e+39) tmp = Float64(Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(Float64(x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / Float64(i + Float64(y * Float64(c + Float64(y * Float64(b + Float64(y * a))))))); 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) tmp = 0.0; if (y <= -3.8e+58) tmp = x + (z / y); elseif (y <= 9.8e+39) tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * (b + (y * a)))))); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.8e+58], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.8e+39], N[(N[(N[(y * N[(N[(y * N[(N[(y * N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * N[(b + N[(y * a), $MachinePrecision]), $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}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+58}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 9.8 \cdot 10^{+39}:\\
\;\;\;\;\frac{y \cdot \left(y \cdot \left(y \cdot \left(x \cdot y + z\right) + 27464.7644705\right) + 230661.510616\right) + t}{i + y \cdot \left(c + y \cdot \left(b + y \cdot a\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -3.7999999999999999e58Initial program 0.2%
Taylor expanded in a around 0 0.2%
+-commutative0.2%
distribute-lft-in0.2%
unpow20.2%
cube-mult0.2%
Simplified0.2%
Taylor expanded in y around inf 69.5%
if -3.7999999999999999e58 < y < 9.79999999999999974e39Initial program 94.4%
Taylor expanded in y around 0 92.6%
if 9.79999999999999974e39 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 74.1%
associate--l+74.1%
associate-/l*75.8%
Simplified75.8%
Final simplification84.2%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -5.8e+59)
(+ x (/ z y))
(if (<= y 1.85e+40)
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z))))))
(+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i))
(+ 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 tmp;
if (y <= -5.8e+59) {
tmp = x + (z / y);
} else if (y <= 1.85e+40) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} 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) :: tmp
if (y <= (-5.8d+59)) then
tmp = x + (z / y)
else if (y <= 1.85d+40) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i)
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 tmp;
if (y <= -5.8e+59) {
tmp = x + (z / y);
} else if (y <= 1.85e+40) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -5.8e+59: tmp = x + (z / y) elif y <= 1.85e+40: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -5.8e+59) tmp = Float64(x + Float64(z / y)); elseif (y <= 1.85e+40) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(y + a)) + b)) + c)) + i)); 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) tmp = 0.0; if (y <= -5.8e+59) tmp = x + (z / y); elseif (y <= 1.85e+40) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -5.8e+59], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.85e+40], 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[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.8 \cdot 10^{+59}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{+40}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -5.79999999999999981e59Initial program 0.2%
Taylor expanded in a around 0 0.2%
+-commutative0.2%
distribute-lft-in0.2%
unpow20.2%
cube-mult0.2%
Simplified0.2%
Taylor expanded in y around inf 69.5%
if -5.79999999999999981e59 < y < 1.85e40Initial program 94.4%
Taylor expanded in x around 0 88.3%
if 1.85e40 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 74.1%
associate--l+74.1%
associate-/l*75.8%
Simplified75.8%
Final simplification81.7%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -2.6e+55)
(+ x (/ z y))
(if (<= y 7.7e+34)
(/
(+ (* y (+ (* y (+ (* y (+ (* x y) z)) 27464.7644705)) 230661.510616)) t)
(+ i (* y (+ c (* 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 tmp;
if (y <= -2.6e+55) {
tmp = x + (z / y);
} else if (y <= 7.7e+34) {
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (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) :: tmp
if (y <= (-2.6d+55)) then
tmp = x + (z / y)
else if (y <= 7.7d+34) then
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705d0)) + 230661.510616d0)) + t) / (i + (y * (c + (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 tmp;
if (y <= -2.6e+55) {
tmp = x + (z / y);
} else if (y <= 7.7e+34) {
tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * b))));
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -2.6e+55: tmp = x + (z / y) elif y <= 7.7e+34: tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * b)))) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -2.6e+55) tmp = Float64(x + Float64(z / y)); elseif (y <= 7.7e+34) tmp = Float64(Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(Float64(x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / Float64(i + Float64(y * Float64(c + 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) tmp = 0.0; if (y <= -2.6e+55) tmp = x + (z / y); elseif (y <= 7.7e+34) tmp = ((y * ((y * ((y * ((x * y) + z)) + 27464.7644705)) + 230661.510616)) + t) / (i + (y * (c + (y * b)))); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -2.6e+55], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.7e+34], N[(N[(N[(y * N[(N[(y * N[(N[(y * N[(N[(x * y), $MachinePrecision] + z), $MachinePrecision]), $MachinePrecision] + 27464.7644705), $MachinePrecision]), $MachinePrecision] + 230661.510616), $MachinePrecision]), $MachinePrecision] + t), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $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}
\mathbf{if}\;y \leq -2.6 \cdot 10^{+55}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 7.7 \cdot 10^{+34}:\\
\;\;\;\;\frac{y \cdot \left(y \cdot \left(y \cdot \left(x \cdot y + z\right) + 27464.7644705\right) + 230661.510616\right) + t}{i + y \cdot \left(c + y \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -2.6e55Initial program 0.3%
Taylor expanded in a around 0 0.3%
+-commutative0.3%
distribute-lft-in0.3%
unpow20.3%
cube-mult0.3%
Simplified0.3%
Taylor expanded in y around inf 68.2%
if -2.6e55 < y < 7.6999999999999999e34Initial program 96.3%
Taylor expanded in y around 0 89.1%
*-commutative89.1%
Simplified89.1%
if 7.6999999999999999e34 < y Initial program 0.8%
fma-define0.8%
fma-define0.8%
fma-define0.8%
fma-define0.8%
fma-define0.8%
fma-define0.8%
fma-define0.8%
Simplified0.8%
Taylor expanded in y around inf 71.7%
associate--l+71.7%
associate-/l*73.2%
Simplified73.2%
Final simplification81.2%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -2.1e+66)
(+ x (/ z y))
(if (<= y 5.5e+40)
(/
(+ t (* y (+ 230661.510616 (* y 27464.7644705))))
(+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i))
(+ 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 tmp;
if (y <= -2.1e+66) {
tmp = x + (z / y);
} else if (y <= 5.5e+40) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} 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) :: tmp
if (y <= (-2.1d+66)) then
tmp = x + (z / y)
else if (y <= 5.5d+40) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i)
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 tmp;
if (y <= -2.1e+66) {
tmp = x + (z / y);
} else if (y <= 5.5e+40) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -2.1e+66: tmp = x + (z / y) elif y <= 5.5e+40: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -2.1e+66) tmp = Float64(x + Float64(z / y)); elseif (y <= 5.5e+40) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(y + a)) + b)) + c)) + i)); 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) tmp = 0.0; if (y <= -2.1e+66) tmp = x + (z / y); elseif (y <= 5.5e+40) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -2.1e+66], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e+40], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.1 \cdot 10^{+66}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{+40}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -2.10000000000000005e66Initial program 0.2%
Taylor expanded in a around 0 0.2%
+-commutative0.2%
distribute-lft-in0.2%
unpow20.2%
cube-mult0.2%
Simplified0.2%
Taylor expanded in y around inf 69.5%
if -2.10000000000000005e66 < y < 5.49999999999999974e40Initial program 93.8%
Taylor expanded in y around 0 81.8%
*-commutative81.8%
Simplified81.8%
if 5.49999999999999974e40 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 75.5%
associate--l+75.5%
associate-/l*77.1%
Simplified77.1%
Final simplification78.3%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -9.6e+50)
(+ x (/ z y))
(if (<= y 4.6e+40)
(/ (+ t (* y 230661.510616)) (+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i))
(+ 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 tmp;
if (y <= -9.6e+50) {
tmp = x + (z / y);
} else if (y <= 4.6e+40) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} 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) :: tmp
if (y <= (-9.6d+50)) then
tmp = x + (z / y)
else if (y <= 4.6d+40) then
tmp = (t + (y * 230661.510616d0)) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i)
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 tmp;
if (y <= -9.6e+50) {
tmp = x + (z / y);
} else if (y <= 4.6e+40) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -9.6e+50: tmp = x + (z / y) elif y <= 4.6e+40: tmp = (t + (y * 230661.510616)) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -9.6e+50) tmp = Float64(x + Float64(z / y)); elseif (y <= 4.6e+40) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(y + a)) + b)) + c)) + i)); 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) tmp = 0.0; if (y <= -9.6e+50) tmp = x + (z / y); elseif (y <= 4.6e+40) tmp = (t + (y * 230661.510616)) / ((y * ((y * ((y * (y + a)) + b)) + c)) + i); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -9.6e+50], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.6e+40], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.6 \cdot 10^{+50}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{+40}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -9.6000000000000007e50Initial program 2.1%
Taylor expanded in a around 0 2.1%
+-commutative2.1%
distribute-lft-in2.1%
unpow22.1%
cube-mult2.1%
Simplified2.1%
Taylor expanded in y around inf 67.1%
if -9.6000000000000007e50 < y < 4.59999999999999987e40Initial program 94.4%
Taylor expanded in y around 0 82.2%
*-commutative82.2%
Simplified82.2%
if 4.59999999999999987e40 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 75.5%
associate--l+75.5%
associate-/l*77.1%
Simplified77.1%
Final simplification77.9%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -3.8e+58)
(+ x (/ z y))
(if (<= y 5e+40)
(/ t (+ (* y (+ (* y (+ (* y (+ y a)) b)) c)) i))
(+ 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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 5e+40) {
tmp = t / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} 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) :: tmp
if (y <= (-3.8d+58)) then
tmp = x + (z / y)
else if (y <= 5d+40) then
tmp = t / ((y * ((y * ((y * (y + a)) + b)) + c)) + i)
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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 5e+40) {
tmp = t / ((y * ((y * ((y * (y + a)) + b)) + c)) + i);
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -3.8e+58: tmp = x + (z / y) elif y <= 5e+40: tmp = t / ((y * ((y * ((y * (y + a)) + b)) + c)) + i) else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -3.8e+58) tmp = Float64(x + Float64(z / y)); elseif (y <= 5e+40) tmp = Float64(t / Float64(Float64(y * Float64(Float64(y * Float64(Float64(y * Float64(y + a)) + b)) + c)) + i)); 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) tmp = 0.0; if (y <= -3.8e+58) tmp = x + (z / y); elseif (y <= 5e+40) tmp = t / ((y * ((y * ((y * (y + a)) + b)) + c)) + i); else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.8e+58], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5e+40], N[(t / N[(N[(y * N[(N[(y * N[(N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+58}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 5 \cdot 10^{+40}:\\
\;\;\;\;\frac{t}{y \cdot \left(y \cdot \left(y \cdot \left(y + a\right) + b\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -3.7999999999999999e58Initial program 0.2%
Taylor expanded in a around 0 0.2%
+-commutative0.2%
distribute-lft-in0.2%
unpow20.2%
cube-mult0.2%
Simplified0.2%
Taylor expanded in y around inf 69.5%
if -3.7999999999999999e58 < y < 5.00000000000000003e40Initial program 93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
Simplified93.8%
Taylor expanded in t around inf 65.1%
if 5.00000000000000003e40 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 75.5%
associate--l+75.5%
associate-/l*77.1%
Simplified77.1%
Final simplification68.6%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -3.5e+50)
(+ x (/ z y))
(if (<= y 8.6e+35)
(/ (+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y z)))))) i)
(+ 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 tmp;
if (y <= -3.5e+50) {
tmp = x + (z / y);
} else if (y <= 8.6e+35) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i;
} 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) :: tmp
if (y <= (-3.5d+50)) then
tmp = x + (z / y)
else if (y <= 8.6d+35) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * z)))))) / i
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 tmp;
if (y <= -3.5e+50) {
tmp = x + (z / y);
} else if (y <= 8.6e+35) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i;
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -3.5e+50: tmp = x + (z / y) elif y <= 8.6e+35: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -3.5e+50) tmp = Float64(x + Float64(z / y)); elseif (y <= 8.6e+35) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * z)))))) / i); 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) tmp = 0.0; if (y <= -3.5e+50) tmp = x + (z / y); elseif (y <= 8.6e+35) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * z)))))) / i; else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.5e+50], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.6e+35], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.5 \cdot 10^{+50}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 8.6 \cdot 10^{+35}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot z\right)\right)}{i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -3.50000000000000006e50Initial program 2.1%
Taylor expanded in a around 0 2.1%
+-commutative2.1%
distribute-lft-in2.1%
unpow22.1%
cube-mult2.1%
Simplified2.1%
Taylor expanded in y around inf 67.1%
if -3.50000000000000006e50 < y < 8.5999999999999995e35Initial program 95.6%
Taylor expanded in x around 0 89.3%
Taylor expanded in i around inf 59.9%
if 8.5999999999999995e35 < y Initial program 0.7%
fma-define0.7%
fma-define0.7%
fma-define0.7%
fma-define0.7%
fma-define0.7%
fma-define0.7%
fma-define0.7%
Simplified0.7%
Taylor expanded in y around inf 72.9%
associate--l+72.9%
associate-/l*74.5%
Simplified74.5%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -3.8e+58) (+ x (/ z y)) (if (<= y 2.5e+40) (/ t i) (+ 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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 2.5e+40) {
tmp = t / i;
} 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) :: tmp
if (y <= (-3.8d+58)) then
tmp = x + (z / y)
else if (y <= 2.5d+40) then
tmp = t / i
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 tmp;
if (y <= -3.8e+58) {
tmp = x + (z / y);
} else if (y <= 2.5e+40) {
tmp = t / i;
} else {
tmp = x + ((z / y) - (a * (x / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -3.8e+58: tmp = x + (z / y) elif y <= 2.5e+40: tmp = t / i else: tmp = x + ((z / y) - (a * (x / y))) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -3.8e+58) tmp = Float64(x + Float64(z / y)); elseif (y <= 2.5e+40) tmp = Float64(t / i); 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) tmp = 0.0; if (y <= -3.8e+58) tmp = x + (z / y); elseif (y <= 2.5e+40) tmp = t / i; else tmp = x + ((z / y) - (a * (x / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.8e+58], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.5e+40], N[(t / i), $MachinePrecision], N[(x + N[(N[(z / y), $MachinePrecision] - N[(a * N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+58}:\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{elif}\;y \leq 2.5 \cdot 10^{+40}:\\
\;\;\;\;\frac{t}{i}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{z}{y} - a \cdot \frac{x}{y}\right)\\
\end{array}
\end{array}
if y < -3.7999999999999999e58Initial program 0.2%
Taylor expanded in a around 0 0.2%
+-commutative0.2%
distribute-lft-in0.2%
unpow20.2%
cube-mult0.2%
Simplified0.2%
Taylor expanded in y around inf 69.5%
if -3.7999999999999999e58 < y < 2.50000000000000002e40Initial program 93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
Simplified93.8%
Taylor expanded in y around 0 47.7%
if 2.50000000000000002e40 < y Initial program 0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
fma-define0.6%
Simplified0.6%
Taylor expanded in y around inf 75.5%
associate--l+75.5%
associate-/l*77.1%
Simplified77.1%
(FPCore (x y z t a b c i) :precision binary64 (if (or (<= y -3.8e+58) (not (<= y 2.5e+40))) (+ x (/ z y)) (/ t i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if ((y <= -3.8e+58) || !(y <= 2.5e+40)) {
tmp = x + (z / y);
} else {
tmp = t / 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 <= (-3.8d+58)) .or. (.not. (y <= 2.5d+40))) then
tmp = x + (z / y)
else
tmp = t / 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 <= -3.8e+58) || !(y <= 2.5e+40)) {
tmp = x + (z / y);
} else {
tmp = t / i;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if (y <= -3.8e+58) or not (y <= 2.5e+40): tmp = x + (z / y) else: tmp = t / i return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if ((y <= -3.8e+58) || !(y <= 2.5e+40)) tmp = Float64(x + Float64(z / y)); else tmp = Float64(t / i); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if ((y <= -3.8e+58) || ~((y <= 2.5e+40))) tmp = x + (z / y); else tmp = t / i; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[Or[LessEqual[y, -3.8e+58], N[Not[LessEqual[y, 2.5e+40]], $MachinePrecision]], N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision], N[(t / i), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.8 \cdot 10^{+58} \lor \neg \left(y \leq 2.5 \cdot 10^{+40}\right):\\
\;\;\;\;x + \frac{z}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{t}{i}\\
\end{array}
\end{array}
if y < -3.7999999999999999e58 or 2.50000000000000002e40 < y Initial program 0.4%
Taylor expanded in a around 0 0.4%
+-commutative0.4%
distribute-lft-in0.4%
unpow20.4%
cube-mult0.4%
Simplified0.4%
Taylor expanded in y around inf 73.4%
if -3.7999999999999999e58 < y < 2.50000000000000002e40Initial program 93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
fma-define93.8%
Simplified93.8%
Taylor expanded in y around 0 47.7%
Final simplification58.4%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -9.6e+85) x (if (<= y 1.4e+36) (/ 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 <= -9.6e+85) {
tmp = x;
} else if (y <= 1.4e+36) {
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 <= (-9.6d+85)) then
tmp = x
else if (y <= 1.4d+36) 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 <= -9.6e+85) {
tmp = x;
} else if (y <= 1.4e+36) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -9.6e+85: tmp = x elif y <= 1.4e+36: tmp = t / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -9.6e+85) tmp = x; elseif (y <= 1.4e+36) 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 <= -9.6e+85) tmp = x; elseif (y <= 1.4e+36) tmp = t / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -9.6e+85], x, If[LessEqual[y, 1.4e+36], N[(t / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.6 \cdot 10^{+85}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{+36}:\\
\;\;\;\;\frac{t}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -9.59999999999999986e85 or 1.4e36 < y Initial program 0.4%
fma-define0.4%
fma-define0.4%
fma-define0.4%
fma-define0.4%
fma-define0.4%
fma-define0.4%
fma-define0.4%
Simplified0.4%
Taylor expanded in y around inf 57.3%
if -9.59999999999999986e85 < y < 1.4e36Initial 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 y around 0 46.8%
(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 54.8%
fma-define54.8%
fma-define54.8%
fma-define54.8%
fma-define54.8%
fma-define54.8%
fma-define54.8%
fma-define54.8%
Simplified54.8%
Taylor expanded in y around inf 25.3%
herbie shell --seed 2024170
(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)))