

def _create_lookup_table(table):
    ' Add formulae for the function -> meijerg lookup table. '

    def wild(n):
        return Wild(n, exclude=[z])
    (p, q, a, b, c) = list(map(wild, 'pqabc'))
    n = Wild('n', properties=[(lambda x: (x.is_Integer and (x > 0)))])
    t = (p * (z ** q))

    def add(formula, an, ap, bm, bq, arg=t, fac=S(1), cond=True, hint=True):
        table.setdefault(_mytype(formula, z), []).append((formula, [(fac, meijerg(an, ap, bm, bq, arg))], cond, hint))

    def addi(formula, inst, cond, hint=True):
        table.setdefault(_mytype(formula, z), []).append((formula, inst, cond, hint))

    def constant(a):
        return [(a, meijerg([1], [], [], [0], z)), (a, meijerg([], [1], [0], [], z))]
    table[()] = [(a, constant(a), True, True)]
    from sympy import unpolarify, Function, Not

    class IsNonPositiveInteger(Function):

        @classmethod
        def eval(cls, arg):
            arg = unpolarify(arg)
            if (arg.is_Integer is True):
                return (arg <= 0)
    from sympy import gamma, pi, cos, exp, re, sin, sinc, sqrt, sinh, cosh, factorial, log, erf, erfc, erfi, polar_lift
    add((Heaviside((t - b)) * ((t - b) ** (a - 1))), [a], [], [], [0], (t / b), (gamma(a) * (b ** (a - 1))), And((b > 0)))
    add((Heaviside((b - t)) * ((b - t) ** (a - 1))), [], [a], [0], [], (t / b), (gamma(a) * (b ** (a - 1))), And((b > 0)))
    add((Heaviside((z - ((table / p) ** (1 / q)))) * ((t - b) ** (a - 1))), [a], [], [], [0], (t / b), (gamma(a) * (b ** (a - 1))), And((b > 0)))
    add((Heaviside((((b / p) ** (1 / q)) - z)) * ((b - t) ** (a - 1))), [], [a], [0], [], (t / b), (gamma(a) * (b ** (a - 1))), And((b > 0)))
    add(((b + t) ** (- a)), [(1 - a)], [], [0], [], (t / b), ((b ** (- a)) / gamma(a)), hint=Not(IsNonPositiveInteger(a)))
    add((abs((b - t)) ** (- a)), [(1 - a)], [((1 - a) / 2)], [0], [((1 - a) / 2)], (t / b), ((pi / (gamma(a) * cos(((pi * a) / 2)))) * (abs(b) ** (- a))), (re(a) < 1))
    add((((t ** a) - (b ** a)) / (t - b)), [0, a], [], [0, a], [], (t / b), (((b ** (a - 1)) * sin((a * pi))) / pi))

    def A1(r, sign, nu):
        return ((pi ** ((- S(1)) / 2)) * ((((- sign) * nu) / 2) ** (1 - (2 * r))))

    def tmpadd(r, sgn):
        add((((sqrt(((a ** 2) + t)) + (sgn * a)) ** b) / (((a ** 2) + t) ** r)), [((1 + b) / 2), ((1 - (2 * r)) + (b / 2))], [], [((b - (sgn * b)) / 2)], [((b + (sgn * b)) / 2)], (t / (a ** 2)), ((a ** (b - (2 * r))) * A1(r, sgn, b)))
    tmpadd(0, 1)
    tmpadd(0, (- 1))
    tmpadd((S(1) / 2), 1)
    tmpadd((S(1) / 2), (- 1))

    def tmpadd(r, sgn):
        add((((sqrt((a + (p * (z ** q)))) + ((sgn * sqrt(p)) * (z ** (q / 2)))) ** b) / ((a + (p * (z ** q))) ** r)), [((1 - r) + ((sgn * b) / 2))], [((1 - r) - ((sgn * b) / 2))], [0, (S(1) / 2)], [], ((p * (z ** q)) / a), ((a ** ((b / 2) - r)) * A1(r, sgn, b)))
    tmpadd(0, 1)
    tmpadd(0, (- 1))
    tmpadd((S(1) / 2), 1)
    tmpadd((S(1) / 2), (- 1))
    add(exp((polar_lift((- 1)) * t)), [], [], [0], [])
    add(sinh(t), [], [1], [(S(1) / 2)], [1, 0], ((t ** 2) / 4), (pi ** (S(3) / 2)))
    add(cosh(t), [], [(S(1) / 2)], [0], [(S(1) / 2), (S(1) / 2)], ((t ** 2) / 4), (pi ** (S(3) / 2)))
    add(sin(t), [], [], [(S(1) / 2)], [0], ((t ** 2) / 4), sqrt(pi))
    add(cos(t), [], [], [0], [(S(1) / 2)], ((t ** 2) / 4), sqrt(pi))
    add(sinc(t), [], [], [0], [(S((- 1)) / 2)], ((t ** 2) / 4), (sqrt(pi) / 2))

    def make_log1(subs):
        N = subs[n]
        return [((((- 1) ** N) * factorial(N)), meijerg([], ([1] * (N + 1)), ([0] * (N + 1)), [], t))]

    def make_log2(subs):
        N = subs[n]
        return [(factorial(N), meijerg(([1] * (N + 1)), [], [], ([0] * (N + 1)), t))]
    addi(((log(t) ** n) * Heaviside((1 - t))), make_log1, True)
    addi(((log(t) ** n) * Heaviside((t - 1))), make_log2, True)

    def make_log3(subs):
        return (make_log1(subs) + make_log2(subs))
    addi((log(t) ** n), make_log3, True)
    addi(log((t + a)), (constant(log(a)) + [(S(1), meijerg([1, 1], [], [1], [0], (t / a)))]), True)
    addi(log(abs((t - a))), (constant(log(abs(a))) + [(pi, meijerg([1, 1], [(S(1) / 2)], [1], [0, (S(1) / 2)], (t / a)))]), True)
    from sympy import Ei, I, expint, Si, Ci, Shi, Chi, fresnels, fresnelc
    addi(Ei(t), (constant(((- I) * pi)) + [(S((- 1)), meijerg([], [1], [0, 0], [], (t * polar_lift((- 1)))))]), True)
    add(Si(t), [1], [], [(S(1) / 2)], [0, 0], ((t ** 2) / 4), (sqrt(pi) / 2))
    add(Ci(t), [], [1], [0, 0], [(S(1) / 2)], ((t ** 2) / 4), ((- sqrt(pi)) / 2))
    add(Shi(t), [(S(1) / 2)], [], [0], [(S((- 1)) / 2), (S((- 1)) / 2)], ((polar_lift((- 1)) * (t ** 2)) / 4), ((t * sqrt(pi)) / 4))
    add(Chi(t), [], [(S(1) / 2), 1], [0, 0], [(S(1) / 2), (S(1) / 2)], ((t ** 2) / 4), ((- (pi ** S('3/2'))) / 2))
    add(expint(a, t), [], [a], [(a - 1), 0], [], t)
    add(erf(t), [1], [], [(S(1) / 2)], [0], (t ** 2), (1 / sqrt(pi)))
    add(erfc(t), [], [1], [0, (S(1) / 2)], [], (t ** 2), (1 / sqrt(pi)))
    add(erfi(t), [(S(1) / 2)], [], [0], [((- S(1)) / 2)], (- (t ** 2)), (t / sqrt(pi)))
    add(fresnels(t), [1], [], [(S(3) / 4)], [0, (S(1) / 4)], (((pi ** 2) * (t ** 4)) / 16), (S(1) / 2))
    add(fresnelc(t), [1], [], [(S(1) / 4)], [0, (S(3) / 4)], (((pi ** 2) * (t ** 4)) / 16), (S(1) / 2))
    from sympy import besselj, bessely, besseli, besselk
    add(besselj(a, t), [], [], [(a / 2)], [((- a) / 2)], ((t ** 2) / 4))
    add(bessely(a, t), [], [((- (a + 1)) / 2)], [(a / 2), ((- a) / 2)], [((- (a + 1)) / 2)], ((t ** 2) / 4))
    add(besseli(a, t), [], [((1 + a) / 2)], [(a / 2)], [((- a) / 2), ((1 + a) / 2)], ((t ** 2) / 4), pi)
    add(besselk(a, t), [], [], [(a / 2), ((- a) / 2)], [], ((t ** 2) / 4), (S(1) / 2))
    from sympy import elliptic_k, elliptic_e
    add(elliptic_k(t), [S.Half, S.Half], [], [0], [0], (- t), S.Half)
    add(elliptic_e(t), [S.Half, (3 * S.Half)], [], [0], [0], (- t), ((- S.Half) / 2))

dataset/ETHPy150Open sympy/sympy/sympy/integrals/meijerint.py _create_lookup_table/VarMisuse@557/639 `b`->`table`