passagemath-flint 10.6.1rc10__cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sage/graphs/matchpoly.pyx

@@ -0,0 +1,412 @@
+# sage_setup: distribution = sagemath-flint
+# cython: binding=True
+# sage.doctest: needs sage.libs.flint sage.graphs
+"""
+Matching polynomial
+
+This module contains the following methods:
+
+.. csv-table::
+    :class: contentstable
+    :widths: 30, 70
+    :delim: |
+
+    :meth:`matching_polynomial` | Compute the matching polynomial of a given graph.
+    :meth:`complete_poly` | Compute the matching polynomial of the complete graph on `n` vertices.
+
+AUTHORS:
+
+- Robert Miller, Tom Boothby - original implementation
+
+REFERENCE:
+
+[God1993]_
+
+
+Methods
+-------
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2010 Robert Miller
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cysignals.memory cimport check_allocarray, sig_free
+from cysignals.signals cimport sig_on, sig_off
+
+from sage.rings.polynomial.polynomial_ring import polygen
+from sage.rings.integer_ring import ZZ
+from sage.rings.integer cimport Integer
+
+from sage.libs.flint.fmpz cimport *
+from sage.libs.flint.fmpz_poly cimport *
+from sage.libs.flint.fmpz_poly_sage cimport *
+
+
+x = polygen(ZZ, 'x')
+
+
+def matching_polynomial(G, complement=True, name=None):
+    r"""
+    Compute the matching polynomial of the graph `G`.
+
+    If `p(G, k)` denotes the number of `k`-matchings (matchings with `k` edges)
+    in `G`, then the matching polynomial is defined as [God1993]_:
+
+    .. MATH::
+
+        \mu(x)=\sum_{k \geq 0} (-1)^k p(G,k) x^{n-2k}
+
+    INPUT:
+
+    - ``complement`` -- boolean (default: ``True``); whether to use Godsil's duality
+      theorem to compute the matching polynomial from that of the graphs
+      complement (see ALGORITHM)
+
+    - ``name`` -- (optional) string for the variable name in the polynomial
+
+    .. NOTE::
+
+        The ``complement`` option uses matching polynomials of complete graphs,
+        which are cached. So if you are crazy enough to try computing the
+        matching polynomial on a graph with millions of vertices, you might not
+        want to use this option, since it will end up caching millions of
+        polynomials of degree in the millions.
+
+    ALGORITHM:
+
+    The algorithm used is a recursive one, based on the following observation
+    [God1993]_:
+
+    - If `e` is an edge of `G`, `G'` is the result of deleting the edge `e`, and
+      `G''` is the result of deleting each vertex in `e`, then the matching
+      polynomial of `G` is equal to that of `G'` minus that of `G''`.
+
+      (the algorithm actually computes the *signless* matching polynomial, for
+      which the recursion is the same when one replaces the subtraction by an
+      addition. It is then converted into the matching polynomial and returned)
+
+    Depending on the value of ``complement``, Godsil's duality theorem
+    [God1993]_ can also be used to compute `\mu(x)` :
+
+    .. MATH::
+
+        \mu(\overline{G}, x) = \sum_{k \geq 0} p(G,k) \mu( K_{n-2k}, x)
+
+
+    Where `\overline{G}` is the complement of `G`, and `K_n` the complete graph
+    on `n` vertices.
+
+    EXAMPLES::
+
+        sage: g = graphs.PetersenGraph()
+        sage: g.matching_polynomial()
+        x^10 - 15*x^8 + 75*x^6 - 145*x^4 + 90*x^2 - 6
+        sage: g.matching_polynomial(complement=False)
+        x^10 - 15*x^8 + 75*x^6 - 145*x^4 + 90*x^2 - 6
+        sage: g.matching_polynomial(name='tom')
+        tom^10 - 15*tom^8 + 75*tom^6 - 145*tom^4 + 90*tom^2 - 6
+        sage: g = Graph()
+        sage: L = [graphs.RandomGNP(8, .3) for i in range(1, 6)]
+        sage: prod([h.matching_polynomial() for h in L]) == sum(L, g).matching_polynomial()  # long time (up to 10s on sage.math, 2011)
+        True
+
+    ::
+
+        sage: for i in range(1, 12):  # long time (10s on sage.math, 2011)
+        ....:     for t in graphs.trees(i):
+        ....:         if t.matching_polynomial() != t.characteristic_polynomial():
+        ....:             raise RuntimeError('bug for a tree A of size {0}'.format(i))
+        ....:         c = t.complement()
+        ....:         if c.matching_polynomial(complement=False) != c.matching_polynomial():
+        ....:             raise RuntimeError('bug for a tree B of size {0}'.format(i))
+
+    ::
+
+        sage: from sage.graphs.matchpoly import matching_polynomial
+        sage: matching_polynomial(graphs.CompleteGraph(0))
+        1
+        sage: matching_polynomial(graphs.CompleteGraph(1))
+        x
+        sage: matching_polynomial(graphs.CompleteGraph(2))
+        x^2 - 1
+        sage: matching_polynomial(graphs.CompleteGraph(3))
+        x^3 - 3*x
+        sage: matching_polynomial(graphs.CompleteGraph(4))
+        x^4 - 6*x^2 + 3
+        sage: matching_polynomial(graphs.CompleteGraph(5))
+        x^5 - 10*x^3 + 15*x
+        sage: matching_polynomial(graphs.CompleteGraph(6))
+        x^6 - 15*x^4 + 45*x^2 - 15
+        sage: matching_polynomial(graphs.CompleteGraph(7))
+        x^7 - 21*x^5 + 105*x^3 - 105*x
+        sage: matching_polynomial(graphs.CompleteGraph(8))
+        x^8 - 28*x^6 + 210*x^4 - 420*x^2 + 105
+        sage: matching_polynomial(graphs.CompleteGraph(9))
+        x^9 - 36*x^7 + 378*x^5 - 1260*x^3 + 945*x
+        sage: matching_polynomial(graphs.CompleteGraph(10))
+        x^10 - 45*x^8 + 630*x^6 - 3150*x^4 + 4725*x^2 - 945
+        sage: matching_polynomial(graphs.CompleteGraph(11))
+        x^11 - 55*x^9 + 990*x^7 - 6930*x^5 + 17325*x^3 - 10395*x
+        sage: matching_polynomial(graphs.CompleteGraph(12))
+        x^12 - 66*x^10 + 1485*x^8 - 13860*x^6 + 51975*x^4 - 62370*x^2 + 10395
+        sage: matching_polynomial(graphs.CompleteGraph(13))
+        x^13 - 78*x^11 + 2145*x^9 - 25740*x^7 + 135135*x^5 - 270270*x^3 + 135135*x
+
+    ::
+
+        sage: G = Graph({0:[1,2], 1:[2]})
+        sage: matching_polynomial(G)
+        x^3 - 3*x
+        sage: G = Graph({0:[1,2]})
+        sage: matching_polynomial(G)
+        x^3 - 2*x
+        sage: G = Graph({0:[1], 2:[]})
+        sage: matching_polynomial(G)
+        x^3 - x
+        sage: G = Graph({0:[], 1:[], 2:[]})
+        sage: matching_polynomial(G)
+        x^3
+
+    ::
+
+        sage: matching_polynomial(graphs.CompleteGraph(0), complement=False)
+        1
+        sage: matching_polynomial(graphs.CompleteGraph(1), complement=False)
+        x
+        sage: matching_polynomial(graphs.CompleteGraph(2), complement=False)
+        x^2 - 1
+        sage: matching_polynomial(graphs.CompleteGraph(3), complement=False)
+        x^3 - 3*x
+        sage: matching_polynomial(graphs.CompleteGraph(4), complement=False)
+        x^4 - 6*x^2 + 3
+        sage: matching_polynomial(graphs.CompleteGraph(5), complement=False)
+        x^5 - 10*x^3 + 15*x
+        sage: matching_polynomial(graphs.CompleteGraph(6), complement=False)
+        x^6 - 15*x^4 + 45*x^2 - 15
+        sage: matching_polynomial(graphs.CompleteGraph(7), complement=False)
+        x^7 - 21*x^5 + 105*x^3 - 105*x
+        sage: matching_polynomial(graphs.CompleteGraph(8), complement=False)
+        x^8 - 28*x^6 + 210*x^4 - 420*x^2 + 105
+        sage: matching_polynomial(graphs.CompleteGraph(9), complement=False)
+        x^9 - 36*x^7 + 378*x^5 - 1260*x^3 + 945*x
+        sage: matching_polynomial(graphs.CompleteGraph(10), complement=False)
+        x^10 - 45*x^8 + 630*x^6 - 3150*x^4 + 4725*x^2 - 945
+        sage: matching_polynomial(graphs.CompleteGraph(11), complement=False)
+        x^11 - 55*x^9 + 990*x^7 - 6930*x^5 + 17325*x^3 - 10395*x
+        sage: matching_polynomial(graphs.CompleteGraph(12), complement=False)
+        x^12 - 66*x^10 + 1485*x^8 - 13860*x^6 + 51975*x^4 - 62370*x^2 + 10395
+        sage: matching_polynomial(graphs.CompleteGraph(13), complement=False)
+        x^13 - 78*x^11 + 2145*x^9 - 25740*x^7 + 135135*x^5 - 270270*x^3 + 135135*x
+
+    TESTS:
+
+    Non-integer labels should work, (:issue:`15545`)::
+
+        sage: G = Graph(10)
+        sage: G.add_vertex((0,1))
+        sage: G.add_vertex('X')
+        sage: G.matching_polynomial()
+        x^12
+    """
+    if G.has_multiple_edges():
+        raise NotImplementedError
+
+    cdef int i, j, d
+    cdef fmpz_poly_t pol
+    cdef int nverts = G.num_verts()
+
+    # Using Godsil's duality theorem when the graph is dense
+
+    if complement and G.density() > 0.5:  # this cutoff could probably be tuned
+        f_comp = matching_polynomial(G.complement()).list()
+        f = x.parent().zero()
+        for i in range(nverts // 2 + 1):
+            j = nverts - 2 * i
+            f += complete_poly(j) * f_comp[j] * (-1)**i
+        return f
+
+    cdef int nedges = G.num_edges()
+
+    # Relabelling the vertices of the graph as [0...n-1] so that they are sorted
+    # in increasing order of degree
+
+    cdef list L = []
+    for v, d in G.degree_iterator(labels=True):
+        L.append((d, v))
+    L.sort(key=lambda pair: pair[0])
+    G = G.relabel(perm={L[i][1]: i for i in range(nverts)}, inplace=False)
+    G.allow_loops(False)
+
+    # Initialization of pol, edges* variables.
+
+    # The edges_mem table is of size (2 * nedges * nedges), and is to be read as
+    # nedges blocks of size (2 * nedges). These blocks of size (2 * nedges) are
+    # themselves to be read as two blocks of length nedges, addressed as edges1
+    # and edges2.
+    #
+    # Only the first block of size (2 * nedges) is here filled. The function
+    # delete_and_add will need the rest of the memory.
+
+    fmpz_poly_init(pol)  # sets to zero
+    cdef int** edges = <int**>check_allocarray(2 * nedges, sizeof(int*))
+    cdef int* edges_mem = <int*>check_allocarray(2 * nedges * nedges, sizeof(int))
+
+    for i in range(2 * nedges):
+        edges[i] = edges_mem + i * nedges
+
+    cdef int* edges1 = edges_mem           # edges[0]
+    cdef int* edges2 = edges_mem + nedges  # edges[1]
+
+    cdef int cur = 0
+    for i, j in sorted(map(sorted, G.edge_iterator(labels=False))):
+        edges1[cur] = i
+        edges2[cur] = j
+        cur += 1
+
+    # Computing the signless matching polynomial
+
+    sig_on()
+    delete_and_add(edges, nverts, nedges, nverts, 0, pol)
+    sig_off()
+
+    # Building the actual matching polynomial
+
+    cdef list coeffs_ZZ = []
+    cdef Integer c_ZZ
+    for i in range(nverts + 1):
+        c_ZZ = Integer(0)
+        fmpz_poly_get_coeff_mpz(c_ZZ.value, pol, i)
+        coeffs_ZZ.append(c_ZZ * (-1)**((nverts - i) // 2))
+
+    f = x.parent()(coeffs_ZZ)
+    sig_free(edges_mem)
+    sig_free(edges)
+    fmpz_poly_clear(pol)
+    if name is not None:
+        return f.change_variable_name(name)
+    return f
+
+
+# The following is a cache of complete graph matching polynomials.
+
+cdef list complete_matching_polys = [x.parent().one(), x]
+
+
+def complete_poly(n):
+    """
+    Compute the matching polynomial of the complete graph on `n` vertices.
+
+    INPUT:
+
+    - ``n`` -- order of the complete graph
+
+    .. TODO::
+
+        This code could probably be made more efficient by using FLINT
+        polynomials and being written in Cython, using an array of
+        fmpz_poly_t pointers or something...  Right now just about the
+        whole complement optimization is written in Python, and could
+        be easily sped up.
+
+    EXAMPLES::
+
+        sage: from sage.graphs.matchpoly import complete_poly
+        sage: f = complete_poly(10)
+        sage: f
+        x^10 - 45*x^8 + 630*x^6 - 3150*x^4 + 4725*x^2 - 945
+        sage: f = complete_poly(20)
+        sage: f[8]
+        1309458150
+        sage: f = complete_poly(1000)
+        sage: len(str(f))
+        406824
+
+    TESTS:
+
+    Checking the numerical results up to 20::
+
+        sage: from sage.functions.orthogonal_polys import hermite                       # needs sage.symbolic
+        sage: p = lambda n: 2^(-n/2)*hermite(n, x/sqrt(2))                              # needs sage.symbolic
+        sage: all(p(i) == complete_poly(i) for i in range(2, 20))                       # needs sage.symbolic
+        True
+    """
+    # global complete_matching_polys # if we do eventually make it a C array...
+    cdef int lcmp = len(complete_matching_polys)
+
+    if n < lcmp:
+        return complete_matching_polys[n]
+    lcmp -= 2
+    a = complete_matching_polys[lcmp]
+    b = complete_matching_polys[lcmp + 1]
+    while lcmp + 2 <= n:
+        a, b, lcmp = b, x * b - (lcmp + 1) * a, lcmp + 1
+        complete_matching_polys.append(b)
+    return b
+
+
+cdef void delete_and_add(int **edges, int nverts, int nedges, int totverts, int depth, fmpz_poly_t pol) noexcept:
+    """
+    Add matching polynomial to pol via recursion.
+
+    NOTE : at the end of this function, pol represents the *SIGNLESS*
+    matching polynomial.
+    """
+    cdef fmpz* coeff
+
+    if nverts == 3:
+        coeff = fmpz_poly_get_coeff_ptr(pol, 3)
+        if coeff is NULL:
+            fmpz_poly_set_coeff_ui(pol, 3, 1)
+        else:
+            fmpz_add_ui(coeff, coeff, 1)
+        coeff = fmpz_poly_get_coeff_ptr(pol, 1)
+        if coeff is NULL:
+            fmpz_poly_set_coeff_ui(pol, 1, nedges)
+        else:
+            fmpz_add_ui(coeff, coeff, nedges)
+        return
+
+    if not nedges:
+        coeff = fmpz_poly_get_coeff_ptr(pol, nverts)
+        if coeff is NULL:
+            fmpz_poly_set_coeff_ui(pol, nverts, 1)
+        else:
+            fmpz_add_ui(coeff, coeff, 1)
+        return
+
+    cdef int* edges1 = edges[2 * depth]
+    cdef int* edges2 = edges[2 * depth + 1]
+    cdef int* new_edges1 = edges[2 * depth + 2]
+    cdef int* new_edges2 = edges[2 * depth + 3]
+
+    nedges -= 1
+
+    # The last edge is (edge1, edge2)
+    cdef int edge1 = edges1[nedges]
+    cdef int edge2 = edges2[nedges]
+    cdef int new_nedges = 0
+    cdef int i
+
+    # The new edges are all the edges that are not incident with (edge1, edge2)
+
+    for i in range(nedges):
+        if edge1 == edges1[i]:
+            # Since the rest of the edges are incident to edge1 (the edges are
+            # sorted by increasing order of their first component), we can stop
+            break
+
+        if edge1 != edges2[i] and edge2 != edges2[i]:
+            # since edge2 > edge1 > edges1[i], we only need to check edges2[i]
+            new_edges1[new_nedges] = edges1[i]
+            new_edges2[new_nedges] = edges2[i]
+            new_nedges += 1
+
+    delete_and_add(edges, nverts - 2, new_nedges, totverts, depth + 1, pol)
+    delete_and_add(edges, nverts, nedges, totverts, depth, pol)

sage/libs/all__sagemath_flint.py

@@ -0,0 +1,17 @@
+# sage_setup: distribution = sagemath-flint
+
+try:
+    from sage.libs.all__sagemath_pari import *
+except ImportError:
+    pass
+
+try:
+    from sage.libs.all__sagemath_ntl import *
+except ImportError:
+    pass
+
+from sage.misc.lazy_import import lazy_import
+
+lazy_import('sage.libs.flint.qsieve_sage', 'qsieve')
+
+del lazy_import

sage/libs/arb/__init__.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-flint

sage/libs/arb/acb.pxd

@@ -0,0 +1,154 @@
+# sage_setup: distribution = sagemath-flint
+# Deprecated header file; use sage/libs/flint/acb.pxd instead
+# See https://github.com/sagemath/sage/pull/36449
+
+from sage.libs.flint.types cimport acb_struct, acb_t, acb_ptr, acb_srcptr
+
+from sage.libs.flint.acb cimport (
+    acb_realref,
+    acb_imagref,
+    acb_init,
+    acb_clear,
+    _acb_vec_init,
+    _acb_vec_clear,
+    acb_is_zero,
+    acb_is_one,
+    acb_is_finite,
+    acb_is_exact,
+    acb_is_int,
+    acb_zero,
+    acb_one,
+    acb_onei,
+    acb_set,
+    acb_set_ui,
+    acb_set_si,
+    acb_set_fmpz,
+    acb_set_arb,
+    acb_set_fmpq,
+    acb_set_round,
+    acb_set_round_fmpz,
+    acb_set_round_arb,
+    acb_swap,
+    acb_print,
+    acb_printd,
+    acb_randtest,
+    acb_randtest_special,
+    acb_randtest_precise,
+    acb_randtest_param,
+    acb_equal,
+    acb_eq,
+    acb_ne,
+    acb_overlaps,
+    acb_union,
+    acb_get_abs_ubound_arf,
+    acb_get_abs_lbound_arf,
+    acb_get_rad_ubound_arf,
+    acb_get_mag,
+    acb_get_mag_lower,
+    acb_contains_fmpq,
+    acb_contains_fmpz,
+    acb_contains,
+    acb_contains_zero,
+    acb_contains_int,
+    acb_rel_error_bits,
+    acb_rel_accuracy_bits,
+    acb_bits,
+    acb_indeterminate,
+    acb_trim,
+    acb_is_real,
+    acb_get_unique_fmpz,
+    acb_arg,
+    acb_abs,
+    acb_neg,
+    acb_conj,
+    acb_add_ui,
+    acb_add_fmpz,
+    acb_add_arb,
+    acb_add,
+    acb_sub_ui,
+    acb_sub_fmpz,
+    acb_sub_arb,
+    acb_sub,
+    acb_mul_onei,
+    acb_div_onei,
+    acb_mul_ui,
+    acb_mul_si,
+    acb_mul_fmpz,
+    acb_mul_arb,
+    acb_mul,
+    acb_mul_2exp_si,
+    acb_mul_2exp_fmpz,
+    acb_cube,
+    acb_addmul,
+    acb_addmul_ui,
+    acb_addmul_si,
+    acb_addmul_fmpz,
+    acb_addmul_arb,
+    acb_submul,
+    acb_submul_ui,
+    acb_submul_si,
+    acb_submul_fmpz,
+    acb_submul_arb,
+    acb_inv,
+    acb_div_ui,
+    acb_div_si,
+    acb_div_fmpz,
+    acb_div,
+    acb_const_pi,
+    acb_sqrt,
+    acb_rsqrt,
+    acb_pow_fmpz,
+    acb_pow_ui,
+    acb_pow_si,
+    acb_pow_arb,
+    acb_pow,
+    acb_exp,
+    acb_exp_pi_i,
+    acb_exp_invexp,
+    acb_log,
+    acb_log1p,
+    acb_sin,
+    acb_cos,
+    acb_sin_cos,
+    acb_tan,
+    acb_cot,
+    acb_sec,
+    acb_csc,
+    acb_sin_pi,
+    acb_cos_pi,
+    acb_sin_cos_pi,
+    acb_tan_pi,
+    acb_cot_pi,
+    acb_asin,
+    acb_acos,
+    acb_atan,
+    acb_asinh,
+    acb_acosh,
+    acb_atanh,
+    acb_lambertw,
+    acb_sinh,
+    acb_cosh,
+    acb_sinh_cosh,
+    acb_tanh,
+    acb_coth,
+    acb_sech,
+    acb_csch,
+    acb_rising_ui,
+    acb_rising,
+    acb_gamma,
+    acb_rgamma,
+    acb_lgamma,
+    acb_digamma,
+    acb_log_sin_pi,
+    acb_polygamma,
+    acb_barnes_g,
+    acb_log_barnes_g,
+    acb_zeta,
+    acb_hurwitz_zeta,
+    acb_polylog,
+    acb_polylog_si,
+    acb_agm1,
+    acb_agm1_cpx,
+    _acb_vec_init,
+    _acb_vec_sort_pretty,
+    _acb_vec_clear)

sage/libs/arb/acb_calc.pxd

@@ -0,0 +1,9 @@
+# sage_setup: distribution = sagemath-flint
+# Deprecated header file; use sage/libs/flint/acb_calc.pxd instead
+# See https://github.com/sagemath/sage/pull/36449
+
+from sage.libs.flint.types cimport acb_calc_integrate_opt_t, acb_calc_func_t
+
+from sage.libs.flint.acb_calc cimport (
+    acb_calc_integrate,
+    acb_calc_integrate_opt_init)

sage/libs/arb/acb_elliptic.pxd

@@ -0,0 +1,25 @@
+# sage_setup: distribution = sagemath-flint
+# Deprecated header file; use sage/libs/flint/acb_elliptic.pxd instead
+# See https://github.com/sagemath/sage/pull/36449
+
+from sage.libs.flint.acb_elliptic cimport (
+    acb_elliptic_k,
+    acb_elliptic_k_jet,
+    acb_elliptic_k_series,
+    acb_elliptic_e,
+    acb_elliptic_rf,
+    acb_elliptic_rj,
+    acb_elliptic_rg,
+    acb_elliptic_rc1,
+    acb_elliptic_f,
+    acb_elliptic_e_inc,
+    acb_elliptic_pi,
+    acb_elliptic_pi_inc,
+    acb_elliptic_p,
+    acb_elliptic_p_jet,
+    acb_elliptic_p_series,
+    acb_elliptic_zeta,
+    acb_elliptic_sigma,
+    acb_elliptic_roots,
+    acb_elliptic_invariants,
+    acb_elliptic_inv_p)

sage/libs/arb/acb_hypgeom.pxd

@@ -0,0 +1,74 @@
+# sage_setup: distribution = sagemath-flint
+# Deprecated header file; use sage/libs/flint/acb_hypgeom.pxd instead
+# See https://github.com/sagemath/sage/pull/36449
+
+from sage.libs.flint.acb_hypgeom cimport (
+    acb_hypgeom_pfq_bound_factor,
+    acb_hypgeom_pfq_choose_n,
+    acb_hypgeom_pfq_sum_forward,
+    acb_hypgeom_pfq_sum_rs,
+    acb_hypgeom_pfq_sum_bs,
+    acb_hypgeom_pfq_sum_fme,
+    acb_hypgeom_pfq_sum,
+    acb_hypgeom_pfq_sum_bs_invz,
+    acb_hypgeom_pfq_sum_invz,
+    acb_hypgeom_pfq_direct,
+    acb_hypgeom_pfq_series_direct,
+    acb_hypgeom_u_asymp,
+    acb_hypgeom_u_use_asymp,
+    acb_hypgeom_u_1f1_series,
+    acb_hypgeom_u_1f1,
+    acb_hypgeom_u,
+    acb_hypgeom_m_asymp,
+    acb_hypgeom_m_1f1,
+    acb_hypgeom_m,
+    acb_hypgeom_erf_1f1a,
+    acb_hypgeom_erf_1f1b,
+    acb_hypgeom_erf_asymp,
+    acb_hypgeom_erf,
+    acb_hypgeom_erfc,
+    acb_hypgeom_erfi,
+    acb_hypgeom_bessel_j_asymp,
+    acb_hypgeom_bessel_j_0f1,
+    acb_hypgeom_bessel_j,
+    acb_hypgeom_bessel_jy,
+    acb_hypgeom_bessel_y,
+    acb_hypgeom_bessel_i_asymp,
+    acb_hypgeom_bessel_i_0f1,
+    acb_hypgeom_bessel_i,
+    acb_hypgeom_bessel_k_asymp,
+    acb_hypgeom_bessel_k_0f1_series,
+    acb_hypgeom_bessel_k_0f1,
+    acb_hypgeom_bessel_k,
+    acb_hypgeom_gamma_upper_asymp,
+    acb_hypgeom_gamma_upper_1f1a,
+    acb_hypgeom_gamma_upper_1f1b,
+    acb_hypgeom_gamma_upper_singular,
+    acb_hypgeom_gamma_upper,
+    acb_hypgeom_expint,
+    acb_hypgeom_ei_asymp,
+    acb_hypgeom_ei_2f2,
+    acb_hypgeom_ei,
+    acb_hypgeom_si_asymp,
+    acb_hypgeom_si_1f2,
+    acb_hypgeom_si,
+    acb_hypgeom_ci_asymp,
+    acb_hypgeom_ci_2f3,
+    acb_hypgeom_ci,
+    acb_hypgeom_shi,
+    acb_hypgeom_chi_asymp,
+    acb_hypgeom_chi_2f3,
+    acb_hypgeom_chi,
+    acb_hypgeom_li,
+    acb_hypgeom_0f1,
+    acb_hypgeom_2f1,
+    acb_hypgeom_legendre_p,
+    acb_hypgeom_legendre_q,
+    acb_hypgeom_jacobi_p,
+    acb_hypgeom_gegenbauer_c,
+    acb_hypgeom_laguerre_l,
+    acb_hypgeom_hermite_h,
+    acb_hypgeom_chebyshev_t,
+    acb_hypgeom_chebyshev_u,
+    acb_hypgeom_spherical_y,
+    acb_hypgeom_airy)