
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (+ t_0 7)) (t_2 (+ t_1 1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (* (sqrt (* PI 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
(+
(+
(+
(+
(+
9999999999998099/10000000000000000
(/ 6765203681218851/10000000000000 (+ t_0 1)))
(/ -3147848041806007/2500000000000 (+ t_0 2)))
(/ 7713234287776531/10000000000000 (+ t_0 3)))
(/ -883075145810703/5000000000000 (+ t_0 4)))
(/ 2501468655737381/200000000000000 (+ t_0 5)))
(/ -3464277381643003/25000000000000000 (+ t_0 6)))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * (((sqrt((((double) M_PI) * 2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (Math.PI / Math.sin((Math.PI * z))) * (((Math.sqrt((Math.PI * 2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = t_0 + 7.0 t_2 = t_1 + 0.5 return (math.pi / math.sin((math.pi * z))) * (((math.sqrt((math.pi * 2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(t_0 + 7.0) t_2 = Float64(t_1 + 0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(sqrt(Float64(pi * 2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(676.5203681218851 / Float64(t_0 + 1.0))) + Float64(-1259.1392167224028 / Float64(t_0 + 2.0))) + Float64(771.3234287776531 / Float64(t_0 + 3.0))) + Float64(-176.6150291621406 / Float64(t_0 + 4.0))) + Float64(12.507343278686905 / Float64(t_0 + 5.0))) + Float64(-0.13857109526572012 / Float64(t_0 + 6.0))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = t_0 + 7.0; t_2 = t_1 + 0.5; tmp = (pi / sin((pi * z))) * (((sqrt((pi * 2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 7), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Sqrt[N[(Pi * 2), $MachinePrecision]], $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(6765203681218851/10000000000000 / N[(t$95$0 + 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3147848041806007/2500000000000 / N[(t$95$0 + 2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(7713234287776531/10000000000000 / N[(t$95$0 + 3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-883075145810703/5000000000000 / N[(t$95$0 + 4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2501468655737381/200000000000000 / N[(t$95$0 + 5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(t$95$0 + 6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := t\_0 + 7\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\sqrt{\pi \cdot 2} \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \frac{\frac{6765203681218851}{10000000000000}}{t\_0 + 1}\right) + \frac{\frac{-3147848041806007}{2500000000000}}{t\_0 + 2}\right) + \frac{\frac{7713234287776531}{10000000000000}}{t\_0 + 3}\right) + \frac{\frac{-883075145810703}{5000000000000}}{t\_0 + 4}\right) + \frac{\frac{2501468655737381}{200000000000000}}{t\_0 + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{t\_0 + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (+ t_0 7)) (t_2 (+ t_1 1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (* (sqrt (* PI 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
(+
(+
(+
(+
(+
9999999999998099/10000000000000000
(/ 6765203681218851/10000000000000 (+ t_0 1)))
(/ -3147848041806007/2500000000000 (+ t_0 2)))
(/ 7713234287776531/10000000000000 (+ t_0 3)))
(/ -883075145810703/5000000000000 (+ t_0 4)))
(/ 2501468655737381/200000000000000 (+ t_0 5)))
(/ -3464277381643003/25000000000000000 (+ t_0 6)))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * (((sqrt((((double) M_PI) * 2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (Math.PI / Math.sin((Math.PI * z))) * (((Math.sqrt((Math.PI * 2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = t_0 + 7.0 t_2 = t_1 + 0.5 return (math.pi / math.sin((math.pi * z))) * (((math.sqrt((math.pi * 2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(t_0 + 7.0) t_2 = Float64(t_1 + 0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(sqrt(Float64(pi * 2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(676.5203681218851 / Float64(t_0 + 1.0))) + Float64(-1259.1392167224028 / Float64(t_0 + 2.0))) + Float64(771.3234287776531 / Float64(t_0 + 3.0))) + Float64(-176.6150291621406 / Float64(t_0 + 4.0))) + Float64(12.507343278686905 / Float64(t_0 + 5.0))) + Float64(-0.13857109526572012 / Float64(t_0 + 6.0))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = t_0 + 7.0; t_2 = t_1 + 0.5; tmp = (pi / sin((pi * z))) * (((sqrt((pi * 2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * ((((((((0.9999999999998099 + (676.5203681218851 / (t_0 + 1.0))) + (-1259.1392167224028 / (t_0 + 2.0))) + (771.3234287776531 / (t_0 + 3.0))) + (-176.6150291621406 / (t_0 + 4.0))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 7), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Sqrt[N[(Pi * 2), $MachinePrecision]], $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(6765203681218851/10000000000000 / N[(t$95$0 + 1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3147848041806007/2500000000000 / N[(t$95$0 + 2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(7713234287776531/10000000000000 / N[(t$95$0 + 3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-883075145810703/5000000000000 / N[(t$95$0 + 4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2501468655737381/200000000000000 / N[(t$95$0 + 5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(t$95$0 + 6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := t\_0 + 7\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\sqrt{\pi \cdot 2} \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \frac{\frac{6765203681218851}{10000000000000}}{t\_0 + 1}\right) + \frac{\frac{-3147848041806007}{2500000000000}}{t\_0 + 2}\right) + \frac{\frac{7713234287776531}{10000000000000}}{t\_0 + 3}\right) + \frac{\frac{-883075145810703}{5000000000000}}{t\_0 + 4}\right) + \frac{\frac{2501468655737381}{200000000000000}}{t\_0 + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{t\_0 + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (+ t_0 7)) (t_2 (+ t_1 1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (* (sqrt (* PI 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
(+
(+
9999999999998099/10000000000000000
(+
(-
(/ 1 (/ (- 1 z) 6765203681218851/10000000000000))
(/ 3147848041806007/2500000000000 (- (- 1 z) -1)))
(-
(/ 7713234287776531/10000000000000 (- (- 1 z) -2))
(/ 883075145810703/5000000000000 (- (- 1 z) -3)))))
(/ 2501468655737381/200000000000000 (+ t_0 5)))
(/ -3464277381643003/25000000000000000 (+ t_0 6)))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * (((sqrt((((double) M_PI) * 2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * (((((0.9999999999998099 + (((1.0 / ((1.0 - z) / 676.5203681218851)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (Math.PI / Math.sin((Math.PI * z))) * (((Math.sqrt((Math.PI * 2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * (((((0.9999999999998099 + (((1.0 / ((1.0 - z) / 676.5203681218851)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = t_0 + 7.0 t_2 = t_1 + 0.5 return (math.pi / math.sin((math.pi * z))) * (((math.sqrt((math.pi * 2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * (((((0.9999999999998099 + (((1.0 / ((1.0 - z) / 676.5203681218851)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(t_0 + 7.0) t_2 = Float64(t_1 + 0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(sqrt(Float64(pi * 2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(Float64(Float64(1.0 / Float64(Float64(1.0 - z) / 676.5203681218851)) - Float64(1259.1392167224028 / Float64(Float64(1.0 - z) - -1.0))) + Float64(Float64(771.3234287776531 / Float64(Float64(1.0 - z) - -2.0)) - Float64(176.6150291621406 / Float64(Float64(1.0 - z) - -3.0))))) + Float64(12.507343278686905 / Float64(t_0 + 5.0))) + Float64(-0.13857109526572012 / Float64(t_0 + 6.0))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = t_0 + 7.0; t_2 = t_1 + 0.5; tmp = (pi / sin((pi * z))) * (((sqrt((pi * 2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * (((((0.9999999999998099 + (((1.0 / ((1.0 - z) / 676.5203681218851)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 7), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Sqrt[N[(Pi * 2), $MachinePrecision]], $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(N[(N[(1 / N[(N[(1 - z), $MachinePrecision] / 6765203681218851/10000000000000), $MachinePrecision]), $MachinePrecision] - N[(3147848041806007/2500000000000 / N[(N[(1 - z), $MachinePrecision] - -1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(7713234287776531/10000000000000 / N[(N[(1 - z), $MachinePrecision] - -2), $MachinePrecision]), $MachinePrecision] - N[(883075145810703/5000000000000 / N[(N[(1 - z), $MachinePrecision] - -3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2501468655737381/200000000000000 / N[(t$95$0 + 5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(t$95$0 + 6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := t\_0 + 7\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\sqrt{\pi \cdot 2} \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \left(\left(\frac{1}{\frac{1 - z}{\frac{6765203681218851}{10000000000000}}} - \frac{\frac{3147848041806007}{2500000000000}}{\left(1 - z\right) - -1}\right) + \left(\frac{\frac{7713234287776531}{10000000000000}}{\left(1 - z\right) - -2} - \frac{\frac{883075145810703}{5000000000000}}{\left(1 - z\right) - -3}\right)\right)\right) + \frac{\frac{2501468655737381}{200000000000000}}{t\_0 + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{t\_0 + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
Initial program 96.4%
Applied rewrites98.3%
lift-/.f64N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f6498.3%
Applied rewrites98.3%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (- 1 (+ z -6))) (t_2 (+ t_1 1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (* (sqrt (* PI 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
(+
(+
9999999999998099/10000000000000000
(+
(-
(/ 6765203681218851/10000000000000 (- 1 z))
(/ 3147848041806007/2500000000000 (- (- 1 z) -1)))
(-
(/ 7713234287776531/10000000000000 (- (- 1 z) -2))
(/ 883075145810703/5000000000000 (- (- 1 z) -3)))))
(/ 2501468655737381/200000000000000 (+ t_0 5)))
(/ -3464277381643003/25000000000000000 (+ t_0 6)))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = 1.0 - (z + -6.0);
double t_2 = t_1 + 0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * (((sqrt((((double) M_PI) * 2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * (((((0.9999999999998099 + (((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = 1.0 - (z + -6.0);
double t_2 = t_1 + 0.5;
return (Math.PI / Math.sin((Math.PI * z))) * (((Math.sqrt((Math.PI * 2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * (((((0.9999999999998099 + (((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = 1.0 - (z + -6.0) t_2 = t_1 + 0.5 return (math.pi / math.sin((math.pi * z))) * (((math.sqrt((math.pi * 2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * (((((0.9999999999998099 + (((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(1.0 - Float64(z + -6.0)) t_2 = Float64(t_1 + 0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(sqrt(Float64(pi * 2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(Float64(Float64(676.5203681218851 / Float64(1.0 - z)) - Float64(1259.1392167224028 / Float64(Float64(1.0 - z) - -1.0))) + Float64(Float64(771.3234287776531 / Float64(Float64(1.0 - z) - -2.0)) - Float64(176.6150291621406 / Float64(Float64(1.0 - z) - -3.0))))) + Float64(12.507343278686905 / Float64(t_0 + 5.0))) + Float64(-0.13857109526572012 / Float64(t_0 + 6.0))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = 1.0 - (z + -6.0); t_2 = t_1 + 0.5; tmp = (pi / sin((pi * z))) * (((sqrt((pi * 2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * (((((0.9999999999998099 + (((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0))))) + (12.507343278686905 / (t_0 + 5.0))) + (-0.13857109526572012 / (t_0 + 6.0))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(1 - N[(z + -6), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[Sqrt[N[(Pi * 2), $MachinePrecision]], $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(N[(N[(6765203681218851/10000000000000 / N[(1 - z), $MachinePrecision]), $MachinePrecision] - N[(3147848041806007/2500000000000 / N[(N[(1 - z), $MachinePrecision] - -1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(7713234287776531/10000000000000 / N[(N[(1 - z), $MachinePrecision] - -2), $MachinePrecision]), $MachinePrecision] - N[(883075145810703/5000000000000 / N[(N[(1 - z), $MachinePrecision] - -3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2501468655737381/200000000000000 / N[(t$95$0 + 5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(t$95$0 + 6), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := 1 - \left(z + -6\right)\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\sqrt{\pi \cdot 2} \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \left(\left(\frac{\frac{6765203681218851}{10000000000000}}{1 - z} - \frac{\frac{3147848041806007}{2500000000000}}{\left(1 - z\right) - -1}\right) + \left(\frac{\frac{7713234287776531}{10000000000000}}{\left(1 - z\right) - -2} - \frac{\frac{883075145810703}{5000000000000}}{\left(1 - z\right) - -3}\right)\right)\right) + \frac{\frac{2501468655737381}{200000000000000}}{t\_0 + 5}\right) + \frac{\frac{-3464277381643003}{25000000000000000}}{t\_0 + 6}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
Initial program 96.4%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) -13/2)))
(*
(/ PI (sin (* PI z)))
(*
(+
(+
(+
(+
9999999999998099/10000000000000000
(-
(/ 6765203681218851/10000000000000 (- 1 z))
(/ 3147848041806007/2500000000000 (- (- 1 z) -1))))
(-
(/ 7713234287776531/10000000000000 (- (- 1 z) -2))
(/ 883075145810703/5000000000000 (- (- 1 z) -3))))
(+
(/ 2501468655737381/200000000000000 (- (- 1 z) -4))
(/ -3464277381643003/25000000000000000 (- (- 1 z) -5))))
(+
(/ 2496092394504893/250000000000000000000 (- (- 1 z) -6))
(/ -3764081837873279/25000000000000000000000 (- -7 (- 1 z)))))
(*
(exp (- t_0))
(* (pow t_0 (- (- 1 z) 1/2)) (sqrt (+ PI PI))))))))double code(double z) {
double t_0 = (1.0 - z) - -6.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * (((((0.9999999999998099 + ((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0)))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0)))) + ((12.507343278686905 / ((1.0 - z) - -4.0)) + (-0.13857109526572012 / ((1.0 - z) - -5.0)))) + ((9.984369578019572e-6 / ((1.0 - z) - -6.0)) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z))))) * (exp(-t_0) * (pow(t_0, ((1.0 - z) - 0.5)) * sqrt((((double) M_PI) + ((double) M_PI))))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - -6.5;
return (Math.PI / Math.sin((Math.PI * z))) * (((((0.9999999999998099 + ((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0)))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0)))) + ((12.507343278686905 / ((1.0 - z) - -4.0)) + (-0.13857109526572012 / ((1.0 - z) - -5.0)))) + ((9.984369578019572e-6 / ((1.0 - z) - -6.0)) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z))))) * (Math.exp(-t_0) * (Math.pow(t_0, ((1.0 - z) - 0.5)) * Math.sqrt((Math.PI + Math.PI)))));
}
def code(z): t_0 = (1.0 - z) - -6.5 return (math.pi / math.sin((math.pi * z))) * (((((0.9999999999998099 + ((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0)))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0)))) + ((12.507343278686905 / ((1.0 - z) - -4.0)) + (-0.13857109526572012 / ((1.0 - z) - -5.0)))) + ((9.984369578019572e-6 / ((1.0 - z) - -6.0)) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z))))) * (math.exp(-t_0) * (math.pow(t_0, ((1.0 - z) - 0.5)) * math.sqrt((math.pi + math.pi)))))
function code(z) t_0 = Float64(Float64(1.0 - z) - -6.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(Float64(Float64(0.9999999999998099 + Float64(Float64(676.5203681218851 / Float64(1.0 - z)) - Float64(1259.1392167224028 / Float64(Float64(1.0 - z) - -1.0)))) + Float64(Float64(771.3234287776531 / Float64(Float64(1.0 - z) - -2.0)) - Float64(176.6150291621406 / Float64(Float64(1.0 - z) - -3.0)))) + Float64(Float64(12.507343278686905 / Float64(Float64(1.0 - z) - -4.0)) + Float64(-0.13857109526572012 / Float64(Float64(1.0 - z) - -5.0)))) + Float64(Float64(9.984369578019572e-6 / Float64(Float64(1.0 - z) - -6.0)) + Float64(-1.5056327351493116e-7 / Float64(-7.0 - Float64(1.0 - z))))) * Float64(exp(Float64(-t_0)) * Float64((t_0 ^ Float64(Float64(1.0 - z) - 0.5)) * sqrt(Float64(pi + pi)))))) end
function tmp = code(z) t_0 = (1.0 - z) - -6.5; tmp = (pi / sin((pi * z))) * (((((0.9999999999998099 + ((676.5203681218851 / (1.0 - z)) - (1259.1392167224028 / ((1.0 - z) - -1.0)))) + ((771.3234287776531 / ((1.0 - z) - -2.0)) - (176.6150291621406 / ((1.0 - z) - -3.0)))) + ((12.507343278686905 / ((1.0 - z) - -4.0)) + (-0.13857109526572012 / ((1.0 - z) - -5.0)))) + ((9.984369578019572e-6 / ((1.0 - z) - -6.0)) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z))))) * (exp(-t_0) * ((t_0 ^ ((1.0 - z) - 0.5)) * sqrt((pi + pi))))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - -13/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(9999999999998099/10000000000000000 + N[(N[(6765203681218851/10000000000000 / N[(1 - z), $MachinePrecision]), $MachinePrecision] - N[(3147848041806007/2500000000000 / N[(N[(1 - z), $MachinePrecision] - -1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(7713234287776531/10000000000000 / N[(N[(1 - z), $MachinePrecision] - -2), $MachinePrecision]), $MachinePrecision] - N[(883075145810703/5000000000000 / N[(N[(1 - z), $MachinePrecision] - -3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(2501468655737381/200000000000000 / N[(N[(1 - z), $MachinePrecision] - -4), $MachinePrecision]), $MachinePrecision] + N[(-3464277381643003/25000000000000000 / N[(N[(1 - z), $MachinePrecision] - -5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(2496092394504893/250000000000000000000 / N[(N[(1 - z), $MachinePrecision] - -6), $MachinePrecision]), $MachinePrecision] + N[(-3764081837873279/25000000000000000000000 / N[(-7 - N[(1 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Exp[(-t$95$0)], $MachinePrecision] * N[(N[Power[t$95$0, N[(N[(1 - z), $MachinePrecision] - 1/2), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Pi + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left(1 - z\right) - \frac{-13}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\left(\left(\frac{9999999999998099}{10000000000000000} + \left(\frac{\frac{6765203681218851}{10000000000000}}{1 - z} - \frac{\frac{3147848041806007}{2500000000000}}{\left(1 - z\right) - -1}\right)\right) + \left(\frac{\frac{7713234287776531}{10000000000000}}{\left(1 - z\right) - -2} - \frac{\frac{883075145810703}{5000000000000}}{\left(1 - z\right) - -3}\right)\right) + \left(\frac{\frac{2501468655737381}{200000000000000}}{\left(1 - z\right) - -4} + \frac{\frac{-3464277381643003}{25000000000000000}}{\left(1 - z\right) - -5}\right)\right) + \left(\frac{\frac{2496092394504893}{250000000000000000000}}{\left(1 - z\right) - -6} + \frac{\frac{-3764081837873279}{25000000000000000000000}}{-7 - \left(1 - z\right)}\right)\right) \cdot \left(e^{-t\_0} \cdot \left({t\_0}^{\left(\left(1 - z\right) - \frac{1}{2}\right)} \cdot \sqrt{\pi + \pi}\right)\right)\right)
\end{array}
Initial program 96.4%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
lift-+.f64N/A
lift--.f64N/A
associate-+l-N/A
lift--.f64N/A
metadata-evalN/A
associate--l-N/A
lower--.f64N/A
lower-+.f6498.3%
Applied rewrites98.3%
Applied rewrites98.3%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (+ t_0 7)) (t_2 (+ t_1 1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (* (* (sqrt PI) (sqrt 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
9876869457595968283/37500000000000000
(*
z
(+
131068851705067315609/300000000000000000
(*
z
(+
367898832774098786021/675000000000000000
(* 65521081538557082921549/108000000000000000000 z))))))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * ((((sqrt(((double) M_PI)) * sqrt(2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (Math.PI / Math.sin((Math.PI * z))) * ((((Math.sqrt(Math.PI) * Math.sqrt(2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = t_0 + 7.0 t_2 = t_1 + 0.5 return (math.pi / math.sin((math.pi * z))) * ((((math.sqrt(math.pi) * math.sqrt(2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(t_0 + 7.0) t_2 = Float64(t_1 + 0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64(Float64(Float64(sqrt(pi) * sqrt(2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(263.3831855358925 + Float64(z * Float64(436.8961723502244 + Float64(z * Float64(545.0353078134797 + Float64(606.6766809125655 * z)))))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = t_0 + 7.0; t_2 = t_1 + 0.5; tmp = (pi / sin((pi * z))) * ((((sqrt(pi) * sqrt(2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 7), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[Sqrt[Pi], $MachinePrecision] * N[Sqrt[2], $MachinePrecision]), $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(9876869457595968283/37500000000000000 + N[(z * N[(131068851705067315609/300000000000000000 + N[(z * N[(367898832774098786021/675000000000000000 + N[(65521081538557082921549/108000000000000000000 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := t\_0 + 7\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left(\left(\left(\sqrt{\pi} \cdot \sqrt{2}\right) \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\frac{9876869457595968283}{37500000000000000} + z \cdot \left(\frac{131068851705067315609}{300000000000000000} + z \cdot \left(\frac{367898832774098786021}{675000000000000000} + \frac{65521081538557082921549}{108000000000000000000} \cdot z\right)\right)\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
Initial program 96.4%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f6496.6%
Applied rewrites96.6%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
lift-PI.f64N/A
lower-unsound-*.f64N/A
lift-PI.f64N/A
lower-unsound-sqrt.f64N/A
lower-unsound-sqrt.f6497.4%
Applied rewrites97.4%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) -6)) (t_1 (- t_0 -1/2)))
(*
(/ PI (sin (* PI z)))
(*
(* (pow t_1 (- (- 1 z) 1/2)) (sqrt (+ PI PI)))
(*
(exp (- t_1))
(+
(-
(*
(-
(*
(-
(* 65521081538557082921549/108000000000000000000 z)
-367898832774098786021/675000000000000000)
z)
-131068851705067315609/300000000000000000)
z)
-9876869457595968283/37500000000000000)
(+
(/ 2496092394504893/250000000000000000000 t_0)
(/
-3764081837873279/25000000000000000000000
(- -7 (- 1 z))))))))))double code(double z) {
double t_0 = (1.0 - z) - -6.0;
double t_1 = t_0 - -0.5;
return (((double) M_PI) / sin((((double) M_PI) * z))) * ((pow(t_1, ((1.0 - z) - 0.5)) * sqrt((((double) M_PI) + ((double) M_PI)))) * (exp(-t_1) * (((((((606.6766809125655 * z) - -545.0353078134797) * z) - -436.8961723502244) * z) - -263.3831855358925) + ((9.984369578019572e-6 / t_0) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z)))))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - -6.0;
double t_1 = t_0 - -0.5;
return (Math.PI / Math.sin((Math.PI * z))) * ((Math.pow(t_1, ((1.0 - z) - 0.5)) * Math.sqrt((Math.PI + Math.PI))) * (Math.exp(-t_1) * (((((((606.6766809125655 * z) - -545.0353078134797) * z) - -436.8961723502244) * z) - -263.3831855358925) + ((9.984369578019572e-6 / t_0) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z)))))));
}
def code(z): t_0 = (1.0 - z) - -6.0 t_1 = t_0 - -0.5 return (math.pi / math.sin((math.pi * z))) * ((math.pow(t_1, ((1.0 - z) - 0.5)) * math.sqrt((math.pi + math.pi))) * (math.exp(-t_1) * (((((((606.6766809125655 * z) - -545.0353078134797) * z) - -436.8961723502244) * z) - -263.3831855358925) + ((9.984369578019572e-6 / t_0) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z)))))))
function code(z) t_0 = Float64(Float64(1.0 - z) - -6.0) t_1 = Float64(t_0 - -0.5) return Float64(Float64(pi / sin(Float64(pi * z))) * Float64(Float64((t_1 ^ Float64(Float64(1.0 - z) - 0.5)) * sqrt(Float64(pi + pi))) * Float64(exp(Float64(-t_1)) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(606.6766809125655 * z) - -545.0353078134797) * z) - -436.8961723502244) * z) - -263.3831855358925) + Float64(Float64(9.984369578019572e-6 / t_0) + Float64(-1.5056327351493116e-7 / Float64(-7.0 - Float64(1.0 - z)))))))) end
function tmp = code(z) t_0 = (1.0 - z) - -6.0; t_1 = t_0 - -0.5; tmp = (pi / sin((pi * z))) * (((t_1 ^ ((1.0 - z) - 0.5)) * sqrt((pi + pi))) * (exp(-t_1) * (((((((606.6766809125655 * z) - -545.0353078134797) * z) - -436.8961723502244) * z) - -263.3831855358925) + ((9.984369578019572e-6 / t_0) + (-1.5056327351493116e-7 / (-7.0 - (1.0 - z))))))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - -6), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - -1/2), $MachinePrecision]}, N[(N[(Pi / N[Sin[N[(Pi * z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[t$95$1, N[(N[(1 - z), $MachinePrecision] - 1/2), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Pi + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[(-t$95$1)], $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(65521081538557082921549/108000000000000000000 * z), $MachinePrecision] - -367898832774098786021/675000000000000000), $MachinePrecision] * z), $MachinePrecision] - -131068851705067315609/300000000000000000), $MachinePrecision] * z), $MachinePrecision] - -9876869457595968283/37500000000000000), $MachinePrecision] + N[(N[(2496092394504893/250000000000000000000 / t$95$0), $MachinePrecision] + N[(-3764081837873279/25000000000000000000000 / N[(-7 - N[(1 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - -6\\
t_1 := t\_0 - \frac{-1}{2}\\
\frac{\pi}{\sin \left(\pi \cdot z\right)} \cdot \left(\left({t\_1}^{\left(\left(1 - z\right) - \frac{1}{2}\right)} \cdot \sqrt{\pi + \pi}\right) \cdot \left(e^{-t\_1} \cdot \left(\left(\left(\left(\frac{65521081538557082921549}{108000000000000000000} \cdot z - \frac{-367898832774098786021}{675000000000000000}\right) \cdot z - \frac{-131068851705067315609}{300000000000000000}\right) \cdot z - \frac{-9876869457595968283}{37500000000000000}\right) + \left(\frac{\frac{2496092394504893}{250000000000000000000}}{t\_0} + \frac{\frac{-3764081837873279}{25000000000000000000000}}{-7 - \left(1 - z\right)}\right)\right)\right)\right)
\end{array}
Initial program 96.4%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f6496.6%
Applied rewrites96.6%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
lift-PI.f64N/A
lower-unsound-*.f64N/A
lift-PI.f64N/A
lower-unsound-sqrt.f64N/A
lower-unsound-sqrt.f6497.4%
Applied rewrites97.4%
Applied rewrites96.6%
Applied rewrites97.4%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) -6)) (t_1 (- t_0 -1/2)))
(*
(*
(/ PI (sin (* z PI)))
(* (exp (- t_1)) (* (pow t_1 (- (- 1 z) 1/2)) (sqrt (+ PI PI)))))
(+
(+
(+
(*
(+
(*
(+
(* 65521081538557082921549/108000000000000000000 z)
367898832774098786021/675000000000000000)
z)
131068851705067315609/300000000000000000)
z)
9876869457595968283/37500000000000000)
(/ 2496092394504893/250000000000000000000 t_0))
(/ 3764081837873279/25000000000000000000000 (- (- 1 z) -7))))))double code(double z) {
double t_0 = (1.0 - z) - -6.0;
double t_1 = t_0 - -0.5;
return ((((double) M_PI) / sin((z * ((double) M_PI)))) * (exp(-t_1) * (pow(t_1, ((1.0 - z) - 0.5)) * sqrt((((double) M_PI) + ((double) M_PI)))))) * ((((((((606.6766809125655 * z) + 545.0353078134797) * z) + 436.8961723502244) * z) + 263.3831855358925) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((1.0 - z) - -7.0)));
}
public static double code(double z) {
double t_0 = (1.0 - z) - -6.0;
double t_1 = t_0 - -0.5;
return ((Math.PI / Math.sin((z * Math.PI))) * (Math.exp(-t_1) * (Math.pow(t_1, ((1.0 - z) - 0.5)) * Math.sqrt((Math.PI + Math.PI))))) * ((((((((606.6766809125655 * z) + 545.0353078134797) * z) + 436.8961723502244) * z) + 263.3831855358925) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((1.0 - z) - -7.0)));
}
def code(z): t_0 = (1.0 - z) - -6.0 t_1 = t_0 - -0.5 return ((math.pi / math.sin((z * math.pi))) * (math.exp(-t_1) * (math.pow(t_1, ((1.0 - z) - 0.5)) * math.sqrt((math.pi + math.pi))))) * ((((((((606.6766809125655 * z) + 545.0353078134797) * z) + 436.8961723502244) * z) + 263.3831855358925) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((1.0 - z) - -7.0)))
function code(z) t_0 = Float64(Float64(1.0 - z) - -6.0) t_1 = Float64(t_0 - -0.5) return Float64(Float64(Float64(pi / sin(Float64(z * pi))) * Float64(exp(Float64(-t_1)) * Float64((t_1 ^ Float64(Float64(1.0 - z) - 0.5)) * sqrt(Float64(pi + pi))))) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(606.6766809125655 * z) + 545.0353078134797) * z) + 436.8961723502244) * z) + 263.3831855358925) + Float64(9.984369578019572e-6 / t_0)) + Float64(1.5056327351493116e-7 / Float64(Float64(1.0 - z) - -7.0)))) end
function tmp = code(z) t_0 = (1.0 - z) - -6.0; t_1 = t_0 - -0.5; tmp = ((pi / sin((z * pi))) * (exp(-t_1) * ((t_1 ^ ((1.0 - z) - 0.5)) * sqrt((pi + pi))))) * ((((((((606.6766809125655 * z) + 545.0353078134797) * z) + 436.8961723502244) * z) + 263.3831855358925) + (9.984369578019572e-6 / t_0)) + (1.5056327351493116e-7 / ((1.0 - z) - -7.0))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - -6), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - -1/2), $MachinePrecision]}, N[(N[(N[(Pi / N[Sin[N[(z * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[Exp[(-t$95$1)], $MachinePrecision] * N[(N[Power[t$95$1, N[(N[(1 - z), $MachinePrecision] - 1/2), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Pi + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(N[(65521081538557082921549/108000000000000000000 * z), $MachinePrecision] + 367898832774098786021/675000000000000000), $MachinePrecision] * z), $MachinePrecision] + 131068851705067315609/300000000000000000), $MachinePrecision] * z), $MachinePrecision] + 9876869457595968283/37500000000000000), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$0), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(N[(1 - z), $MachinePrecision] - -7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - -6\\
t_1 := t\_0 - \frac{-1}{2}\\
\left(\frac{\pi}{\sin \left(z \cdot \pi\right)} \cdot \left(e^{-t\_1} \cdot \left({t\_1}^{\left(\left(1 - z\right) - \frac{1}{2}\right)} \cdot \sqrt{\pi + \pi}\right)\right)\right) \cdot \left(\left(\left(\left(\left(\frac{65521081538557082921549}{108000000000000000000} \cdot z + \frac{367898832774098786021}{675000000000000000}\right) \cdot z + \frac{131068851705067315609}{300000000000000000}\right) \cdot z + \frac{9876869457595968283}{37500000000000000}\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_0}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{\left(1 - z\right) - -7}\right)
\end{array}
Initial program 96.4%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f6496.6%
Applied rewrites96.6%
Applied rewrites96.8%
(FPCore (z)
:precision binary64
(*
(+
(*
(+
(*
(-
(*
64608921419941589693928044520019/118540800000000000000000000000
PI)
(*
-4027292589444183035165374538123333/6638284800000000000000000000000
(* z PI)))
z)
(* 102757979785251069442117317613/235200000000000000000000000 PI))
z)
(* 1106209385320415913103082059/4200000000000000000000000 PI))
(*
(*
(pow (- (- 1 z) -13/2) (- (- 1 z) 1/2))
(* (exp (- z 15/2)) (sqrt (+ PI PI))))
(/ 1 (sin (* z PI))))))double code(double z) {
return ((((((545.0353078428827 * ((double) M_PI)) - (-606.6766809167608 * (z * ((double) M_PI)))) * z) + (436.8961725563396 * ((double) M_PI))) * z) + (263.3831869810514 * ((double) M_PI))) * ((pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)) * (exp((z - 7.5)) * sqrt((((double) M_PI) + ((double) M_PI))))) * (1.0 / sin((z * ((double) M_PI)))));
}
public static double code(double z) {
return ((((((545.0353078428827 * Math.PI) - (-606.6766809167608 * (z * Math.PI))) * z) + (436.8961725563396 * Math.PI)) * z) + (263.3831869810514 * Math.PI)) * ((Math.pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)) * (Math.exp((z - 7.5)) * Math.sqrt((Math.PI + Math.PI)))) * (1.0 / Math.sin((z * Math.PI))));
}
def code(z): return ((((((545.0353078428827 * math.pi) - (-606.6766809167608 * (z * math.pi))) * z) + (436.8961725563396 * math.pi)) * z) + (263.3831869810514 * math.pi)) * ((math.pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)) * (math.exp((z - 7.5)) * math.sqrt((math.pi + math.pi)))) * (1.0 / math.sin((z * math.pi))))
function code(z) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(545.0353078428827 * pi) - Float64(-606.6766809167608 * Float64(z * pi))) * z) + Float64(436.8961725563396 * pi)) * z) + Float64(263.3831869810514 * pi)) * Float64(Float64((Float64(Float64(1.0 - z) - -6.5) ^ Float64(Float64(1.0 - z) - 0.5)) * Float64(exp(Float64(z - 7.5)) * sqrt(Float64(pi + pi)))) * Float64(1.0 / sin(Float64(z * pi))))) end
function tmp = code(z) tmp = ((((((545.0353078428827 * pi) - (-606.6766809167608 * (z * pi))) * z) + (436.8961725563396 * pi)) * z) + (263.3831869810514 * pi)) * (((((1.0 - z) - -6.5) ^ ((1.0 - z) - 0.5)) * (exp((z - 7.5)) * sqrt((pi + pi)))) * (1.0 / sin((z * pi)))); end
code[z_] := N[(N[(N[(N[(N[(N[(N[(64608921419941589693928044520019/118540800000000000000000000000 * Pi), $MachinePrecision] - N[(-4027292589444183035165374538123333/6638284800000000000000000000000 * N[(z * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] + N[(102757979785251069442117317613/235200000000000000000000000 * Pi), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] + N[(1106209385320415913103082059/4200000000000000000000000 * Pi), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Power[N[(N[(1 - z), $MachinePrecision] - -13/2), $MachinePrecision], N[(N[(1 - z), $MachinePrecision] - 1/2), $MachinePrecision]], $MachinePrecision] * N[(N[Exp[N[(z - 15/2), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Pi + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1 / N[Sin[N[(z * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\left(\left(\left(\frac{64608921419941589693928044520019}{118540800000000000000000000000} \cdot \pi - \frac{-4027292589444183035165374538123333}{6638284800000000000000000000000} \cdot \left(z \cdot \pi\right)\right) \cdot z + \frac{102757979785251069442117317613}{235200000000000000000000000} \cdot \pi\right) \cdot z + \frac{1106209385320415913103082059}{4200000000000000000000000} \cdot \pi\right) \cdot \left(\left({\left(\left(1 - z\right) - \frac{-13}{2}\right)}^{\left(\left(1 - z\right) - \frac{1}{2}\right)} \cdot \left(e^{z - \frac{15}{2}} \cdot \sqrt{\pi + \pi}\right)\right) \cdot \frac{1}{\sin \left(z \cdot \pi\right)}\right)
Initial program 96.4%
Applied rewrites96.7%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
Applied rewrites96.6%
Applied rewrites96.8%
(FPCore (z)
:precision binary64
(let* ((t_0 (- (- 1 z) 1)) (t_1 (+ t_0 7)) (t_2 (+ t_1 1/2)))
(*
(/ 1 z)
(*
(* (* (* (sqrt PI) (sqrt 2)) (pow t_2 (+ t_0 1/2))) (exp (- t_2)))
(+
(+
(+
9876869457595968283/37500000000000000
(*
z
(+
131068851705067315609/300000000000000000
(*
z
(+
367898832774098786021/675000000000000000
(* 65521081538557082921549/108000000000000000000 z))))))
(/ 2496092394504893/250000000000000000000 t_1))
(/ 3764081837873279/25000000000000000000000 (+ t_0 8)))))))double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (1.0 / z) * ((((sqrt(((double) M_PI)) * sqrt(2.0)) * pow(t_2, (t_0 + 0.5))) * exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
public static double code(double z) {
double t_0 = (1.0 - z) - 1.0;
double t_1 = t_0 + 7.0;
double t_2 = t_1 + 0.5;
return (1.0 / z) * ((((Math.sqrt(Math.PI) * Math.sqrt(2.0)) * Math.pow(t_2, (t_0 + 0.5))) * Math.exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))));
}
def code(z): t_0 = (1.0 - z) - 1.0 t_1 = t_0 + 7.0 t_2 = t_1 + 0.5 return (1.0 / z) * ((((math.sqrt(math.pi) * math.sqrt(2.0)) * math.pow(t_2, (t_0 + 0.5))) * math.exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0))))
function code(z) t_0 = Float64(Float64(1.0 - z) - 1.0) t_1 = Float64(t_0 + 7.0) t_2 = Float64(t_1 + 0.5) return Float64(Float64(1.0 / z) * Float64(Float64(Float64(Float64(sqrt(pi) * sqrt(2.0)) * (t_2 ^ Float64(t_0 + 0.5))) * exp(Float64(-t_2))) * Float64(Float64(Float64(263.3831855358925 + Float64(z * Float64(436.8961723502244 + Float64(z * Float64(545.0353078134797 + Float64(606.6766809125655 * z)))))) + Float64(9.984369578019572e-6 / t_1)) + Float64(1.5056327351493116e-7 / Float64(t_0 + 8.0))))) end
function tmp = code(z) t_0 = (1.0 - z) - 1.0; t_1 = t_0 + 7.0; t_2 = t_1 + 0.5; tmp = (1.0 / z) * ((((sqrt(pi) * sqrt(2.0)) * (t_2 ^ (t_0 + 0.5))) * exp(-t_2)) * (((263.3831855358925 + (z * (436.8961723502244 + (z * (545.0353078134797 + (606.6766809125655 * z)))))) + (9.984369578019572e-6 / t_1)) + (1.5056327351493116e-7 / (t_0 + 8.0)))); end
code[z_] := Block[{t$95$0 = N[(N[(1 - z), $MachinePrecision] - 1), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + 7), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + 1/2), $MachinePrecision]}, N[(N[(1 / z), $MachinePrecision] * N[(N[(N[(N[(N[Sqrt[Pi], $MachinePrecision] * N[Sqrt[2], $MachinePrecision]), $MachinePrecision] * N[Power[t$95$2, N[(t$95$0 + 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Exp[(-t$95$2)], $MachinePrecision]), $MachinePrecision] * N[(N[(N[(9876869457595968283/37500000000000000 + N[(z * N[(131068851705067315609/300000000000000000 + N[(z * N[(367898832774098786021/675000000000000000 + N[(65521081538557082921549/108000000000000000000 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2496092394504893/250000000000000000000 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(3764081837873279/25000000000000000000000 / N[(t$95$0 + 8), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
t_0 := \left(1 - z\right) - 1\\
t_1 := t\_0 + 7\\
t_2 := t\_1 + \frac{1}{2}\\
\frac{1}{z} \cdot \left(\left(\left(\left(\sqrt{\pi} \cdot \sqrt{2}\right) \cdot {t\_2}^{\left(t\_0 + \frac{1}{2}\right)}\right) \cdot e^{-t\_2}\right) \cdot \left(\left(\left(\frac{9876869457595968283}{37500000000000000} + z \cdot \left(\frac{131068851705067315609}{300000000000000000} + z \cdot \left(\frac{367898832774098786021}{675000000000000000} + \frac{65521081538557082921549}{108000000000000000000} \cdot z\right)\right)\right) + \frac{\frac{2496092394504893}{250000000000000000000}}{t\_1}\right) + \frac{\frac{3764081837873279}{25000000000000000000000}}{t\_0 + 8}\right)\right)
\end{array}
Initial program 96.4%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f6496.6%
Applied rewrites96.6%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
lift-PI.f64N/A
lower-unsound-*.f64N/A
lift-PI.f64N/A
lower-unsound-sqrt.f64N/A
lower-unsound-sqrt.f6497.4%
Applied rewrites97.4%
Taylor expanded in z around 0
lower-/.f6497.2%
Applied rewrites97.2%
(FPCore (z)
:precision binary64
(*
(*
(+
(* 1106209385320415913103082059/4200000000000000000000000 PI)
(*
z
(+
(* 102757979785251069442117317613/235200000000000000000000000 PI)
(*
z
(+
(*
64608921419941589693928044520019/118540800000000000000000000000
PI)
(*
4027292589444183035165374538123333/6638284800000000000000000000000
(* z PI)))))))
(*
(* (exp (+ (+ 0 z) -15/2)) (sqrt (+ PI PI)))
(pow (- (- 1 z) -13/2) (- (- 1 z) 1/2))))
(/ 1 (* z PI))))double code(double z) {
return (((263.3831869810514 * ((double) M_PI)) + (z * ((436.8961725563396 * ((double) M_PI)) + (z * ((545.0353078428827 * ((double) M_PI)) + (606.6766809167608 * (z * ((double) M_PI)))))))) * ((exp(((0.0 + z) + -7.5)) * sqrt((((double) M_PI) + ((double) M_PI)))) * pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)))) * (1.0 / (z * ((double) M_PI)));
}
public static double code(double z) {
return (((263.3831869810514 * Math.PI) + (z * ((436.8961725563396 * Math.PI) + (z * ((545.0353078428827 * Math.PI) + (606.6766809167608 * (z * Math.PI))))))) * ((Math.exp(((0.0 + z) + -7.5)) * Math.sqrt((Math.PI + Math.PI))) * Math.pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)))) * (1.0 / (z * Math.PI));
}
def code(z): return (((263.3831869810514 * math.pi) + (z * ((436.8961725563396 * math.pi) + (z * ((545.0353078428827 * math.pi) + (606.6766809167608 * (z * math.pi))))))) * ((math.exp(((0.0 + z) + -7.5)) * math.sqrt((math.pi + math.pi))) * math.pow(((1.0 - z) - -6.5), ((1.0 - z) - 0.5)))) * (1.0 / (z * math.pi))
function code(z) return Float64(Float64(Float64(Float64(263.3831869810514 * pi) + Float64(z * Float64(Float64(436.8961725563396 * pi) + Float64(z * Float64(Float64(545.0353078428827 * pi) + Float64(606.6766809167608 * Float64(z * pi))))))) * Float64(Float64(exp(Float64(Float64(0.0 + z) + -7.5)) * sqrt(Float64(pi + pi))) * (Float64(Float64(1.0 - z) - -6.5) ^ Float64(Float64(1.0 - z) - 0.5)))) * Float64(1.0 / Float64(z * pi))) end
function tmp = code(z) tmp = (((263.3831869810514 * pi) + (z * ((436.8961725563396 * pi) + (z * ((545.0353078428827 * pi) + (606.6766809167608 * (z * pi))))))) * ((exp(((0.0 + z) + -7.5)) * sqrt((pi + pi))) * (((1.0 - z) - -6.5) ^ ((1.0 - z) - 0.5)))) * (1.0 / (z * pi)); end
code[z_] := N[(N[(N[(N[(1106209385320415913103082059/4200000000000000000000000 * Pi), $MachinePrecision] + N[(z * N[(N[(102757979785251069442117317613/235200000000000000000000000 * Pi), $MachinePrecision] + N[(z * N[(N[(64608921419941589693928044520019/118540800000000000000000000000 * Pi), $MachinePrecision] + N[(4027292589444183035165374538123333/6638284800000000000000000000000 * N[(z * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(N[Exp[N[(N[(0 + z), $MachinePrecision] + -15/2), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(Pi + Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(1 - z), $MachinePrecision] - -13/2), $MachinePrecision], N[(N[(1 - z), $MachinePrecision] - 1/2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1 / N[(z * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\left(\left(\frac{1106209385320415913103082059}{4200000000000000000000000} \cdot \pi + z \cdot \left(\frac{102757979785251069442117317613}{235200000000000000000000000} \cdot \pi + z \cdot \left(\frac{64608921419941589693928044520019}{118540800000000000000000000000} \cdot \pi + \frac{4027292589444183035165374538123333}{6638284800000000000000000000000} \cdot \left(z \cdot \pi\right)\right)\right)\right) \cdot \left(\left(e^{\left(0 + z\right) + \frac{-15}{2}} \cdot \sqrt{\pi + \pi}\right) \cdot {\left(\left(1 - z\right) - \frac{-13}{2}\right)}^{\left(\left(1 - z\right) - \frac{1}{2}\right)}\right)\right) \cdot \frac{1}{z \cdot \pi}
Initial program 96.4%
Applied rewrites96.7%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
Applied rewrites96.6%
Taylor expanded in z around 0
lower-/.f64N/A
lower-*.f64N/A
lower-PI.f6496.2%
Applied rewrites96.2%
(FPCore (z) :precision binary64 (* 1106209385320415913103082059/4200000000000000000000000 (/ (* (exp -15/2) (* (sqrt 2) (* (sqrt PI) (pow 15/2 1/2)))) z)))
double code(double z) {
return 263.3831869810514 * ((exp(-7.5) * (sqrt(2.0) * (sqrt(((double) M_PI)) * pow(7.5, 0.5)))) / z);
}
public static double code(double z) {
return 263.3831869810514 * ((Math.exp(-7.5) * (Math.sqrt(2.0) * (Math.sqrt(Math.PI) * Math.pow(7.5, 0.5)))) / z);
}
def code(z): return 263.3831869810514 * ((math.exp(-7.5) * (math.sqrt(2.0) * (math.sqrt(math.pi) * math.pow(7.5, 0.5)))) / z)
function code(z) return Float64(263.3831869810514 * Float64(Float64(exp(-7.5) * Float64(sqrt(2.0) * Float64(sqrt(pi) * (7.5 ^ 0.5)))) / z)) end
function tmp = code(z) tmp = 263.3831869810514 * ((exp(-7.5) * (sqrt(2.0) * (sqrt(pi) * (7.5 ^ 0.5)))) / z); end
code[z_] := N[(1106209385320415913103082059/4200000000000000000000000 * N[(N[(N[Exp[-15/2], $MachinePrecision] * N[(N[Sqrt[2], $MachinePrecision] * N[(N[Sqrt[Pi], $MachinePrecision] * N[Power[15/2, 1/2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]
\frac{1106209385320415913103082059}{4200000000000000000000000} \cdot \frac{e^{\frac{-15}{2}} \cdot \left(\sqrt{2} \cdot \left(\sqrt{\pi} \cdot {\frac{15}{2}}^{\frac{1}{2}}\right)\right)}{z}
Initial program 96.4%
Taylor expanded in z around 0
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower-*.f6496.6%
Applied rewrites96.6%
lift-sqrt.f64N/A
lift-*.f64N/A
sqrt-prodN/A
lift-PI.f64N/A
lower-unsound-*.f64N/A
lift-PI.f64N/A
lower-unsound-sqrt.f64N/A
lower-unsound-sqrt.f6497.4%
Applied rewrites97.4%
Taylor expanded in z around 0
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites96.4%
(FPCore (z) :precision binary64 (* 1106209385320415913103082059/4200000000000000000000000 (/ 1 (/ z (* (sqrt (* 15 PI)) (exp -15/2))))))
double code(double z) {
return 263.3831869810514 * (1.0 / (z / (sqrt((15.0 * ((double) M_PI))) * exp(-7.5))));
}
public static double code(double z) {
return 263.3831869810514 * (1.0 / (z / (Math.sqrt((15.0 * Math.PI)) * Math.exp(-7.5))));
}
def code(z): return 263.3831869810514 * (1.0 / (z / (math.sqrt((15.0 * math.pi)) * math.exp(-7.5))))
function code(z) return Float64(263.3831869810514 * Float64(1.0 / Float64(z / Float64(sqrt(Float64(15.0 * pi)) * exp(-7.5))))) end
function tmp = code(z) tmp = 263.3831869810514 * (1.0 / (z / (sqrt((15.0 * pi)) * exp(-7.5)))); end
code[z_] := N[(1106209385320415913103082059/4200000000000000000000000 * N[(1 / N[(z / N[(N[Sqrt[N[(15 * Pi), $MachinePrecision]], $MachinePrecision] * N[Exp[-15/2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\frac{1106209385320415913103082059}{4200000000000000000000000} \cdot \frac{1}{\frac{z}{\sqrt{15 \cdot \pi} \cdot e^{\frac{-15}{2}}}}
Initial program 96.4%
Taylor expanded in z around 0
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites95.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6495.4%
lift-*.f64N/A
*-commutativeN/A
lift-pow.f64N/A
unpow1/2N/A
lift-sqrt.f64N/A
sqrt-unprodN/A
lower-sqrt.f64N/A
lower-*.f6495.4%
lift-*.f64N/A
count-2-revN/A
lift-+.f6495.4%
Applied rewrites95.4%
Taylor expanded in z around 0
lower-/.f64N/A
lower-*.f64N/A
lower-exp.f64N/A
lower-sqrt.f64N/A
lower-*.f64N/A
lower-PI.f6495.7%
Applied rewrites95.7%
lift-/.f64N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f6495.7%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6495.7%
Applied rewrites95.7%
(FPCore (z) :precision binary64 (* 1106209385320415913103082059/4200000000000000000000000 (/ (* (exp -15/2) (sqrt (* 15 PI))) z)))
double code(double z) {
return 263.3831869810514 * ((exp(-7.5) * sqrt((15.0 * ((double) M_PI)))) / z);
}
public static double code(double z) {
return 263.3831869810514 * ((Math.exp(-7.5) * Math.sqrt((15.0 * Math.PI))) / z);
}
def code(z): return 263.3831869810514 * ((math.exp(-7.5) * math.sqrt((15.0 * math.pi))) / z)
function code(z) return Float64(263.3831869810514 * Float64(Float64(exp(-7.5) * sqrt(Float64(15.0 * pi))) / z)) end
function tmp = code(z) tmp = 263.3831869810514 * ((exp(-7.5) * sqrt((15.0 * pi))) / z); end
code[z_] := N[(1106209385320415913103082059/4200000000000000000000000 * N[(N[(N[Exp[-15/2], $MachinePrecision] * N[Sqrt[N[(15 * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]
\frac{1106209385320415913103082059}{4200000000000000000000000} \cdot \frac{e^{\frac{-15}{2}} \cdot \sqrt{15 \cdot \pi}}{z}
Initial program 96.4%
Taylor expanded in z around 0
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites95.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6495.4%
lift-*.f64N/A
*-commutativeN/A
lift-pow.f64N/A
unpow1/2N/A
lift-sqrt.f64N/A
sqrt-unprodN/A
lower-sqrt.f64N/A
lower-*.f6495.4%
lift-*.f64N/A
count-2-revN/A
lift-+.f6495.4%
Applied rewrites95.4%
Taylor expanded in z around 0
lower-/.f64N/A
lower-*.f64N/A
lower-exp.f64N/A
lower-sqrt.f64N/A
lower-*.f64N/A
lower-PI.f6495.7%
Applied rewrites95.7%
herbie shell --seed 2025271 -o generate:evaluate
(FPCore (z)
:name "Jmat.Real.gamma, branch z less than 0.5"
:precision binary64
:pre (<= z 1/2)
(* (/ PI (sin (* PI z))) (* (* (* (sqrt (* PI 2)) (pow (+ (+ (- (- 1 z) 1) 7) 1/2) (+ (- (- 1 z) 1) 1/2))) (exp (- (+ (+ (- (- 1 z) 1) 7) 1/2)))) (+ (+ (+ (+ (+ (+ (+ (+ 9999999999998099/10000000000000000 (/ 6765203681218851/10000000000000 (+ (- (- 1 z) 1) 1))) (/ -3147848041806007/2500000000000 (+ (- (- 1 z) 1) 2))) (/ 7713234287776531/10000000000000 (+ (- (- 1 z) 1) 3))) (/ -883075145810703/5000000000000 (+ (- (- 1 z) 1) 4))) (/ 2501468655737381/200000000000000 (+ (- (- 1 z) 1) 5))) (/ -3464277381643003/25000000000000000 (+ (- (- 1 z) 1) 6))) (/ 2496092394504893/250000000000000000000 (+ (- (- 1 z) 1) 7))) (/ 3764081837873279/25000000000000000000000 (+ (- (- 1 z) 1) 8))))))