public static MultiPrecision <N> Erfc(MultiPrecision <N> x)
        {
            if (x.IsZero)
            {
                return(1);
            }
            if (x.IsNaN)
            {
                return(NaN);
            }
            if (!x.IsFinite)
            {
                return(x.Sign == Sign.Plus ? 0 : 2);
            }
            if (x.Sign == Sign.Minus)
            {
                return(1 + Erf(Abs(x)));
            }

            if (x.Exponent < Consts.Erf.ExponentThreshold)
            {
                MultiPrecision <Plus4 <Plus4 <N> > > y =
                    MultiPrecision <Plus4 <N> > .ErfTaylorSeriesApprox(x.Convert <Plus4 <N> >());

                return((1 - y).Convert <N>());
            }
            else
            {
                long n = ErfcConvergenceTable.N(Bits, (double)x);
                MultiPrecision <Plus4 <N> > y = ErfcContinueFractionalApprox(x, n);

                return(y.Convert <N>());
            }
        }
        public static MultiPrecision <N> Erf(MultiPrecision <N> x)
        {
            if (x.IsZero)
            {
                return(0);
            }
            if (x.IsNaN)
            {
                return(NaN);
            }
            if (!x.IsFinite)
            {
                return(x.Sign == Sign.Plus ? 1 : -1);
            }
            if (x.Sign == Sign.Minus)
            {
                return(-Erf(Abs(x)));
            }

            if (x.Exponent < Consts.Erf.ExponentThreshold)
            {
                MultiPrecision <Plus4 <N> > y = ErfTaylorSeriesApprox(x);

                return(y.Convert <N>());
            }
            else
            {
                double xd = (double)x;
                double erfc_exponent_estimate = 1.4 * xd * xd;

                int needs_bits = Bits - (int)Math.Min(Bits, erfc_exponent_estimate);
                if (needs_bits < 1)
                {
                    return(1);
                }

                long n = ErfcConvergenceTable.N(needs_bits, xd);
                MultiPrecision <Plus4 <N> > y = ErfcContinueFractionalApprox(x, n);

                return((1 - y).Convert <N>());
            }
        }