Jmat.Real.gamma, branch z greater than 0.5

Specification

?
\[z > \frac{1}{2}\]
\[\begin{array}{l} t_0 := \left(z - 1\right) + 7\\ t_1 := t\_0 + \frac{1}{2}\\ \left(\left(\sqrt{\pi \cdot 2} \cdot {t\_1}^{\left(\left(z - 1\right) + \frac{1}{2}\right)}\right) \cdot e^{-t\_1}\right) \cdot \left(\left(\left(\left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \frac{\frac{6765203681218851}{10000000000000}}{\left(z - 1\right) + 1}\right) + \frac{\frac{-3147848041806007}{2500000000000}}{\left(z - 1\right) + 2}\right) + \frac{\frac{7713234287776531}{10000000000000}}{\left(z - 1\right) + 3}\right) + \frac{\frac{-883075145810703}{5000000000000}}{\left(z - 1\right) + 4}\right) + \frac{\frac{2501468655737381}{200000000000000}}{\left(z - 1\right) + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{\left(z - 1\right) + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_0}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{\left(z - 1\right) + 8}\right) \end{array} \]
(FPCore (z)
  :precision binary64
  (let* ((t_0 (+ (- z 1) 7)) (t_1 (+ t_0 1/2)))
  (*
   (* (* (sqrt (* PI 2)) (pow t_1 (+ (- z 1) 1/2))) (exp (- t_1)))
   (+
    (+
     (+
      (+
       (+
        (+
         (+
          (+
           9999999999998099/10000000000000000
           (/ 6765203681218851/10000000000000 (+ (- z 1) 1)))
          (/ -3147848041806007/2500000000000 (+ (- z 1) 2)))
         (/ 7713234287776531/10000000000000 (+ (- z 1) 3)))
        (/ -883075145810703/5000000000000 (+ (- z 1) 4)))
       (/ 2501468655737381/200000000000000 (+ (- z 1) 5)))
      (/ -3464277381643003/25000000000000000 (+ (- z 1) 6)))
     (/ 2496092394504893/250000000000000000000 t_0))
    (/ 3764081837873279/25000000000000000000000 (+ (- z 1) 8))))))
double code(double z) {
	double t_0 = (z - 1.0) + 7.0;
	double t_1 = t_0 + 0.5;
	return ((sqrt((((double) M_PI) * 2.0)) * pow(t_1, ((z - 1.0) + 0.5))) * exp(-t_1)) * ((((((((0.9999999999998099 + (676.5203681218851 / ((z - 1.0) + 1.0))) + (-1259.1392167224028 / ((z - 1.0) + 2.0))) + (771.3234287776531 / ((z - 1.0) + 3.0))) + (-176.6150291621406 / ((z - 1.0) + 4.0))) + (12.507343278686905 / ((z - 1.0) + 5.0))) + (-0.13857109526572012 / ((z - 1.0) + 6.0))) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((z - 1.0) + 8.0)));
}

public static double code(double z) {
	double t_0 = (z - 1.0) + 7.0;
	double t_1 = t_0 + 0.5;
	return ((Math.sqrt((Math.PI * 2.0)) * Math.pow(t_1, ((z - 1.0) + 0.5))) * Math.exp(-t_1)) * ((((((((0.9999999999998099 + (676.5203681218851 / ((z - 1.0) + 1.0))) + (-1259.1392167224028 / ((z - 1.0) + 2.0))) + (771.3234287776531 / ((z - 1.0) + 3.0))) + (-176.6150291621406 / ((z - 1.0) + 4.0))) + (12.507343278686905 / ((z - 1.0) + 5.0))) + (-0.13857109526572012 / ((z - 1.0) + 6.0))) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((z - 1.0) + 8.0)));
}

def code(z):
	t_0 = (z - 1.0) + 7.0
	t_1 = t_0 + 0.5
	return ((math.sqrt((math.pi * 2.0)) * math.pow(t_1, ((z - 1.0) + 0.5))) * math.exp(-t_1)) * ((((((((0.9999999999998099 + (676.5203681218851 / ((z - 1.0) + 1.0))) + (-1259.1392167224028 / ((z - 1.0) + 2.0))) + (771.3234287776531 / ((z - 1.0) + 3.0))) + (-176.6150291621406 / ((z - 1.0) + 4.0))) + (12.507343278686905 / ((z - 1.0) + 5.0))) + (-0.13857109526572012 / ((z - 1.0) + 6.0))) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((z - 1.0) + 8.0)))

function code(z)
	t_0 = Float64(Float64(z - 1.0) + 7.0)
	t_1 = Float64(t_0 + 0.5)
	return Float64(Float64(Float64(sqrt(Float64(pi * 2.0)) * (t_1 ^ Float64(Float64(z - 1.0) + 0.5))) * exp(Float64(-t_1))) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(676.5203681218851 / Float64(Float64(z - 1.0) + 1.0))) + Float64(-1259.1392167224028 / Float64(Float64(z - 1.0) + 2.0))) + Float64(771.3234287776531 / Float64(Float64(z - 1.0) + 3.0))) + Float64(-176.6150291621406 / Float64(Float64(z - 1.0) + 4.0))) + Float64(12.507343278686905 / Float64(Float64(z - 1.0) + 5.0))) + Float64(-0.13857109526572012 / Float64(Float64(z - 1.0) + 6.0))) + Float64(9.984369578019572e-6 / t_0)) + Float64(1.5056327351493116e-7 / Float64(Float64(z - 1.0) + 8.0))))
end

function tmp = code(z)
	t_0 = (z - 1.0) + 7.0;
	t_1 = t_0 + 0.5;
	tmp = ((sqrt((pi * 2.0)) * (t_1 ^ ((z - 1.0) + 0.5))) * exp(-t_1)) * ((((((((0.9999999999998099 + (676.5203681218851 / ((z - 1.0) + 1.0))) + (-1259.1392167224028 / ((z - 1.0) + 2.0))) + (771.3234287776531 / ((z - 1.0) + 3.0))) + (-176.6150291621406 / ((z - 1.0) + 4.0))) + (12.507343278686905 / ((z - 1.0) + 5.0))) + (-0.13857109526572012 / ((z - 1.0) + 6.0))) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((z - 1.0) + 8.0)));
end

code[z_] := Block[{t$95$0 = N[(N[(z - 1), $MachinePrecision] + 7), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 1/2), $MachinePrecision]}, N[(N[(N[(N[Sqrt[N[(Pi * 2), $MachinePrecision]], $MachinePrecision] * N[Power[t$95$1, N[(N[(z - 1), $MachinePrecision] + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$1)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(6765203681218851/10000000000000 / N[(N[(z - 1), $MachinePrecision] + 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3147848041806007/2500000000000 / N[(N[(z - 1), $MachinePrecision] + 2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(7713234287776531/10000000000000 / N[(N[(z - 1), $MachinePrecision] + 3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-883075145810703/5000000000000 / N[(N[(z - 1), $MachinePrecision] + 4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2501468655737381/200000000000000 / N[(N[(z - 1), $MachinePrecision] + 5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(N[(z - 1), $MachinePrecision] + 6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$0), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(N[(z - 1), $MachinePrecision] + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

\begin{array}{l}
t_0 := \left(z - 1\right) + 7\\
t_1 := t\_0 + \frac{1}{2}\\
\left(\left(\sqrt{\pi \cdot 2} \cdot {t\_1}^{\left(\left(z - 1\right) + \frac{1}{2}\right)}\right) \cdot e^{-t\_1}\right) \cdot \left(\left(\left(\left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \frac{\frac{6765203681218851}{10000000000000}}{\left(z - 1\right) + 1}\right) + \frac{\frac{-3147848041806007}{2500000000000}}{\left(z - 1\right) + 2}\right) + \frac{\frac{7713234287776531}{10000000000000}}{\left(z - 1\right) + 3}\right) + \frac{\frac{-883075145810703}{5000000000000}}{\left(z - 1\right) + 4}\right) + \frac{\frac{2501468655737381}{200000000000000}}{\left(z - 1\right) + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{\left(z - 1\right) + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_0}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{\left(z - 1\right) + 8}\right)
\end{array}

Cannot sample enough valid points. (more)