
(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 23 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
(if (<= y -1.7e+83)
(+ x (/ (- z (* x a)) y))
(if (<= y 1.45e+66)
(/
(+ t (* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
(+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -1.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.45e+66) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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.7d+83)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 1.45d+66) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.45e+66) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -1.7e+83: tmp = x + ((z - (x * a)) / y) elif y <= 1.45e+66: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -1.7e+83) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 1.45e+66) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -1.7e+83) tmp = x + ((z - (x * a)) / y); elseif (y <= 1.45e+66) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -1.7e+83], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.45e+66], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(N[(y * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.7 \cdot 10^{+83}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{+66}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -1.6999999999999999e83Initial program 2.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified54.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6476.1%
Simplified76.1%
if -1.6999999999999999e83 < y < 1.44999999999999993e66Initial program 92.2%
if 1.44999999999999993e66 < y Initial program 0.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr0.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification85.2%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ b (* y (+ y a))))
(t_2
(/
(+
t
(* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
(+ i (* (* y y) t_1)))))
(if (<= y -1.7e+83)
(+ x (/ (- z (* x a)) y))
(if (<= y -6.5e-34)
t_2
(if (<= y 2.3e-61)
(/
(+ t (* y (+ 230661.510616 (* y 27464.7644705))))
(+ (* y (+ (* y t_1) c)) i))
(if (<= y 1.5e+66)
t_2
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = b + (y * (y + a));
double t_2 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1));
double tmp;
if (y <= -1.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= -6.5e-34) {
tmp = t_2;
} else if (y <= 2.3e-61) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * t_1) + c)) + i);
} else if (y <= 1.5e+66) {
tmp = t_2;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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) :: t_2
real(8) :: tmp
t_1 = b + (y * (y + a))
t_2 = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1))
if (y <= (-1.7d+83)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= (-6.5d-34)) then
tmp = t_2
else if (y <= 2.3d-61) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / ((y * ((y * t_1) + c)) + i)
else if (y <= 1.5d+66) then
tmp = t_2
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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 = b + (y * (y + a));
double t_2 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1));
double tmp;
if (y <= -1.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= -6.5e-34) {
tmp = t_2;
} else if (y <= 2.3e-61) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * t_1) + c)) + i);
} else if (y <= 1.5e+66) {
tmp = t_2;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = b + (y * (y + a)) t_2 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1)) tmp = 0 if y <= -1.7e+83: tmp = x + ((z - (x * a)) / y) elif y <= -6.5e-34: tmp = t_2 elif y <= 2.3e-61: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * t_1) + c)) + i) elif y <= 1.5e+66: tmp = t_2 else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(b + Float64(y * Float64(y + a))) t_2 = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(i + Float64(Float64(y * y) * t_1))) tmp = 0.0 if (y <= -1.7e+83) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= -6.5e-34) tmp = t_2; elseif (y <= 2.3e-61) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(Float64(y * Float64(Float64(y * t_1) + c)) + i)); elseif (y <= 1.5e+66) tmp = t_2; else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = b + (y * (y + a)); t_2 = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1)); tmp = 0.0; if (y <= -1.7e+83) tmp = x + ((z - (x * a)) / y); elseif (y <= -6.5e-34) tmp = t_2; elseif (y <= 2.3e-61) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * t_1) + c)) + i); elseif (y <= 1.5e+66) tmp = t_2; else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(N[(y * y), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.7e+83], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -6.5e-34], t$95$2, If[LessEqual[y, 2.3e-61], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(y * N[(N[(y * t$95$1), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+66], t$95$2, N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b + y \cdot \left(y + a\right)\\
t_2 := \frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{i + \left(y \cdot y\right) \cdot t\_1}\\
\mathbf{if}\;y \leq -1.7 \cdot 10^{+83}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq -6.5 \cdot 10^{-34}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 2.3 \cdot 10^{-61}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{y \cdot \left(y \cdot t\_1 + c\right) + i}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+66}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -1.6999999999999999e83Initial program 2.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified54.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6476.1%
Simplified76.1%
if -1.6999999999999999e83 < y < -6.49999999999999985e-34 or 2.29999999999999992e-61 < y < 1.50000000000000001e66Initial program 77.9%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified65.7%
if -6.49999999999999985e-34 < y < 2.29999999999999992e-61Initial program 99.8%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6498.0%
Simplified98.0%
if 1.50000000000000001e66 < y Initial program 0.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr0.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification82.0%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ b (* y (+ y a)))))
(if (<= y -1.7e+83)
(+ x (/ (- z (* x a)) y))
(if (<= y 8.8e-41)
(/
-1.0
(*
(+ (* y (+ (* y t_1) c)) i)
(/ -1.0 (+ t (* y (+ 230661.510616 (* x (* y (* y y)))))))))
(if (<= y 1.5e+66)
(/
(+
t
(* y (+ 230661.510616 (* y (+ 27464.7644705 (* y (+ z (* y x))))))))
(+ i (* (* y y) t_1)))
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = b + (y * (y + a));
double tmp;
if (y <= -1.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 8.8e-41) {
tmp = -1.0 / (((y * ((y * t_1) + c)) + i) * (-1.0 / (t + (y * (230661.510616 + (x * (y * (y * y))))))));
} else if (y <= 1.5e+66) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1));
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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 = b + (y * (y + a))
if (y <= (-1.7d+83)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 8.8d-41) then
tmp = (-1.0d0) / (((y * ((y * t_1) + c)) + i) * ((-1.0d0) / (t + (y * (230661.510616d0 + (x * (y * (y * y))))))))
else if (y <= 1.5d+66) then
tmp = (t + (y * (230661.510616d0 + (y * (27464.7644705d0 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1))
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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 = b + (y * (y + a));
double tmp;
if (y <= -1.7e+83) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 8.8e-41) {
tmp = -1.0 / (((y * ((y * t_1) + c)) + i) * (-1.0 / (t + (y * (230661.510616 + (x * (y * (y * y))))))));
} else if (y <= 1.5e+66) {
tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1));
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = b + (y * (y + a)) tmp = 0 if y <= -1.7e+83: tmp = x + ((z - (x * a)) / y) elif y <= 8.8e-41: tmp = -1.0 / (((y * ((y * t_1) + c)) + i) * (-1.0 / (t + (y * (230661.510616 + (x * (y * (y * y)))))))) elif y <= 1.5e+66: tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1)) else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(b + Float64(y * Float64(y + a))) tmp = 0.0 if (y <= -1.7e+83) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 8.8e-41) tmp = Float64(-1.0 / Float64(Float64(Float64(y * Float64(Float64(y * t_1) + c)) + i) * Float64(-1.0 / Float64(t + Float64(y * Float64(230661.510616 + Float64(x * Float64(y * Float64(y * y))))))))); elseif (y <= 1.5e+66) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * Float64(27464.7644705 + Float64(y * Float64(z + Float64(y * x)))))))) / Float64(i + Float64(Float64(y * y) * t_1))); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = b + (y * (y + a)); tmp = 0.0; if (y <= -1.7e+83) tmp = x + ((z - (x * a)) / y); elseif (y <= 8.8e-41) tmp = -1.0 / (((y * ((y * t_1) + c)) + i) * (-1.0 / (t + (y * (230661.510616 + (x * (y * (y * y)))))))); elseif (y <= 1.5e+66) tmp = (t + (y * (230661.510616 + (y * (27464.7644705 + (y * (z + (y * x)))))))) / (i + ((y * y) * t_1)); else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := Block[{t$95$1 = N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.7e+83], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.8e-41], N[(-1.0 / N[(N[(N[(y * N[(N[(y * t$95$1), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision] * N[(-1.0 / N[(t + N[(y * N[(230661.510616 + N[(x * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+66], N[(N[(t + N[(y * N[(230661.510616 + N[(y * N[(27464.7644705 + N[(y * N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(N[(y * y), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b + y \cdot \left(y + a\right)\\
\mathbf{if}\;y \leq -1.7 \cdot 10^{+83}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 8.8 \cdot 10^{-41}:\\
\;\;\;\;\frac{-1}{\left(y \cdot \left(y \cdot t\_1 + c\right) + i\right) \cdot \frac{-1}{t + y \cdot \left(230661.510616 + x \cdot \left(y \cdot \left(y \cdot y\right)\right)\right)}}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+66}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot \left(27464.7644705 + y \cdot \left(z + y \cdot x\right)\right)\right)}{i + \left(y \cdot y\right) \cdot t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -1.6999999999999999e83Initial program 2.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified54.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6476.1%
Simplified76.1%
if -1.6999999999999999e83 < y < 8.7999999999999999e-41Initial program 93.7%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr93.5%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr93.0%
Taylor expanded in y around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6487.4%
Simplified87.4%
if 8.7999999999999999e-41 < y < 1.50000000000000001e66Initial program 85.2%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified74.2%
if 1.50000000000000001e66 < y Initial program 0.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr0.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification80.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i)))
(if (<= y -7.6e+63)
(+ x (/ (- z (* x a)) y))
(if (<= y 3.6e-93)
(/ (+ t (* y 230661.510616)) t_1)
(if (<= y 5e+30)
(/ (+ t (* y (* z (* y y)))) t_1)
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i;
double tmp;
if (y <= -7.6e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.6e-93) {
tmp = (t + (y * 230661.510616)) / t_1;
} else if (y <= 5e+30) {
tmp = (t + (y * (z * (y * y)))) / t_1;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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 = (y * ((y * (b + (y * (y + a)))) + c)) + i
if (y <= (-7.6d+63)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 3.6d-93) then
tmp = (t + (y * 230661.510616d0)) / t_1
else if (y <= 5d+30) then
tmp = (t + (y * (z * (y * y)))) / t_1
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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 = (y * ((y * (b + (y * (y + a)))) + c)) + i;
double tmp;
if (y <= -7.6e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.6e-93) {
tmp = (t + (y * 230661.510616)) / t_1;
} else if (y <= 5e+30) {
tmp = (t + (y * (z * (y * y)))) / t_1;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i tmp = 0 if y <= -7.6e+63: tmp = x + ((z - (x * a)) / y) elif y <= 3.6e-93: tmp = (t + (y * 230661.510616)) / t_1 elif y <= 5e+30: tmp = (t + (y * (z * (y * y)))) / t_1 else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i) tmp = 0.0 if (y <= -7.6e+63) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 3.6e-93) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / t_1); elseif (y <= 5e+30) tmp = Float64(Float64(t + Float64(y * Float64(z * Float64(y * y)))) / t_1); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i; tmp = 0.0; if (y <= -7.6e+63) tmp = x + ((z - (x * a)) / y); elseif (y <= 3.6e-93) tmp = (t + (y * 230661.510616)) / t_1; elseif (y <= 5e+30) tmp = (t + (y * (z * (y * y)))) / t_1; else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); 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[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]}, If[LessEqual[y, -7.6e+63], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.6e-93], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[y, 5e+30], N[(N[(t + N[(y * N[(z * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i\\
\mathbf{if}\;y \leq -7.6 \cdot 10^{+63}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{-93}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{t\_1}\\
\mathbf{elif}\;y \leq 5 \cdot 10^{+30}:\\
\;\;\;\;\frac{t + y \cdot \left(z \cdot \left(y \cdot y\right)\right)}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -7.6000000000000002e63Initial program 6.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified51.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -7.6000000000000002e63 < y < 3.6000000000000002e-93Initial program 95.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6487.1%
Simplified87.1%
if 3.6000000000000002e-93 < y < 4.9999999999999998e30Initial program 99.3%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.6%
Simplified77.6%
if 4.9999999999999998e30 < y Initial program 8.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr8.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr8.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6464.5%
Simplified64.5%
Final simplification77.3%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i)))
(if (<= y -6e+63)
(+ x (/ (- z (* x a)) y))
(if (<= y 3.3e-6)
(/ (+ t (* y 230661.510616)) t_1)
(if (<= y 1.15e+31)
(/ (* z (* y (* y y))) t_1)
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i;
double tmp;
if (y <= -6e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.3e-6) {
tmp = (t + (y * 230661.510616)) / t_1;
} else if (y <= 1.15e+31) {
tmp = (z * (y * (y * y))) / t_1;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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 = (y * ((y * (b + (y * (y + a)))) + c)) + i
if (y <= (-6d+63)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 3.3d-6) then
tmp = (t + (y * 230661.510616d0)) / t_1
else if (y <= 1.15d+31) then
tmp = (z * (y * (y * y))) / t_1
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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 = (y * ((y * (b + (y * (y + a)))) + c)) + i;
double tmp;
if (y <= -6e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.3e-6) {
tmp = (t + (y * 230661.510616)) / t_1;
} else if (y <= 1.15e+31) {
tmp = (z * (y * (y * y))) / t_1;
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i tmp = 0 if y <= -6e+63: tmp = x + ((z - (x * a)) / y) elif y <= 3.3e-6: tmp = (t + (y * 230661.510616)) / t_1 elif y <= 1.15e+31: tmp = (z * (y * (y * y))) / t_1 else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i) tmp = 0.0 if (y <= -6e+63) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 3.3e-6) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / t_1); elseif (y <= 1.15e+31) tmp = Float64(Float64(z * Float64(y * Float64(y * y))) / t_1); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = (y * ((y * (b + (y * (y + a)))) + c)) + i; tmp = 0.0; if (y <= -6e+63) tmp = x + ((z - (x * a)) / y); elseif (y <= 3.3e-6) tmp = (t + (y * 230661.510616)) / t_1; elseif (y <= 1.15e+31) tmp = (z * (y * (y * y))) / t_1; else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); 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[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] + i), $MachinePrecision]}, If[LessEqual[y, -6e+63], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e-6], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[y, 1.15e+31], N[(N[(z * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i\\
\mathbf{if}\;y \leq -6 \cdot 10^{+63}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{-6}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{t\_1}\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{+31}:\\
\;\;\;\;\frac{z \cdot \left(y \cdot \left(y \cdot y\right)\right)}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -5.99999999999999998e63Initial program 6.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified51.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -5.99999999999999998e63 < y < 3.30000000000000017e-6Initial program 96.0%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6485.9%
Simplified85.9%
if 3.30000000000000017e-6 < y < 1.15e31Initial program 99.4%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6465.7%
Simplified65.7%
if 1.15e31 < y Initial program 8.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr8.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr8.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6464.5%
Simplified64.5%
Final simplification76.8%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -6.4e+63)
(+ x (/ (- z (* x a)) y))
(if (<= y 2.8e-8)
(/ (+ t (* y 230661.510616)) (+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))
(if (<= y 2e+30)
(/ (+ t (* y (* z (* y y)))) (+ i (* y (+ c (* a (* y y))))))
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.4e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.8e-8) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else if (y <= 2e+30) {
tmp = (t + (y * (z * (y * y)))) / (i + (y * (c + (a * (y * y)))));
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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.4d+63)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 2.8d-8) then
tmp = (t + (y * 230661.510616d0)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
else if (y <= 2d+30) then
tmp = (t + (y * (z * (y * y)))) / (i + (y * (c + (a * (y * y)))))
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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.4e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.8e-8) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else if (y <= 2e+30) {
tmp = (t + (y * (z * (y * y)))) / (i + (y * (c + (a * (y * y)))));
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -6.4e+63: tmp = x + ((z - (x * a)) / y) elif y <= 2.8e-8: tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) elif y <= 2e+30: tmp = (t + (y * (z * (y * y)))) / (i + (y * (c + (a * (y * y))))) else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -6.4e+63) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 2.8e-8) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); elseif (y <= 2e+30) tmp = Float64(Float64(t + Float64(y * Float64(z * Float64(y * y)))) / Float64(i + Float64(y * Float64(c + Float64(a * Float64(y * y)))))); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -6.4e+63) tmp = x + ((z - (x * a)) / y); elseif (y <= 2.8e-8) tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); elseif (y <= 2e+30) tmp = (t + (y * (z * (y * y)))) / (i + (y * (c + (a * (y * y))))); else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -6.4e+63], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.8e-8], 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], If[LessEqual[y, 2e+30], N[(N[(t + N[(y * N[(z * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(a * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.4 \cdot 10^{+63}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{-8}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+30}:\\
\;\;\;\;\frac{t + y \cdot \left(z \cdot \left(y \cdot y\right)\right)}{i + y \cdot \left(c + a \cdot \left(y \cdot y\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -6.40000000000000022e63Initial program 6.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified51.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -6.40000000000000022e63 < y < 2.7999999999999999e-8Initial program 95.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6485.6%
Simplified85.6%
if 2.7999999999999999e-8 < y < 2e30Initial program 99.4%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.9%
Simplified77.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.1%
Simplified70.1%
if 2e30 < y Initial program 8.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr8.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr8.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6464.5%
Simplified64.5%
Final simplification76.8%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -1.8e+64)
(+ x (/ (- z (* x a)) y))
(if (<= y 1.45e+66)
(/
(+ t (* y (+ 230661.510616 (* y 27464.7644705))))
(+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -1.8e+64) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.45e+66) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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.8d+64)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 1.45d+66) then
tmp = (t + (y * (230661.510616d0 + (y * 27464.7644705d0)))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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.8e+64) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.45e+66) {
tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -1.8e+64: tmp = x + ((z - (x * a)) / y) elif y <= 1.45e+66: tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -1.8e+64) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 1.45e+66) tmp = Float64(Float64(t + Float64(y * Float64(230661.510616 + Float64(y * 27464.7644705)))) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -1.8e+64) tmp = x + ((z - (x * a)) / y); elseif (y <= 1.45e+66) tmp = (t + (y * (230661.510616 + (y * 27464.7644705)))) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -1.8e+64], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.45e+66], N[(N[(t + N[(y * N[(230661.510616 + N[(y * 27464.7644705), $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], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.8 \cdot 10^{+64}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{+66}:\\
\;\;\;\;\frac{t + y \cdot \left(230661.510616 + y \cdot 27464.7644705\right)}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -1.80000000000000007e64Initial program 6.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified51.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -1.80000000000000007e64 < y < 1.44999999999999993e66Initial program 93.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6480.9%
Simplified80.9%
if 1.44999999999999993e66 < y Initial program 0.2%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr0.2%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6472.5%
Simplified72.5%
Final simplification77.1%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x)))))
(if (<= y -9.5e+199)
(+ x (/ (- z (* x a)) y))
(if (<= y -2e+21)
t_1
(if (<= y 1.75e+30)
(/ (+ 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 = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
double tmp;
if (y <= -9.5e+199) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= -2e+21) {
tmp = t_1;
} else if (y <= 1.75e+30) {
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 = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / x))
if (y <= (-9.5d+199)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= (-2d+21)) then
tmp = t_1
else if (y <= 1.75d+30) 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 = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
double tmp;
if (y <= -9.5e+199) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= -2e+21) {
tmp = t_1;
} else if (y <= 1.75e+30) {
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 = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) tmp = 0 if y <= -9.5e+199: tmp = x + ((z - (x * a)) / y) elif y <= -2e+21: tmp = t_1 elif y <= 1.75e+30: 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(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))) tmp = 0.0 if (y <= -9.5e+199) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= -2e+21) tmp = t_1; elseif (y <= 1.75e+30) 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 = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); tmp = 0.0; if (y <= -9.5e+199) tmp = x + ((z - (x * a)) / y); elseif (y <= -2e+21) tmp = t_1; elseif (y <= 1.75e+30) 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[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -9.5e+199], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2e+21], t$95$1, If[LessEqual[y, 1.75e+30], 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 := \frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\mathbf{if}\;y \leq -9.5 \cdot 10^{+199}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq -2 \cdot 10^{+21}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.75 \cdot 10^{+30}:\\
\;\;\;\;\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 < -9.49999999999999954e199Initial program 0.0%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified62.7%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6488.7%
Simplified88.7%
if -9.49999999999999954e199 < y < -2e21 or 1.75000000000000011e30 < y Initial program 12.9%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr12.9%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr12.9%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6460.4%
Simplified60.4%
if -2e21 < y < 1.75000000000000011e30Initial program 99.6%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6484.7%
Simplified84.7%
Taylor expanded in y around 0
*-lowering-*.f6480.2%
Simplified80.2%
Final simplification73.7%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -5.8e+63)
(+ x (/ (- z (* x a)) y))
(if (<= y 3.8e+40)
(/ (+ t (* y 230661.510616)) (+ (* y (+ (* y (+ b (* y (+ y a)))) c)) i))
(/ -1.0 (+ (/ (- (/ z (* x x)) (/ a x)) y) (/ -1.0 x))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -5.8e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.8e+40) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / 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 <= (-5.8d+63)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 3.8d+40) then
tmp = (t + (y * 230661.510616d0)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i)
else
tmp = (-1.0d0) / ((((z / (x * x)) - (a / x)) / y) + ((-1.0d0) / 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 <= -5.8e+63) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 3.8e+40) {
tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i);
} else {
tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -5.8e+63: tmp = x + ((z - (x * a)) / y) elif y <= 3.8e+40: tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i) else: tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -5.8e+63) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 3.8e+40) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(Float64(y * Float64(Float64(y * Float64(b + Float64(y * Float64(y + a)))) + c)) + i)); else tmp = Float64(-1.0 / Float64(Float64(Float64(Float64(z / Float64(x * x)) - Float64(a / x)) / y) + Float64(-1.0 / x))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -5.8e+63) tmp = x + ((z - (x * a)) / y); elseif (y <= 3.8e+40) tmp = (t + (y * 230661.510616)) / ((y * ((y * (b + (y * (y + a)))) + c)) + i); else tmp = -1.0 / ((((z / (x * x)) - (a / x)) / y) + (-1.0 / x)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -5.8e+63], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e+40], 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], N[(-1.0 / N[(N[(N[(N[(z / N[(x * x), $MachinePrecision]), $MachinePrecision] - N[(a / x), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.8 \cdot 10^{+63}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{+40}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{y \cdot \left(y \cdot \left(b + y \cdot \left(y + a\right)\right) + c\right) + i}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{\frac{z}{x \cdot x} - \frac{a}{x}}{y} + \frac{-1}{x}}\\
\end{array}
\end{array}
if y < -5.7999999999999999e63Initial program 6.2%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified51.4%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6470.8%
Simplified70.8%
if -5.7999999999999999e63 < y < 3.80000000000000004e40Initial program 95.6%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6479.3%
Simplified79.3%
if 3.80000000000000004e40 < y Initial program 6.9%
flip-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip-+N/A
/-lowering-/.f64N/A
Applied egg-rr6.9%
div-invN/A
frac-2negN/A
metadata-evalN/A
frac-timesN/A
metadata-evalN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
Applied egg-rr6.9%
Taylor expanded in y around inf
--lowering--.f64N/A
associate-*r/N/A
distribute-lft-out--N/A
/-lowering-/.f64N/A
distribute-lft-out--N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6466.5%
Simplified66.5%
Final simplification74.6%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -6.8e-7)
(+ x (/ (- z (* x a)) y))
(if (<= y 4.4e-124)
(/ (+ t (* y 230661.510616)) (+ i (* y c)))
(if (<= y 9.6e+36)
(/ t (+ i (* (* y y) (+ b (* y (+ y a))))))
(+ x (/ (+ (/ 27464.7644705 y) (- z (/ (* x b) y))) y))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 4.4e-124) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else if (y <= 9.6e+36) {
tmp = t / (i + ((y * y) * (b + (y * (y + a)))));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / 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 <= (-6.8d-7)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 4.4d-124) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * c))
else if (y <= 9.6d+36) then
tmp = t / (i + ((y * y) * (b + (y * (y + a)))))
else
tmp = x + (((27464.7644705d0 / y) + (z - ((x * b) / y))) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 4.4e-124) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else if (y <= 9.6e+36) {
tmp = t / (i + ((y * y) * (b + (y * (y + a)))));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -6.8e-7: tmp = x + ((z - (x * a)) / y) elif y <= 4.4e-124: tmp = (t + (y * 230661.510616)) / (i + (y * c)) elif y <= 9.6e+36: tmp = t / (i + ((y * y) * (b + (y * (y + a))))) else: tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -6.8e-7) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 4.4e-124) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * c))); elseif (y <= 9.6e+36) tmp = Float64(t / Float64(i + Float64(Float64(y * y) * Float64(b + Float64(y * Float64(y + a)))))); else tmp = Float64(x + Float64(Float64(Float64(27464.7644705 / y) + Float64(z - Float64(Float64(x * b) / y))) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -6.8e-7) tmp = x + ((z - (x * a)) / y); elseif (y <= 4.4e-124) tmp = (t + (y * 230661.510616)) / (i + (y * c)); elseif (y <= 9.6e+36) tmp = t / (i + ((y * y) * (b + (y * (y + a))))); else tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -6.8e-7], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.4e-124], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.6e+36], N[(t / N[(i + N[(N[(y * y), $MachinePrecision] * N[(b + N[(y * N[(y + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(N[(27464.7644705 / y), $MachinePrecision] + N[(z - N[(N[(x * b), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{-7}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 4.4 \cdot 10^{-124}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot c}\\
\mathbf{elif}\;y \leq 9.6 \cdot 10^{+36}:\\
\;\;\;\;\frac{t}{i + \left(y \cdot y\right) \cdot \left(b + y \cdot \left(y + a\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{\frac{27464.7644705}{y} + \left(z - \frac{x \cdot b}{y}\right)}{y}\\
\end{array}
\end{array}
if y < -6.79999999999999948e-7Initial program 17.7%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified42.8%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6457.1%
Simplified57.1%
if -6.79999999999999948e-7 < y < 4.3999999999999998e-124Initial program 99.8%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6496.9%
Simplified96.9%
Taylor expanded in y around 0
*-lowering-*.f6491.5%
Simplified91.5%
if 4.3999999999999998e-124 < y < 9.5999999999999997e36Initial program 96.5%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified78.0%
Taylor expanded in t around inf
Simplified43.6%
if 9.5999999999999997e36 < y Initial program 8.4%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified52.5%
Taylor expanded in a around 0
/-lowering-/.f64N/A
associate--r+N/A
--lowering--.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6461.1%
Simplified61.1%
Final simplification68.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ t (* y 230661.510616))))
(if (<= y -6.8e-7)
(+ x (/ (- z (* x a)) y))
(if (<= y 1.2e-137)
(/ t_1 (+ i (* y c)))
(if (<= y 7e+82)
(/ t_1 (+ i (* b (* y y))))
(- (+ x (/ z y)) (/ (* x a) y)))))))
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 <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.2e-137) {
tmp = t_1 / (i + (y * c));
} else if (y <= 7e+82) {
tmp = t_1 / (i + (b * (y * y)));
} else {
tmp = (x + (z / y)) - ((x * a) / 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 = t + (y * 230661.510616d0)
if (y <= (-6.8d-7)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 1.2d-137) then
tmp = t_1 / (i + (y * c))
else if (y <= 7d+82) then
tmp = t_1 / (i + (b * (y * y)))
else
tmp = (x + (z / y)) - ((x * a) / 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 = t + (y * 230661.510616);
double tmp;
if (y <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 1.2e-137) {
tmp = t_1 / (i + (y * c));
} else if (y <= 7e+82) {
tmp = t_1 / (i + (b * (y * y)));
} else {
tmp = (x + (z / y)) - ((x * a) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = t + (y * 230661.510616) tmp = 0 if y <= -6.8e-7: tmp = x + ((z - (x * a)) / y) elif y <= 1.2e-137: tmp = t_1 / (i + (y * c)) elif y <= 7e+82: tmp = t_1 / (i + (b * (y * y))) else: tmp = (x + (z / y)) - ((x * a) / y) 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 <= -6.8e-7) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 1.2e-137) tmp = Float64(t_1 / Float64(i + Float64(y * c))); elseif (y <= 7e+82) tmp = Float64(t_1 / Float64(i + Float64(b * Float64(y * y)))); else tmp = Float64(Float64(x + Float64(z / y)) - Float64(Float64(x * a) / y)); 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 <= -6.8e-7) tmp = x + ((z - (x * a)) / y); elseif (y <= 1.2e-137) tmp = t_1 / (i + (y * c)); elseif (y <= 7e+82) tmp = t_1 / (i + (b * (y * y))); else tmp = (x + (z / y)) - ((x * a) / y); 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, -6.8e-7], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.2e-137], N[(t$95$1 / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7e+82], N[(t$95$1 / N[(i + N[(b * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + y \cdot 230661.510616\\
\mathbf{if}\;y \leq -6.8 \cdot 10^{-7}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 1.2 \cdot 10^{-137}:\\
\;\;\;\;\frac{t\_1}{i + y \cdot c}\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+82}:\\
\;\;\;\;\frac{t\_1}{i + b \cdot \left(y \cdot y\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(x + \frac{z}{y}\right) - \frac{x \cdot a}{y}\\
\end{array}
\end{array}
if y < -6.79999999999999948e-7Initial program 17.7%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified42.8%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6457.1%
Simplified57.1%
if -6.79999999999999948e-7 < y < 1.2e-137Initial program 99.8%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6497.7%
Simplified97.7%
Taylor expanded in y around 0
*-lowering-*.f6492.1%
Simplified92.1%
if 1.2e-137 < y < 7.0000000000000001e82Initial program 82.4%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6448.2%
Simplified48.2%
Taylor expanded in b around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6432.1%
Simplified32.1%
if 7.0000000000000001e82 < y Initial program 0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
remove-double-negN/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
remove-double-negN/A
*-lowering-*.f6470.2%
Simplified70.2%
Final simplification67.1%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -7.4e+31)
(+ x (/ (- z (* x a)) y))
(if (<= y 2.25e-61)
(+ (/ t i) (/ (* y 230661.510616) i))
(if (<= y 7e+82)
(/ (+ t (* y 230661.510616)) (* b (* y y)))
(- (+ x (/ z y)) (/ (* x a) y))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -7.4e+31) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.25e-61) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 7e+82) {
tmp = (t + (y * 230661.510616)) / (b * (y * y));
} else {
tmp = (x + (z / y)) - ((x * a) / 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 <= (-7.4d+31)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 2.25d-61) then
tmp = (t / i) + ((y * 230661.510616d0) / i)
else if (y <= 7d+82) then
tmp = (t + (y * 230661.510616d0)) / (b * (y * y))
else
tmp = (x + (z / y)) - ((x * a) / 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 <= -7.4e+31) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.25e-61) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 7e+82) {
tmp = (t + (y * 230661.510616)) / (b * (y * y));
} else {
tmp = (x + (z / y)) - ((x * a) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -7.4e+31: tmp = x + ((z - (x * a)) / y) elif y <= 2.25e-61: tmp = (t / i) + ((y * 230661.510616) / i) elif y <= 7e+82: tmp = (t + (y * 230661.510616)) / (b * (y * y)) else: tmp = (x + (z / y)) - ((x * a) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -7.4e+31) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 2.25e-61) tmp = Float64(Float64(t / i) + Float64(Float64(y * 230661.510616) / i)); elseif (y <= 7e+82) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(b * Float64(y * y))); else tmp = Float64(Float64(x + Float64(z / y)) - Float64(Float64(x * a) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -7.4e+31) tmp = x + ((z - (x * a)) / y); elseif (y <= 2.25e-61) tmp = (t / i) + ((y * 230661.510616) / i); elseif (y <= 7e+82) tmp = (t + (y * 230661.510616)) / (b * (y * y)); else tmp = (x + (z / y)) - ((x * a) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -7.4e+31], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.25e-61], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7e+82], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(b * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7.4 \cdot 10^{+31}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 2.25 \cdot 10^{-61}:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+82}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{b \cdot \left(y \cdot y\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(x + \frac{z}{y}\right) - \frac{x \cdot a}{y}\\
\end{array}
\end{array}
if y < -7.3999999999999996e31Initial program 10.9%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified47.1%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6462.8%
Simplified62.8%
if -7.3999999999999996e31 < y < 2.25e-61Initial program 98.8%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified82.2%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6468.2%
Simplified68.2%
if 2.25e-61 < y < 7.0000000000000001e82Initial program 74.8%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6430.3%
Simplified30.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6416.8%
Simplified16.8%
if 7.0000000000000001e82 < y Initial program 0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
remove-double-negN/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
remove-double-negN/A
*-lowering-*.f6470.2%
Simplified70.2%
Final simplification60.1%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -3.5e+30)
(+ x (/ (- z (* x a)) y))
(if (<= y 4.8e-55)
(+ (/ t i) (/ (* y 230661.510616) i))
(if (<= y 2.15e+86)
(/ (- 27464.7644705 (* x b)) (* y y))
(- (+ x (/ z y)) (/ (* x a) 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+30) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 4.8e-55) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 2.15e+86) {
tmp = (27464.7644705 - (x * b)) / (y * y);
} else {
tmp = (x + (z / y)) - ((x * a) / 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+30)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 4.8d-55) then
tmp = (t / i) + ((y * 230661.510616d0) / i)
else if (y <= 2.15d+86) then
tmp = (27464.7644705d0 - (x * b)) / (y * y)
else
tmp = (x + (z / y)) - ((x * a) / 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+30) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 4.8e-55) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 2.15e+86) {
tmp = (27464.7644705 - (x * b)) / (y * y);
} else {
tmp = (x + (z / y)) - ((x * a) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -3.5e+30: tmp = x + ((z - (x * a)) / y) elif y <= 4.8e-55: tmp = (t / i) + ((y * 230661.510616) / i) elif y <= 2.15e+86: tmp = (27464.7644705 - (x * b)) / (y * y) else: tmp = (x + (z / y)) - ((x * a) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -3.5e+30) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 4.8e-55) tmp = Float64(Float64(t / i) + Float64(Float64(y * 230661.510616) / i)); elseif (y <= 2.15e+86) tmp = Float64(Float64(27464.7644705 - Float64(x * b)) / Float64(y * y)); else tmp = Float64(Float64(x + Float64(z / y)) - Float64(Float64(x * a) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -3.5e+30) tmp = x + ((z - (x * a)) / y); elseif (y <= 4.8e-55) tmp = (t / i) + ((y * 230661.510616) / i); elseif (y <= 2.15e+86) tmp = (27464.7644705 - (x * b)) / (y * y); else tmp = (x + (z / y)) - ((x * a) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -3.5e+30], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.8e-55], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.15e+86], N[(N[(27464.7644705 - N[(x * b), $MachinePrecision]), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.5 \cdot 10^{+30}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 4.8 \cdot 10^{-55}:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{elif}\;y \leq 2.15 \cdot 10^{+86}:\\
\;\;\;\;\frac{27464.7644705 - x \cdot b}{y \cdot y}\\
\mathbf{else}:\\
\;\;\;\;\left(x + \frac{z}{y}\right) - \frac{x \cdot a}{y}\\
\end{array}
\end{array}
if y < -3.50000000000000021e30Initial program 10.9%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified47.1%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6462.8%
Simplified62.8%
if -3.50000000000000021e30 < y < 4.79999999999999983e-55Initial program 98.8%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified81.8%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6467.2%
Simplified67.2%
if 4.79999999999999983e-55 < y < 2.1500000000000001e86Initial program 71.3%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified13.0%
Taylor expanded in y around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6413.7%
Simplified13.7%
Taylor expanded in a around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6414.8%
Simplified14.8%
if 2.1500000000000001e86 < y Initial program 0.2%
Taylor expanded in y around inf
--lowering--.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
remove-double-negN/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
remove-double-negN/A
*-lowering-*.f6471.5%
Simplified71.5%
Final simplification59.9%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -7e+28)
(+ x (/ (- z (* x a)) y))
(if (<= y 2.05e+36)
(/ (+ t (* y 230661.510616)) (+ i (* y (+ c (* y b)))))
(+ x (/ (+ (/ 27464.7644705 y) (- z (/ (* x b) y))) y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -7e+28) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.05e+36) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b))));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / 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 <= (-7d+28)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 2.05d+36) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * (c + (y * b))))
else
tmp = x + (((27464.7644705d0 / y) + (z - ((x * b) / y))) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -7e+28) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 2.05e+36) {
tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b))));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -7e+28: tmp = x + ((z - (x * a)) / y) elif y <= 2.05e+36: tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b)))) else: tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -7e+28) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 2.05e+36) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * Float64(c + Float64(y * b))))); else tmp = Float64(x + Float64(Float64(Float64(27464.7644705 / y) + Float64(z - Float64(Float64(x * b) / y))) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -7e+28) tmp = x + ((z - (x * a)) / y); elseif (y <= 2.05e+36) tmp = (t + (y * 230661.510616)) / (i + (y * (c + (y * b)))); else tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -7e+28], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.05e+36], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * N[(c + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(N[(27464.7644705 / y), $MachinePrecision] + N[(z - N[(N[(x * b), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -7 \cdot 10^{+28}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 2.05 \cdot 10^{+36}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot \left(c + y \cdot b\right)}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{\frac{27464.7644705}{y} + \left(z - \frac{x \cdot b}{y}\right)}{y}\\
\end{array}
\end{array}
if y < -6.9999999999999999e28Initial program 10.9%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified47.1%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6462.8%
Simplified62.8%
if -6.9999999999999999e28 < y < 2.05000000000000006e36Initial program 98.2%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6482.9%
Simplified82.9%
Taylor expanded in y around 0
*-lowering-*.f6478.5%
Simplified78.5%
if 2.05000000000000006e36 < y Initial program 8.4%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified52.5%
Taylor expanded in a around 0
/-lowering-/.f64N/A
associate--r+N/A
--lowering--.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6461.1%
Simplified61.1%
Final simplification70.8%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -6.8e-7)
(+ x (/ (- z (* x a)) y))
(if (<= y 6.2e+34)
(/ (+ t (* y 230661.510616)) (+ i (* y c)))
(+ x (/ (+ (/ 27464.7644705 y) (- z (/ (* x b) y))) y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 6.2e+34) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / 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 <= (-6.8d-7)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 6.2d+34) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * c))
else
tmp = x + (((27464.7644705d0 / y) + (z - ((x * b) / y))) / y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.8e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 6.2e+34) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else {
tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -6.8e-7: tmp = x + ((z - (x * a)) / y) elif y <= 6.2e+34: tmp = (t + (y * 230661.510616)) / (i + (y * c)) else: tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -6.8e-7) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 6.2e+34) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * c))); else tmp = Float64(x + Float64(Float64(Float64(27464.7644705 / y) + Float64(z - Float64(Float64(x * b) / y))) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -6.8e-7) tmp = x + ((z - (x * a)) / y); elseif (y <= 6.2e+34) tmp = (t + (y * 230661.510616)) / (i + (y * c)); else tmp = x + (((27464.7644705 / y) + (z - ((x * b) / y))) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -6.8e-7], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.2e+34], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(N[(27464.7644705 / y), $MachinePrecision] + N[(z - N[(N[(x * b), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{-7}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 6.2 \cdot 10^{+34}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot c}\\
\mathbf{else}:\\
\;\;\;\;x + \frac{\frac{27464.7644705}{y} + \left(z - \frac{x \cdot b}{y}\right)}{y}\\
\end{array}
\end{array}
if y < -6.79999999999999948e-7Initial program 17.7%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified42.8%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6457.1%
Simplified57.1%
if -6.79999999999999948e-7 < y < 6.19999999999999955e34Initial program 98.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6486.6%
Simplified86.6%
Taylor expanded in y around 0
*-lowering-*.f6473.9%
Simplified73.9%
if 6.19999999999999955e34 < y Initial program 8.4%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified52.5%
Taylor expanded in a around 0
/-lowering-/.f64N/A
associate--r+N/A
--lowering--.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f6461.1%
Simplified61.1%
Final simplification66.7%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (/ (- z (* x a)) y))))
(if (<= y -1.22e+33)
t_1
(if (<= y 4.8e-55)
(+ (/ t i) (/ (* y 230661.510616) i))
(if (<= y 2.15e+86) (/ (- 27464.7644705 (* x b)) (* y y)) 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 - (x * a)) / y);
double tmp;
if (y <= -1.22e+33) {
tmp = t_1;
} else if (y <= 4.8e-55) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 2.15e+86) {
tmp = (27464.7644705 - (x * b)) / (y * y);
} 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 - (x * a)) / y)
if (y <= (-1.22d+33)) then
tmp = t_1
else if (y <= 4.8d-55) then
tmp = (t / i) + ((y * 230661.510616d0) / i)
else if (y <= 2.15d+86) then
tmp = (27464.7644705d0 - (x * b)) / (y * y)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z - (x * a)) / y);
double tmp;
if (y <= -1.22e+33) {
tmp = t_1;
} else if (y <= 4.8e-55) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 2.15e+86) {
tmp = (27464.7644705 - (x * b)) / (y * y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z - (x * a)) / y) tmp = 0 if y <= -1.22e+33: tmp = t_1 elif y <= 4.8e-55: tmp = (t / i) + ((y * 230661.510616) / i) elif y <= 2.15e+86: tmp = (27464.7644705 - (x * b)) / (y * y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z - Float64(x * a)) / y)) tmp = 0.0 if (y <= -1.22e+33) tmp = t_1; elseif (y <= 4.8e-55) tmp = Float64(Float64(t / i) + Float64(Float64(y * 230661.510616) / i)); elseif (y <= 2.15e+86) tmp = Float64(Float64(27464.7644705 - Float64(x * b)) / Float64(y * y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z - (x * a)) / y); tmp = 0.0; if (y <= -1.22e+33) tmp = t_1; elseif (y <= 4.8e-55) tmp = (t / i) + ((y * 230661.510616) / i); elseif (y <= 2.15e+86) tmp = (27464.7644705 - (x * b)) / (y * y); 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 - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.22e+33], t$95$1, If[LessEqual[y, 4.8e-55], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.15e+86], N[(N[(27464.7644705 - N[(x * b), $MachinePrecision]), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{z - x \cdot a}{y}\\
\mathbf{if}\;y \leq -1.22 \cdot 10^{+33}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 4.8 \cdot 10^{-55}:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{elif}\;y \leq 2.15 \cdot 10^{+86}:\\
\;\;\;\;\frac{27464.7644705 - x \cdot b}{y \cdot y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.22000000000000005e33 or 2.1500000000000001e86 < y Initial program 6.0%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified52.7%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6466.8%
Simplified66.8%
if -1.22000000000000005e33 < y < 4.79999999999999983e-55Initial program 98.8%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified81.8%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6467.2%
Simplified67.2%
if 4.79999999999999983e-55 < y < 2.1500000000000001e86Initial program 71.3%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified13.0%
Taylor expanded in y around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6413.7%
Simplified13.7%
Taylor expanded in a around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6414.8%
Simplified14.8%
Final simplification59.9%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (/ (- z (* x a)) y))))
(if (<= y -2.7e+31)
t_1
(if (<= y 3.2e-32)
(+ (/ t i) (/ (* y 230661.510616) i))
(if (<= y 7e+82) (/ t (* a (* y (* y y)))) 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 - (x * a)) / y);
double tmp;
if (y <= -2.7e+31) {
tmp = t_1;
} else if (y <= 3.2e-32) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 7e+82) {
tmp = t / (a * (y * (y * y)));
} 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 - (x * a)) / y)
if (y <= (-2.7d+31)) then
tmp = t_1
else if (y <= 3.2d-32) then
tmp = (t / i) + ((y * 230661.510616d0) / i)
else if (y <= 7d+82) then
tmp = t / (a * (y * (y * y)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double t_1 = x + ((z - (x * a)) / y);
double tmp;
if (y <= -2.7e+31) {
tmp = t_1;
} else if (y <= 3.2e-32) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else if (y <= 7e+82) {
tmp = t / (a * (y * (y * y)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z - (x * a)) / y) tmp = 0 if y <= -2.7e+31: tmp = t_1 elif y <= 3.2e-32: tmp = (t / i) + ((y * 230661.510616) / i) elif y <= 7e+82: tmp = t / (a * (y * (y * y))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i) t_1 = Float64(x + Float64(Float64(z - Float64(x * a)) / y)) tmp = 0.0 if (y <= -2.7e+31) tmp = t_1; elseif (y <= 3.2e-32) tmp = Float64(Float64(t / i) + Float64(Float64(y * 230661.510616) / i)); elseif (y <= 7e+82) tmp = Float64(t / Float64(a * Float64(y * Float64(y * y)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) t_1 = x + ((z - (x * a)) / y); tmp = 0.0; if (y <= -2.7e+31) tmp = t_1; elseif (y <= 3.2e-32) tmp = (t / i) + ((y * 230661.510616) / i); elseif (y <= 7e+82) tmp = t / (a * (y * (y * y))); 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 - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.7e+31], t$95$1, If[LessEqual[y, 3.2e-32], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7e+82], N[(t / N[(a * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{z - x \cdot a}{y}\\
\mathbf{if}\;y \leq -2.7 \cdot 10^{+31}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{-32}:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{elif}\;y \leq 7 \cdot 10^{+82}:\\
\;\;\;\;\frac{t}{a \cdot \left(y \cdot \left(y \cdot y\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.69999999999999986e31 or 7.0000000000000001e82 < y Initial program 5.9%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified52.2%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6466.2%
Simplified66.2%
if -2.69999999999999986e31 < y < 3.2000000000000002e-32Initial program 98.8%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified81.5%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6465.0%
Simplified65.0%
if 3.2000000000000002e-32 < y < 7.0000000000000001e82Initial program 70.0%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6423.1%
Simplified23.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.3%
Simplified17.3%
Taylor expanded in y around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6416.8%
Simplified16.8%
Final simplification59.8%
(FPCore (x y z t a b c i)
:precision binary64
(if (<= y -6.1e-7)
(+ x (/ (- z (* x a)) y))
(if (<= y 5.8e+44)
(/ (+ t (* y 230661.510616)) (+ i (* y c)))
(- (+ x (/ z y)) (/ (* x a) y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -6.1e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 5.8e+44) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else {
tmp = (x + (z / y)) - ((x * a) / 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 <= (-6.1d-7)) then
tmp = x + ((z - (x * a)) / y)
else if (y <= 5.8d+44) then
tmp = (t + (y * 230661.510616d0)) / (i + (y * c))
else
tmp = (x + (z / y)) - ((x * a) / 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 <= -6.1e-7) {
tmp = x + ((z - (x * a)) / y);
} else if (y <= 5.8e+44) {
tmp = (t + (y * 230661.510616)) / (i + (y * c));
} else {
tmp = (x + (z / y)) - ((x * a) / y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -6.1e-7: tmp = x + ((z - (x * a)) / y) elif y <= 5.8e+44: tmp = (t + (y * 230661.510616)) / (i + (y * c)) else: tmp = (x + (z / y)) - ((x * a) / y) return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -6.1e-7) tmp = Float64(x + Float64(Float64(z - Float64(x * a)) / y)); elseif (y <= 5.8e+44) tmp = Float64(Float64(t + Float64(y * 230661.510616)) / Float64(i + Float64(y * c))); else tmp = Float64(Float64(x + Float64(z / y)) - Float64(Float64(x * a) / y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -6.1e-7) tmp = x + ((z - (x * a)) / y); elseif (y <= 5.8e+44) tmp = (t + (y * 230661.510616)) / (i + (y * c)); else tmp = (x + (z / y)) - ((x * a) / y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -6.1e-7], N[(x + N[(N[(z - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.8e+44], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / N[(i + N[(y * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x + N[(z / y), $MachinePrecision]), $MachinePrecision] - N[(N[(x * a), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.1 \cdot 10^{-7}:\\
\;\;\;\;x + \frac{z - x \cdot a}{y}\\
\mathbf{elif}\;y \leq 5.8 \cdot 10^{+44}:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i + y \cdot c}\\
\mathbf{else}:\\
\;\;\;\;\left(x + \frac{z}{y}\right) - \frac{x \cdot a}{y}\\
\end{array}
\end{array}
if y < -6.09999999999999983e-7Initial program 17.7%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified42.8%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6457.1%
Simplified57.1%
if -6.09999999999999983e-7 < y < 5.8000000000000004e44Initial program 98.2%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6485.3%
Simplified85.3%
Taylor expanded in y around 0
*-lowering-*.f6472.8%
Simplified72.8%
if 5.8000000000000004e44 < y Initial program 6.9%
Taylor expanded in y around inf
--lowering--.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
remove-double-negN/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
remove-double-negN/A
*-lowering-*.f6458.0%
Simplified58.0%
Final simplification65.5%
(FPCore (x y z t a b c i)
:precision binary64
(let* ((t_1 (+ x (/ (- z (* x a)) y))))
(if (<= y -5.8e+28)
t_1
(if (<= y 5.5e+42) (+ (/ t i) (/ (* 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 - (x * a)) / y);
double tmp;
if (y <= -5.8e+28) {
tmp = t_1;
} else if (y <= 5.5e+42) {
tmp = (t / i) + ((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 - (x * a)) / y)
if (y <= (-5.8d+28)) then
tmp = t_1
else if (y <= 5.5d+42) then
tmp = (t / i) + ((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 - (x * a)) / y);
double tmp;
if (y <= -5.8e+28) {
tmp = t_1;
} else if (y <= 5.5e+42) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): t_1 = x + ((z - (x * a)) / y) tmp = 0 if y <= -5.8e+28: tmp = t_1 elif y <= 5.5e+42: tmp = (t / i) + ((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 - Float64(x * a)) / y)) tmp = 0.0 if (y <= -5.8e+28) tmp = t_1; elseif (y <= 5.5e+42) tmp = Float64(Float64(t / i) + Float64(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 - (x * a)) / y); tmp = 0.0; if (y <= -5.8e+28) tmp = t_1; elseif (y <= 5.5e+42) tmp = (t / i) + ((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 - N[(x * a), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -5.8e+28], t$95$1, If[LessEqual[y, 5.5e+42], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{z - x \cdot a}{y}\\
\mathbf{if}\;y \leq -5.8 \cdot 10^{+28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{+42}:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -5.8000000000000002e28 or 5.50000000000000001e42 < y Initial program 8.9%
Taylor expanded in y around -inf
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
Simplified49.9%
Taylor expanded in y around inf
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f6460.4%
Simplified60.4%
if -5.8000000000000002e28 < y < 5.50000000000000001e42Initial program 97.5%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified80.4%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6456.5%
Simplified56.5%
Final simplification58.2%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -8.5e+32) x (if (<= y 1950000.0) (+ (/ t i) (/ (* 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 <= -8.5e+32) {
tmp = x;
} else if (y <= 1950000.0) {
tmp = (t / i) + ((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 <= (-8.5d+32)) then
tmp = x
else if (y <= 1950000.0d0) then
tmp = (t / i) + ((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 <= -8.5e+32) {
tmp = x;
} else if (y <= 1950000.0) {
tmp = (t / i) + ((y * 230661.510616) / i);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -8.5e+32: tmp = x elif y <= 1950000.0: tmp = (t / i) + ((y * 230661.510616) / i) else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -8.5e+32) tmp = x; elseif (y <= 1950000.0) tmp = Float64(Float64(t / i) + Float64(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 <= -8.5e+32) tmp = x; elseif (y <= 1950000.0) tmp = (t / i) + ((y * 230661.510616) / i); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -8.5e+32], x, If[LessEqual[y, 1950000.0], N[(N[(t / i), $MachinePrecision] + N[(N[(y * 230661.510616), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.5 \cdot 10^{+32}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1950000:\\
\;\;\;\;\frac{t}{i} + \frac{y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -8.4999999999999998e32 or 1.95e6 < y Initial program 14.4%
Taylor expanded in y around inf
Simplified45.4%
if -8.4999999999999998e32 < y < 1.95e6Initial program 98.9%
Taylor expanded in c around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified81.2%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6460.7%
Simplified60.7%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -1.52e+29) x (if (<= y 6100000.0) (/ (+ 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.52e+29) {
tmp = x;
} else if (y <= 6100000.0) {
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.52d+29)) then
tmp = x
else if (y <= 6100000.0d0) 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.52e+29) {
tmp = x;
} else if (y <= 6100000.0) {
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.52e+29: tmp = x elif y <= 6100000.0: 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.52e+29) tmp = x; elseif (y <= 6100000.0) 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.52e+29) tmp = x; elseif (y <= 6100000.0) 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.52e+29], x, If[LessEqual[y, 6100000.0], N[(N[(t + N[(y * 230661.510616), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.52 \cdot 10^{+29}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 6100000:\\
\;\;\;\;\frac{t + y \cdot 230661.510616}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -1.52e29 or 6.1e6 < y Initial program 14.4%
Taylor expanded in y around inf
Simplified45.4%
if -1.52e29 < y < 6.1e6Initial program 98.9%
Taylor expanded in y around 0
*-commutativeN/A
*-lowering-*.f6487.7%
Simplified87.7%
Taylor expanded in y around 0
Simplified60.6%
Final simplification53.1%
(FPCore (x y z t a b c i) :precision binary64 (if (<= y -2.7e+30) x (if (<= y 1.15e-54) (/ t i) x)))
double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -2.7e+30) {
tmp = x;
} else if (y <= 1.15e-54) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8) :: tmp
if (y <= (-2.7d+30)) then
tmp = x
else if (y <= 1.15d-54) then
tmp = t / i
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i) {
double tmp;
if (y <= -2.7e+30) {
tmp = x;
} else if (y <= 1.15e-54) {
tmp = t / i;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i): tmp = 0 if y <= -2.7e+30: tmp = x elif y <= 1.15e-54: tmp = t / i else: tmp = x return tmp
function code(x, y, z, t, a, b, c, i) tmp = 0.0 if (y <= -2.7e+30) tmp = x; elseif (y <= 1.15e-54) tmp = Float64(t / i); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i) tmp = 0.0; if (y <= -2.7e+30) tmp = x; elseif (y <= 1.15e-54) tmp = t / i; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_] := If[LessEqual[y, -2.7e+30], x, If[LessEqual[y, 1.15e-54], N[(t / i), $MachinePrecision], x]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.7 \cdot 10^{+30}:\\
\;\;\;\;x\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-54}:\\
\;\;\;\;\frac{t}{i}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if y < -2.6999999999999999e30 or 1.1499999999999999e-54 < y Initial program 21.8%
Taylor expanded in y around inf
Simplified41.7%
if -2.6999999999999999e30 < y < 1.1499999999999999e-54Initial program 98.8%
Taylor expanded in y around 0
/-lowering-/.f6454.8%
Simplified54.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 57.0%
Taylor expanded in y around inf
Simplified24.2%
herbie shell --seed 2024160
(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)))