o èEbÚÇã @sêdZdZdZdZdZdZdZddlZddlZddl Z ddl Z ddl Z ddl Z dd l mZddlZe j e j e¡¡Zed ƒZd d d dddddddœ Zddddddddddœ Zdddd d!d"d#d$d%œZd&d'gd(gd)d*gd)gd)d*gd(d+gd*gd)gd)d*gd,œ Zd-d.„Zd/d0„Zegd1¢ƒZd2d2d2d2d2d2d3d3d%œZd4d5„Z d6d7„Z!d8d9„Z"d:d;„Z#dd?„Z%d@dA„Z&GdBdC„dCƒZ'GdDdE„dEe'ƒZ(GdFdG„dGe'ƒZ)dHdI„Z*dJdK„Z+dLdM„Z,dNe-dOee(fdPdQ„Z.dRdS„Z/dTdU„Z0dVdW„Z1e2dXkróe1ƒdSdS)YaC python _generate_pyx.py Generate Ufunc definition source files for scipy.special. Produces files '_ufuncs.c' and '_ufuncs_cxx.c' by first producing Cython. This will generate both calls to PyUFunc_FromFuncAndData and the required ufunc inner loops. The functions signatures are contained in 'functions.json', the syntax for a function signature is : ':' '*' '->' '*' : * : * : ? : ? : [',' ]* The input parameter types are denoted by single character type codes, according to 'f': 'float' 'd': 'double' 'g': 'long double' 'F': 'float complex' 'D': 'double complex' 'G': 'long double complex' 'i': 'int' 'l': 'long' 'v': 'void' If multiple kernel functions are given for a single ufunc, the one which is used is determined by the standard ufunc mechanism. Kernel functions that are listed first are also matched first against the ufunc input types, so functions listed earlier take precedence. In addition, versions with casted variables, such as d->f,D->F and i->d are automatically generated. There should be either a single header that contains all of the kernel functions listed, or there should be one header for each kernel function. Cython pxd files are allowed in addition to .h files. Cython functions may use fused types, but the names in the list should be the specialized ones, such as 'somefunc[float]'. Function coming from C++ should have ``++`` appended to the name of the header. Floating-point exceptions inside these Ufuncs are converted to special function errors --- which are separately controlled by the user, and off by default, as they are usually not especially useful for the user. The C++ module -------------- In addition to ``_ufuncs`` module, a second module ``_ufuncs_cxx`` is generated. This module only exports function pointers that are to be used when constructing some of the ufuncs in ``_ufuncs``. The function pointers are exported via Cython's standard mechanism. This mainly avoids build issues --- Python distutils has no way to figure out what to do if you want to link both C++ and Fortran code in the same shared library. z}# This file is automatically generated by _generate_pyx.py. # Do not edit manually! include "_ufuncs_extra_code_common.pxi" z!include "_ufuncs_extra_code.pxi" z# # Aliases # jn = jv a±# This file is automatically generated by _generate_pyx.py. # Do not edit manually! ctypedef fused number_t: double complex double cpdef number_t spherical_jn(long n, number_t z, bint derivative=*) nogil cpdef number_t spherical_yn(long n, number_t z, bint derivative=*) nogil cpdef number_t spherical_in(long n, number_t z, bint derivative=*) nogil cpdef number_t spherical_kn(long n, number_t z, bint derivative=*) nogil at # This file is automatically generated by _generate_pyx.py. # Do not edit manually! """ .. highlight:: cython Cython API for special functions ================================ Scalar, typed versions of many of the functions in ``scipy.special`` can be accessed directly from Cython; the complete list is given below. Functions are overloaded using Cython fused types so their names match their Python counterpart. The module follows the following conventions: - If a function's Python counterpart returns multiple values, then the function returns its outputs via pointers in the final arguments. - If a function's Python counterpart returns a single value, then the function's output is returned directly. The module is usable from Cython via:: cimport scipy.special.cython_special Error handling -------------- Functions can indicate an error by returning ``nan``; however they cannot emit warnings like their counterparts in ``scipy.special``. Available functions ------------------- FUNCLIST Custom functions ---------------- Some functions in ``scipy.special`` which are not ufuncs have custom Cython wrappers. Spherical Bessel functions ~~~~~~~~~~~~~~~~~~~~~~~~~~ The optional ``derivative`` boolean argument is replaced with an optional Cython ``bint``, leading to the following signatures. - :py:func:`~scipy.special.spherical_jn`:: double complex spherical_jn(long, double complex) double complex spherical_jn(long, double complex, bint) double spherical_jn(long, double) double spherical_jn(long, double, bint) - :py:func:`~scipy.special.spherical_yn`:: double complex spherical_yn(long, double complex) double complex spherical_yn(long, double complex, bint) double spherical_yn(long, double) double spherical_yn(long, double, bint) - :py:func:`~scipy.special.spherical_in`:: double complex spherical_in(long, double complex) double complex spherical_in(long, double complex, bint) double spherical_in(long, double) double spherical_in(long, double, bint) - :py:func:`~scipy.special.spherical_kn`:: double complex spherical_kn(long, double complex) double complex spherical_kn(long, double complex, bint) double spherical_kn(long, double) double spherical_kn(long, double, bint) """ include "_cython_special.pxi" include "_cython_special_custom.pxi" a+# This file is automatically generated by _generate_pyx.py. # Do not edit manually! from typing import Any, Dict import numpy as np __all__ = [ 'geterr', 'seterr', 'errstate', {ALL} ] def geterr() -> Dict[str, str]: ... def seterr(**kwargs: str) -> Dict[str, str]: ... class errstate: def __init__(self, **kargs: str) -> None: ... def __enter__(self) -> None: ... def __exit__( self, exc_type: Any, # Unused exc_value: Any, # Unused traceback: Any, # Unused ) -> None: ... {STUBS} éN)ÚListZ _add_newdocsÚfloatZdoublez long doublez float complexúdouble complexzlong double complexÚintZlongZvoid) ÚfÚdÚgÚFÚDÚGÚiÚlÚvZ npy_floatZ npy_doubleZnpy_longdoubleZ npy_cfloatZ npy_cdoubleZnpy_clongdoubleZnpy_intZnpy_longZ NPY_FLOATZ NPY_DOUBLEZNPY_LONGDOUBLEZ NPY_CFLOATZ NPY_CDOUBLEZNPY_CLONGDOUBLEZNPY_INTZNPY_LONG)rrrr r r r r zd*ddddzD*DDDDÚddrr ÚdD) ZairyZbetaZerfZexprelZgammaZjvZloggammaZlogitZpsicCs | dd¡S)Nú Ú_)Úreplace)Úarg©rú=/usr/lib/python3/dist-packages/scipy/special/_generate_pyx.pyÚ underscore s rcCsdd„|DƒS)NcSóg|]}d |¡‘qS)ZilfdgFDG)Úindex©Ú.0ÚxrrrÚ %ózcast_order..r)ÚcrrrÚ cast_order$sr ))r r )r r )r r)r r)r r)r r )r r )r r)r r)r r)r r )r r )r r)r r)r r)rr )rr )rr )rr )rr )rr )r r ZNPY_NANZ 0xbad0bad0cCsÒt|ƒt|ƒkr tdƒ‚t|ƒt|ƒkr&|dkr"t|ƒdt|ƒks&tdƒ‚d|||||f}d|}|d7}|d7}|d 7}tt|ƒƒD] }|d ||f7}qEtt|ƒƒD]}|d ||t|ƒf7}qVg}g} g} tt|ƒƒD]}| t||¡|  d t||t|||f¡qqt|ƒdt|ƒkrªd} |  |¡|d t|f7}nd} t|ƒD]'\}} |dt| || f7}| dt| ¡|  d|| ¡|  | ¡q°|d7}t|ƒdt|ƒkréd} nd} d| t|d |¡d | ¡f}g}tt|ƒƒD](}||||ftvr*dt||t|||t|||f}| |¡q|r^|dd |¡7}|d|7}|d7}|d7}t| ƒD]\}} |d|t| t| f7}qJn||7}tt || ƒƒD]O\}\} }|| ftvr©|d|t| |f7}|dt| |t| |f7}|d7}|d 7}|d!t| |t| t| f7}qi|d"t| |t| |f7}qitt|ƒƒD] }|d#||f7}q¿tt|ƒƒD]}|d$||t|ƒf7}qÑ|d%7}||fS)&a¡ Generate a UFunc loop function that calls a function given as its data parameter with the specified input and output arguments and return value. This function can be passed to PyUFunc_FromFuncAndData. Parameters ---------- func_inputs, func_outputs, func_retval : str Signature of the function to call, given as type codes of the input, output and return value arguments. These 1-character codes are given according to the CY_TYPES and TYPE_NAMES lists above. The corresponding C function signature to be called is: retval func(intype1 iv1, intype2 iv2, ..., outtype1 *ov1, ...); If len(ufunc_outputs) == len(func_outputs)+1, the return value is treated as the first output argument. Otherwise, the return value is ignored. ufunc_inputs, ufunc_outputs : str Ufunc input and output signature. This does not have to exactly match the function signature, as long as the type casts work out on the C level. Returns ------- loop_name Name of the generated loop function. loop_body Generated C code for the loop. z2Function and ufunc have different number of inputsréz-Function retval and ufunc outputs don't matchzloop_%s_%s_%s_As_%s_%szTcdef void %s(char **args, np.npy_intp *dims, np.npy_intp *steps, void *data) nogil: z$ cdef np.npy_intp i, n = dims[0] z( cdef void *func = (data)[0] z4 cdef char *func_name = (data)[1] z cdef char *ip%d = args[%d] z cdef char *op%d = args[%d] z<%s>(<%s*>ip%d)[0]z cdef %s ov0 rz cdef %s ov%d z%s *z&ov%dz for i in range(n): zov0 = Úz& %s(<%s(*)(%s) nogil>func)(%s) ú, z$<%s>(<%s*>ip%d)[0] == (<%s*>ip%d)[0]z if %s: ú and ú z else: zQ sf_error.error(func_name, sf_error.DOMAIN, "invalid input argument") z ov%d = <%s>%s z if ov%d == <%s>ov%d: z' (<%s *>op%d)[0] = <%s>ov%d zI sf_error.error(func_name, sf_error.DOMAIN, "invalid output") z% (<%s *>op%d)[0] = <%s>%s z# (<%s *>op%d)[0] = <%s>ov%d z ip%d += steps[%d] z op%d += steps[%d] z" sf_error.check_fpe(func_name) ) ÚlenÚ ValueErrorÚrangeÚappendÚCY_TYPESÚ enumerateÚjoinÚDANGEROUS_DOWNCASTÚ NAN_VALUEÚzip)Z func_inputsZ func_outputsZ func_retvalZ ufunc_inputsZ ufunc_outputsÚnameÚbodyÚjZftypesZfvarsZ outtypecodesZ func_joffÚouttypeZrvZfuncallZ input_checksZchkZfouttyperrrÚ generate_loop@sª'ÿÿ ÿ   þ  ÿ þ €  ÿÿÿ ÿ ÿr4cCsNdd„|Dƒ}|d}d|dg}|D] }| d|¡qd |¡}||fS)z¦ Generate name of and cython code for a fused type. Parameters ---------- typecodes : str Valid inputs to CY_TYPES (i.e. f, d, g, ...). cSóg|]}t|‘qSr©r*rrrrrÏóz'generate_fused_type..Z _number_tzctypedef fused ú:r%Ú )r)r,)ÚcodesZcytypesr0Z declarationZcytyperrrÚgenerate_fused_typeÅs  r;cCs˜d}ggg}}}| d¡}t|ƒdkr|d}|d}n|d}d}gg} } t|ƒD]\} } d | ¡} |  | ¡|  d t| | ¡¡q-d d  | ¡¡}| |¡| |d ¡g}t|ƒD] \} } d  | ¡} | d  | ¡¡d  t| | ¡}| ||¡qa| |d¡| d|d¡d ||d¡}d ||d¡}d ||¡}d |||¡}| |d|d  | ¡¡}| ||d  | |¡¡}||fS)Nr%Ú*r!rr"úx{}ú{} {}zdef {{}}(int N, {}):r#z cdef int núy{}ú&{}ú cdef {} {}zfor n in range(N):éú{}({})z_bench_{}_{}_{}ÚpyÚcyr9z_ufuncs.)Úsplitr&r+Úformatr)r*r,)r0r:ÚtabÚtopZmiddleÚendÚtmpÚincodesÚoutcodesZinargsZinargs_and_typesÚnÚcoderÚlineZoutargsZpyfuncZcyfuncZ pytemplateZ cytemplateÚpybenchÚcybenchrrrÚgenerate_benchØs>        rSc Csºd}d |¡g}|D]B}| d¡\}}| d¡}dd„|dDƒ}t|ƒdkr5d d„|dDƒ}| |¡t|} d  | |d  |¡¡} | d || ¡q d  |d¡|d<d |¡}|S)Nr%z!- :py:func:`~scipy.special.{}`:: z->r<cSr5rr6rrrrrr7z generate_doc..rr!cSsg|] }t|›d‘qS©z *r6rrrrrsz {} {}({})r#rBz{} éÿÿÿÿr9)rGrFr&Úextendr*r,r)) r0ÚspecsrHÚdocÚspecrLrMÚintypesÚtypesr3rPrrrÚ generate_docÿs     r\cCód |¡}|S)z0Cast a Cython double complex to a NumPy cdouble.z1_complexstuff.npy_cdouble_from_double_complex({})©rG©ÚvarÚresrrrÚnpy_cdouble_from_double_complexó rbcCr])z0Cast a NumPy cdouble to a Cython double complex.z1_complexstuff.double_complex_from_npy_cdouble({})r^r_rrrÚdouble_complex_from_npy_cdoublercrdc cszdg}d|vsd|vs|dd„|Dƒ}|D]#\}}|}|}t||ƒD]\}}| ||¡}| ||¡}q$||fVqdS)a. Generate variants of UFunc signatures, by changing variable types, within the limitation that the corresponding C types casts still work out. This does not generate all possibilities, just the ones required for the ufunc to work properly with the most common data types. Parameters ---------- inputs, outputs : str UFunc input and output signature strings Yields ------ new_input, new_output : str Modified input and output strings. Also the original input/output pair is yielded. )r r r r cSs g|] \}}|d|df‘qS)rZfFr)rÚaÚbrrrr?s z!iter_variants..N)r/r) ÚinputsÚoutputsÚmapsÚsrcÚdstZ new_inputsZ new_outputsrerfrrrÚ iter_variantss€þ   úrlc@s8eZdZdZdd„Zdd„Zddd„Z dd d „Zd S)ÚFuncz. Base class for Ufunc and FusedFunc. c Cs`||_g|_i|_| ¡D] }|| ¡D]\}}| |¡\}}}|j |||||f¡qq dS©N)r0Ú signaturesÚfunction_name_overridesÚkeysÚitemsÚ_parse_signaturer))Úselfr0roÚheaderÚsigÚinargÚoutargÚretrrrÚ__init__Ps þÿz Func.__init__cCs”t d|¡}|r)dd„| ¡Dƒ\}}}| d¡dkr$td |j|¡ƒ‚|||fSt d|¡}|rAdd„| ¡Dƒ\}}|d |fStd |j|¡ƒ‚) Nz?\s*([fdgFDGil]*)\s*\*\s*([fdgFDGil]*)\s*->\s*([*fdgFDGil]*)\s*$cSóg|]}| ¡‘qSr©Ústriprrrrr]r7z)Func._parse_signature..r<r!z{}: Invalid signature: {}z)\s*([fdgFDGil]*)\s*->\s*([fdgFDGil]?)\s*$cSr{rr|rrrrrcr7r")ÚreÚmatchÚgroupsÚcountr'rGr0)rtrvÚmrwrxryrrrrsZs    zFunc._parse_signatureFc Cs¸g}|jD]T\}}}}}| dd¡}dd„|Dƒdd„|Dƒ}dd„|Dƒdd„|Dƒ} dt|d  |¡f} | d ¡rE|rE| d } n d t|d  | ¡f} | || | |f¡q|S) Nr<r"cSr5r©ÚC_TYPESrrrrrkr7z'Func.get_prototypes..cSóg|]}t|d‘qSrTrƒrrrrrlócSr5rr6rrrrrmr7cSr…rTr6rrrrrnr†z %s (*)(%s)r#ÚhZnogilz%s (*)(%s) nogil)rorr„r,Úendswithr*r)) rtÚ nptypes_for_hZ prototypesÚ func_namerwrxryruZc_argsZcy_argsÚc_protoÚcy_protorrrÚget_prototypesgs   ÿ  ÿ zFunc.get_prototypesÚ_func_TcCsj|r||jvr|j|}d}t d|¡}|r| ¡\}}n|d}}|r/d||| dd¡fSd||fS)Nr"z^(.*?)(\[.*\])$z%s%s%srrz%s%s)rpr~rr€r)rtÚc_nameÚ specializedÚprefixÚoverrider‚Z c_base_nameZ fused_partrrrÚcython_func_namews    zFunc.cython_func_nameN)F)FrŽT)Ú__name__Ú __module__Ú __qualname__Ú__doc__rzrsrr“rrrrrmKs ÿrmcs0eZdZdZ‡fdd„Zdd„Zdd„Z‡ZS)ÚUfunca Ufunc signature, restricted format suitable for special functions. Parameters ---------- name Name of the ufunc to create signature String of form 'func: fff*ff->f, func2: ddd->*i' describing the C-level functions and types of their input arguments and return values. The syntax is 'function_name: inputparams*outputparams->output_retval*ignored_retval' Attributes ---------- name : str Python name for the Ufunc signatures : list of (func_name, inarg_spec, outarg_spec, ret_spec, header_name) List of parsed signatures doc : str Docstring, obtained from add_newdocs function_name_overrides : dict of str->str Overrides for the function names in signatures csFtƒ ||¡t |¡|_|jdurtd|ƒ‚t |j¡ ¡|_dS)NzNo docstring for ufunc %r) ÚsuperrzÚ add_newdocsÚgetrXr'ÚtextwrapÚdedentr})rtr0ro©Ú __class__rrrz¥s    zUfunc.__init__c sd‰d‰tƒ‰g‰‡‡‡‡‡‡fdd„}ˆjD]6\}}}}}t dd|¡|}| dd¡}ˆdur9t|ƒ‰t|ƒ‰tt||ƒƒd\} }|||||| |ƒqˆjD])\}}}}}t dd|¡|}| dd¡}t||ƒD] \} }|||||| |ƒqlqQˆjdd„d ˆˆˆfS) Nc sš|ˆvrdSˆ |¡|||f}d|vrtdˆj|fƒ‚t|ƒˆks)t|ƒˆkr4tdˆj|ˆˆfƒ‚t|||||ƒ\}}|ˆ|<ˆ ||||f¡dS)Nrz%s: void signature %rz6%s: signature %r does not have %d/%d input/output args)Úaddr'r0r&r4r)) rŠrwrxryÚinpÚoutprvÚ loop_nameZloop©Ú all_loopsÚ inarg_numÚ outarg_numÚseenrtÚvariantsrrÚ add_variant³s  þz4Ufunc._get_signatures_and_loops..add_variantú\*.*r"r<rcSs t|dƒS)NrB)r )rrrrÚÙs z1Ufunc._get_signatures_and_loops..©Úkey) Úsetror~Úsubrr&ÚlistrlÚsort) rtr¥rªrŠrwrxryrur¢r¡rr¤rÚ_get_signatures_and_loops¬s*  ÿ zUfunc._get_signatures_and_loopsc Csæd}| |¡\}}}g}g}g}|D](\} } } } | D] } | t| ¡q| D] } | t| ¡q&| | ¡| | ¡q|d|jt|ƒf7}|d|jdt|ƒf7}|d|jt|ƒf7}|d|jt|ƒf7}|d|j|j dd ¡ d d ¡ d d ¡f7}t|ƒD]\}}|d|j||f7}qƒt|ƒD]\}}|d|j||f7}q–t|ƒD]\}}|d|j||j|ddf7}|d|j||jf7}q©t|ƒD]\}}|d|j||j|f7}qÌ|dt|ƒ||||f d|j¡7}|S)Nr"z2cdef np.PyUFuncGenericFunction ufunc_%s_loops[%d] zcdef void *ufunc_%s_ptr[%d] rBzcdef void *ufunc_%s_data[%d] zcdef char ufunc_%s_types[%d] z&cdef char *ufunc_%s_doc = ( "%s") ú\z\\ú"z\"r9z \n" "z3ufunc_%s_loops[%d] = %s zufunc_%s_types[%d] = %s zufunc_%s_ptr[2*%d] = %s T©rz,ufunc_%s_ptr[2*%d+1] = ("%s") z(ufunc_%s_data[%d] = &ufunc_%s_ptr[2*%d] zo@ = np.PyUFunc_FromFuncAndData(ufunc_@_loops, ufunc_@_data, ufunc_@_types, %d, %d, %d, 0, "@", ufunc_@_doc, 0) ú@) r³r)Ú TYPE_NAMESr0r&rXrr+r“)rtr¥Útoplevelr©r¦r§ZloopsZfuncsr[rŠr£rgrhrr2ÚfunctionÚtypeÚfuncrrrÚgenerateÝsZ ÿ  þ  ÿ  ÿ  ÿÿþ üzUfunc.generate)r”r•r–r—rzr³r½Ú __classcell__rrržrr˜Šs  1r˜cseZdZdZ‡fdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Z‡ZS) Ú FusedFuncz_ Generate code for a fused-type special function that can be cimported in Cython. cs‚tƒ ||¡d|j|_| ¡\|_|_tƒ|_|  |j¡\|_ }|j  |¡|  |j¡\|_ }|j  |¡|  ¡\|_|_dS)Nz(See the documentation for scipy.special.)r™rzr0rXÚ _get_codesrLrMr¯Ú fused_typesÚ _get_typesrZÚupdateÚouttypesÚ _get_varsÚinvarsÚoutvars)rtr0roZ infused_typesZoutfused_typesržrrrzs   zFusedFunc.__init__cs d\}}gg}}|jD]1\}}}}}t dd|¡|} |dur(t|ƒ}t| ƒ}tt|| ƒƒd\} } | | ¡| | ¡q g} t|ƒD]‰t‡fdd„|Dƒƒ} |   ¡|  d  | ¡¡qDg} t|ƒD]‰t‡fdd„|Dƒƒ} |   ¡|  d  | ¡¡qdt | ƒt | ƒfS)N)NNr«r"rcóg|]}|ˆ‘qSrrr©rNrrr.r7z(FusedFunc._get_codes..crÈrrrrÉrrr3r7) ror~r°r&r±rlr)r(Úuniquer²r,Útuple)rtr¦r§Zall_inpZall_outprrwrxryr¢r¡rLr:rMrrÉrrÀ s*     zFusedFunc._get_codescCs`g}tƒ}|D]$}t|ƒdkr| t||f¡qt|ƒ\}}| |¡| ||f¡q||fS)Nr!)r¯r&r)r*r;r )rtr:Z all_typesrÁrOÚ fused_typeÚdecrrrrÂ9s   zFusedFunc._get_typescCs8dd„tt|jƒƒDƒ}dd„tt|jƒƒDƒ}||fS)NcSr)r=r^©rrNrrrrHrz'FusedFunc._get_vars..cSr)r?r^rÎrrrrIr)r(r&rZrÄ)rtrÆrÇrrrrÅGszFusedFunc._get_varsc Csœg}tƒ}t||ƒD]$\\}}}t|ƒdkrq ||vr.| |›dtt|ƒ›¡| |¡q |r@|dkr@d |d |¡¡} | S|rJ|dkrJd} | Sd} | S)z_Generate an if/elif/else clause that selects a specialization of fused types. r!z is Úelsez{} {}:r$úelse:N) r¯r/r&r)rr*r rGr,) rtr[r:ÚadverbZclausesr¨ÚtypZtypcoderOrPrrrÚ_get_conditionalLs"  €  üÿzFusedFunc._get_conditionalcCsBg}t|ƒD]\}}|j|}|r|dkrt|ƒ}| |¡q|S)zxGenerate pure input variables to a specialization, i.e., variables that aren't used to return a value. r)r+rÆrbr))rtrZrZ incallvarsrNÚintyper`rrrÚ_get_incallvarsas   zFusedFunc._get_incallvarsc Cs²ggg}}}t|jƒt|ƒ}|j|d…}tt||ƒƒD]4\}\} } |rK| dkrKd |¡} | | ¡| d | ¡¡t| ƒ} | d | | ¡¡q| d | ¡¡q|||fS)zoGenerate output variables to a specialization, i.e., pointers that are used to return values. Nrztmp{}r@ú {}[0] = {}z{})r&rÇr+r/rGr)rd) rtrÄrÚ outcallvarsÚtmpvarsÚcastsÚstartrÇrNr`r3rKZtmpcastrrrÚ_get_outcallvarsns    zFusedFunc._get_outcallvarscs¬d‰gˆdg}}tƒ}t|j|j|jƒD]1\}}}t|ƒdkr3d |t|¡}| dˆ|¡q|}|\} } | |vrG| |¡|  | ¡q|sL|St dd„|Dƒƒ} dd„| Dƒ} t   | ¡d} t tj| ŽƒD]i\}}gg}}t |ƒD]/\}}||}| tt|ƒ¡t |jƒD]\}}|j||kr¥d |t|¡}| |¡qqw|d kr®d }n || krµd }nd }| |||¡}| dˆ|¡| ‡fd d„|Dƒ¡qj|S)znSet all variables to nan for specializations of fused types for which don't have signatures. r%rÐr!rÖrBcSsg|]\}}|‘qSrr)rZ_unusedr:rrrr›r7z+FusedFunc._get_nan_decs..cSsg|]}t|ƒ‘qSr)r&rrrrrr7rÚifrÏÚelifcsg|]}dˆ|‘qS)érr©rHrrr°r†)r¯r/rÇrÄrMr&rGr.r)r rËÚnumpyZprodr+Ú itertoolsÚproductrr*rÓrV)rtrÁÚlinesr¨Úoutvarr3rOrPrÌr0rZ all_codesZcodelensÚlastr‚r:Z fused_codesZdecsrNÚnnrÑÚcondrrßrÚ _get_nan_decsƒsP ÿ   €  €ýzFusedFunc._get_nan_decscs*d‰t|ƒ}| ¡‡fdd„|Dƒ}|S)zQGenerate the declarations of any necessary temporary variables. r%csg|] }ˆd |¡‘qS)zcdef npy_cdouble {}r^)rZtmpvarrßrrr»sÿz+FusedFunc._get_tmp_decs..)r±r²)rtÚ all_tmpvarsrØZtmpdecsrrßrÚ _get_tmp_decs³s ÿzFusedFunc._get_tmp_decsc Csúd}gg}}t|j|jƒD]\\}}}| d ||¡¡qd |jd |¡¡}| |¡t|j|jƒD]\\}}} d || ¡}| ||¡q4dd„|jDƒ} d |jd |j¡d | ¡¡}| ||¡d  d |j¡¡}| ||¡d  |¡}|S) zaGenerate a Python wrapper for functions which pass their arguments as pointers. r%r>zdef _{}_pywrap({}):r#rAcSsg|]}d|›‘qS)ú&rrrrrrÍrz.FusedFunc._get_python_wrap..z {}({}, {})ú return {}r9) r/rZrÆr)rGr0r,rÄrÇ) rtrHr1ÚcallvarsrÔrÚinvarrPr3räZ addr_outvarsrrrÚ_get_python_wrap¿s$   ÿ zFusedFunc._get_python_wrapc Cs(d}|\}}}}}| dd¡}| dd¡}| dd¡}| d¡r#d} nd} | d¡r-d} nd} dd „|Dƒ} d d „|Dƒ} t d d |¡}|sHd }t|} | r`d |¡}d | d | | ¡|¡}n|j|dd}|dkrnd}nd}| |j ||¡}|r„||g}d|}ng}|}||||| | | | ||f S)z4Generate code common to all the _generate_* methods.r%r r r‡TFú++cSr5rr6rrrrrèr7z)FusedFunc._get_common..cSr5rr6rrrrrér7r«r"rz$scipy.special._ufuncs_cxx._export_{}z(<{}(*)({}) nogil>{})r#r¶rrÜrÝrB) rrˆr~r°r*rGr,r“rÓrZ)rtÚsignumrvrHrŠrLrMÚretcoderurZcpprZrÄÚrettyperÑrçrãÚsprrrÚ _get_commonÖsF      ÿ   ÿzFusedFunc._get_commonc Csd}gg}}t|jƒD]I\}}| ||¡\ }}}} } } } } }}| |¡| | | ¡}d |d |¡¡}| r>| dkr>t|ƒ}|d |¡}| |¡d || ¡}| |¡q t |ƒdkrÁ| |d¡|j d \}}t |ƒd}t |ƒdkr‡d t |¡}| d ||¡n:t|ƒD]5\}}|d kr–d }n ||krd }nd }|  |j ||¡}| d ||¡d t |¡}| d||¡q‹gg}}t|j ƒD]\}\}}| d ||j|¡¡qË|j d \}}d ||jd |¡¡}| |d¡| |d |j¡¡d ||¡}|||fS)Nr%rCr#rrìú{}->{}r!rÐrrBrÜrÏrÝrÞr>úcpdef {} {}({}) nogilr8ú"""{}"""r9)r+rorõrVrÕrGr,rdr)r&rÄr.rÓrZrÆr0rX)rtrHrWr1rñrvrŠrLrMròrZrÄrórrãrôríÚcallrPr3rårNrOrÑrçÚheadrÔrrÍrjrrrÚ$_generate_from_return_and_no_outargssR  ÿ           z.FusedFunc._generate_from_return_and_no_outargsc sŠd}tƒ}gg}}t|jƒD]k\}}| ||¡\ }}} } } } } }}‰| |¡| | |¡}| | |¡\}}}| |¡| |¡d |d  |¡¡}|  ˆ|¡| ‡fdd„|Dƒ¡t | ƒdkrod || ¡}|  |¡qd || ¡}|  |¡qt |ƒdkrŠ|  ¡}| |¡t |j ƒdkr d  |j d ¡}|  ||¡gg}}t|j|jƒD]\}\}}|  d  ||¡¡q¬t |j ƒdkrÚt|j |jƒD]\}\}}|  d  ||¡¡qÊt |j ƒdkrô|jd \}}d  ||jd  |¡¡}n d |jd  |¡¡}|  |d¡|  |d |j¡¡t |j ƒdkr1|j d }|jd \}}d ||¡}|  ||¡| | |¡¡d  ||¡}|||fS)Nr%rCr#cóg|]}ˆ|‘qSrrr©rôrrrKr7zBFusedFunc._generate_from_outargs_and_no_return..r!röú{}*{}->vz return {}[0]rr>ú{} *{}r÷úcdef void {}({}) nogilr8rørAr9)r¯r+rorõrVrÕrÛrÃrGr,r)r&rèrÇr/rÆrZrÄr0rXrê)rtrHrérWr1rñrvrŠrLrMròrZrÄrórrãrír×rØrÙrùrPrúrîrÔrrär3rÍrjrrýrÚ$_generate_from_outargs_and_no_return:s\  ÿ               z.FusedFunc._generate_from_outargs_and_no_returnc sàd}tƒ}gg}}t|jƒD]n\}}| ||¡\ }}} } } } } }}‰| |¡| | |¡}| | |¡\}}}| |¡| |¡d |d  |¡¡}|rT| dkrTt |ƒ}d |j d|¡}|  ˆ|¡| ‡fdd„|Dƒ¡d  || | ¡}|  |¡qt |ƒd kr| ¡}| |¡gg}}t|j|jƒD]\}\}}|  d  ||¡¡q™t|j |jƒD]\}\}}|  d  ||¡¡q°d  |jd  |¡¡}|  |d¡|  |d |j¡¡| | |¡¡d  ||¡}|||fS)Nr%rCr#rrÖrcrürrrrýrrr†r7z?FusedFunc._generate_from_outargs_and_return..rþr!r>rÿrr8rør9)r¯r+rorõrVrÕrÛrÃrGr,rdrÇr)r&rèr/rÆrZrÄr0rXrê)rtrHrérWr1rñrvrŠrLrMròrZrÄrórrãrír×rØrÙrùrúrîrÔrrär3rÍrjrrýrÚ!_generate_from_outargs_and_returnssD  ÿ          z+FusedFunc._generate_from_outargs_and_returncCsÊ|jd\}}}}}t dd|¡}|sd}t|ƒdkr'|dkr'| ¡\}}}n(t|ƒdkr9|dkr9| ¡\}}}nt|ƒdkrK|dkrK| ¡\}}}ntdƒ‚t|jƒdkr[|  ¡}nd}||||j |fS)Nrr«r"rzInvalid signaturer!) ror~r°r&rûrrr'rÇrïrÁ)rtrrMròrÍrjrWÚwraprrrr½œs zFusedFunc.generate)r”r•r–r—rzrÀrÂrÅrÓrÕrÛrèrêrïrõrûrrr½r¾rrržrr¿s"   0 139)r¿c Csüg}g}| dd¡ dd¡ dd¡}| d¡rL| d|dd…|j|d d | |¡f¡d |} | d | d | ¡¡| d| | |j|ddf¡n-d| |¡|f} | d|¡| d| d | ¡¡| d|¡| d| d |¡¡|||fS)zÑ Construct a Cython declaration of a function coming either from a pxd or a header file. Do sufficient tricks to enable compile-time type checking against the signature expected by the ufunc. ú[rú]rú.pxdzfrom .%s cimport %s as %sNéüÿÿÿr")r‘z _proto_%s_tz ctypedef %sz(*)zcdef %s *%s_var = &%sTr¶z%s "%s"zcdef extern from "%s":z cdef %sz #include "%s"z%s;)rrˆr)r“) Úufuncrr‹rŒruÚproto_h_filenameÚdefsÚdefs_hÚvar_nameZ proto_nameÚnew_namerrrÚget_declaration³s& þ ÿ rc Cs2|d}|d}|d}|d}|d}d}g} g} i} g} ddg} g}|jdd„d |D]p}| ¡}|D]\\}}}}| d ¡r||dd …}t||||||ƒ\}}}|  |¡| |¡|  d ||j|d ddf¡|  d|f¡d||j|<q6t||||||ƒ\}}}|  |¡|  |¡q6| | ¡}||d7}q.d  t |   ¡ƒ| |g¡}dd„|Dƒgd¢}d  d  |¡¡}t |dƒ&}| t¡| t¡| |¡| d¡| |¡| t¡Wdƒn1sîwYt| ƒ} t |dƒ}| d¡| d  | ¡¡| d¡Wdƒn 1swYt|ƒ}t |dƒ}| d¡| d  |¡¡| d¡Wdƒn 1sFwYt |dƒ}| t¡| d¡| d  | ¡¡| d¡Wdƒn 1sswYt |dƒ}| d  | ¡¡WdƒdS1s’wYdS)Nú.pyxú_defs.hrr"zfrom . cimport sf_errorzFcdef void _set_action(sf_error.sf_error_t, sf_error.sf_action_t) nogilcSs|jSrn)r0)Úurrrr¬ísz!generate_ufuncs..r­rðéþÿÿÿz!cdef void *_export_%s = %sTF)rr’zcdef void *_export_%sz"scipy.special._ufuncs_cxx._export_r9cSs$g|]}|j d¡sd |j¡‘qS)rz'{}')r0Ú startswithrG)rrrrrrs  þ ÿz#generate_ufuncs..)z'geterr'z'seterr'z 'errstate'ú'jn'z__all__ = [{}]r#Úwz0#ifndef UFUNCS_PROTO_H #define UFUNCS_PROTO_H 1 z #endif z # distutils: language = c++ )r²rrˆrrVr)r“rpr½r,ÚsortedÚvaluesrGÚopenÚwriteÚUFUNCS_EXTRA_CODE_COMMONÚUFUNCS_EXTRA_CODEÚUFUNCS_EXTRA_CODE_BOTTOMrÊ)Z fn_prefixZ cxx_fn_prefixÚufuncsÚfilenamer Zcxx_proto_h_filenameZcxx_pyx_filenameZcxx_pxd_filenamer¹r r r¥Zcxx_defsZ cxx_pxd_defsZ cxx_defs_hrÚcfuncsrr‹rŒruÚ item_defsZ item_defs_hr rÚtZ all_ufuncsÚ module_allrrrrÚgenerate_ufuncsÖs”þ    ÿ  ÿ  ÿ   þüÿ       ú   ý   ý    ü $ÿr#c Cs6|d}|d}|d}g}g}g}tƒ} g} g} |D]s} | j d¡r$q|  ¡\} }}}}| | ¡| |¡|r>| |¡|  |¡| jdd}|D]\}}}}| d¡rWqKt| |||||ƒ\}}}|   |¡qK|  t | j|ƒ¡| jt vrŽt | jD]}t | j|ƒ\}}|  ||g¡q|qt | ƒ} |  ¡t|dƒ'}| t¡| d ¡| d  | ¡¡| d ¡| d  |¡¡Wdƒn1sÆwYt|dƒ@}t}| d d  | ¡¡}| |¡| d ¡| d  | ¡¡| d ¡| d  |¡¡| d ¡| d  |¡¡WdƒdS1swYdS) NrrrrT)r‰rðrr9z ZFUNCLIST)r¯r0rr½r)rÃrrˆrrVr\ÚCYTHON_SPECIAL_BENCHFUNCSrSr±r²rrÚCYTHON_SPECIAL_PXDr,ÚCYTHON_SPECIAL_PYXr)ÚmodnameZufunc_fn_prefixÚ fused_funcsZpxdfileZpyxfiler ZsourcesZ declarationsZ bench_auxrÁrXr r¼rÍrjrWZfunc_fused_typesrrrr‹rŒrur rr:rQrRrrrrÚgenerate_fused_funcs7sj        þ  €    û     $÷r)Ú module_namercCsÈgg}}|D]}| |j›d¡|j d¡s"| d|j›d¡q| d¡| d¡| ¡| ¡tjd |¡d |¡d}|›d }t|d ƒ}| |¡WdƒdS1s]wYdS) Nz : np.ufuncrú'rz jn: np.ufuncz, r9)ZALLÚSTUBSz.pyir) r)r0rr²r,rGr,rr)r*rZstubsr"rÚcontentsZ stubs_filerrrrÚgenerate_ufuncs_type_stubs}s$  €  þ   "ÿr.cCs6tƒ}g}|D]}||vrq| |¡| |¡q|S)zb Return a list without repeated entries (first occurrence is kept), preserving order. )r¯r r))Zlstr¨Znew_lstÚitemrrrrÊ“s  rÊcs$ddlm‰t‡‡fdd„|DƒƒS)Nr)Únewerc3s0|]}ˆD]}tj |¡oˆ||ƒVqqdSrn)ÚosÚpathÚexists)rrkrj©r0Ú src_filesrrÚ ¤s €ÿ ÿzall_newer..)Zdistutils.dep_utilr0Úall)r5Ú dst_filesrr4rÚ all_newer¢s ÿr9c Cs0tjtpd ¡d}| ¡\}}t|ƒdkr| d¡tj  t ¡}tj  t ¡tj  tj  |d¡¡tj  tj  |d¡¡f}d}t  t¡t||ƒrNtdƒdSgg}}tdƒ }t |¡} Wdƒn1sgwY|  ¡D]\} } | t| | ƒ¡| t| | ƒ¡qptd d |ƒtd |ƒtd d |ƒdS) Nr")Úusagerzinvalid number of argumentszfunctions.jsonz_add_newdocs.py)z _ufuncs.pyxz_ufuncs_defs.hz_ufuncs_cxx.pyxz_ufuncs_cxx.pxdz_ufuncs_cxx_defs.hz _ufuncs.pyizcython_special.pyxzcython_special.pxdz4scipy/special/_generate_pyx.py: all files up-to-dateZ_ufuncsZ _ufuncs_cxxZcython_special)ÚoptparseZ OptionParserr—r}Ú parse_argsr&Úerrorr1r2ÚdirnameÚ__file__Úabspathr,ÚchdirÚBASE_DIRr9ÚprintrÚjsonÚloadrrr)r˜r¿r#r.r)) ÚpÚoptionsÚargsÚpwdr5r8rr(ÚdataZ functionsrrvrrrÚmain¨s0     þ    ÿ  rKÚ__main__)3r—rrrr%r&r,rárDr1r;r~rœÚtypingrràr2r@r>r?rBÚ __import__ršr*r„r¸r$rr r¯r-r.r4r;rSr\rbrdrlrmr˜r¿rr#r)Ústrr.rÊr9rKr”rrrrÚsºJQ% ÷ ÷ ø ÷   ø '.?(#aF$ ÿ