Exemplo n.º 1
0
    def _eval_apply(self, z, a=S.One):
        z, a = map(Basic.sympify, (z, a))

        if isinstance(a, Basic.Number):
            if isinstance(a, Basic.NaN):
                return S.NaN
            elif isinstance(a, Basic.Zero):
                return self(z)

        if isinstance(z, Basic.Number):
            if isinstance(z, Basic.NaN):
                return S.NaN
            elif isinstance(z, Basic.Infinity):
                return S.One
            elif isinstance(z, Basic.Zero):
                if a.is_negative:
                    return S.Half - a - 1
                else:
                    return S.Half - a
            elif isinstance(z, Basic.One):
                return S.ComplexInfinity
            elif isinstance(z, Basic.Integer):
                if isinstance(a, Basic.Integer):
                    if z.is_negative:
                        zeta = (-1)**z * Basic.bernoulli(-z+1)/(-z+1)
                    elif z.is_even:
                        B, F = Basic.bernoulli(z), Basic.Factorial(z)
                        zeta = 2**(z-1) * abs(B) * pi**z / F

                    if a.is_negative:
                        return zeta + Basic.harmonic(abs(a), z)
                    else:
                        return zeta - Basic.harmonic(a-1, z)
Exemplo n.º 2
0
    def _eval_apply(cls, n, z):
        n, z = map(Basic.sympify, (n, z))

        if n.is_integer:
            if n.is_negative:
                return loggamma(z)
            else:
                if isinstance(z, Basic.Number):
                    if isinstance(z, Basic.NaN):
                        return S.NaN
                    elif isinstance(z, Basic.Infinity):
                        if isinstance(n, Basic.Number):
                            if isinstance(n, Basic.Zero):
                                return S.Infinity
                            else:
                                return S.Zero
                    elif isinstance(z, Basic.Integer):
                        if z.is_nonpositive:
                            return S.ComplexInfinity
                        else:
                            if isinstance(n, Basic.Zero):
                                return -S.EulerGamma + Basic.harmonic(z-1, 1)
                            elif n.is_odd:
                                return (-1)**(n+1)*Basic.Factorial(n)*zeta(n+1, z)