a a1@sdZddlZddlZddlmZdZdZdZdZdefd efd efd efgZ d d gZ gdZ dZ dZ dZddZddZddZddZedkredS)a python generate_sparsetools.py Generate manual wrappers for C++ sparsetools code. Type codes used: 'i': integer scalar 'I': integer array 'T': data array 'B': boolean array 'V': std::vector* 'W': std::vector* '*': indicates that the next argument is an output argument 'v': void 'l': 64-bit integer scalar See sparsetools.cxx for more details. N)newera bsr_diagonal v iiiiiIIT*T bsr_tocsr v iiiiIIT*I*I*T bsr_scale_rows v iiiiII*TT bsr_scale_columns v iiiiII*TT bsr_sort_indices v iiii*I*I*T bsr_transpose v iiiiIIT*I*I*T bsr_matmat v iiiiiiIITIIT*I*I*T bsr_matvec v iiiiIITT*T bsr_matvecs v iiiiiIITT*T bsr_elmul_bsr v iiiiIITIIT*I*I*T bsr_eldiv_bsr v iiiiIITIIT*I*I*T bsr_plus_bsr v iiiiIITIIT*I*I*T bsr_minus_bsr v iiiiIITIIT*I*I*T bsr_maximum_bsr v iiiiIITIIT*I*I*T bsr_minimum_bsr v iiiiIITIIT*I*I*T bsr_ne_bsr v iiiiIITIIT*I*I*B bsr_lt_bsr v iiiiIITIIT*I*I*B bsr_gt_bsr v iiiiIITIIT*I*I*B bsr_le_bsr v iiiiIITIIT*I*I*B bsr_ge_bsr v iiiiIITIIT*I*I*B aZ csc_diagonal v iiiIIT*T csc_tocsr v iiIIT*I*I*T csc_matmat_maxnnz l iiIIII csc_matmat v iiIITIIT*I*I*T csc_matvec v iiIITT*T csc_matvecs v iiiIITT*T csc_elmul_csc v iiIITIIT*I*I*T csc_eldiv_csc v iiIITIIT*I*I*T csc_plus_csc v iiIITIIT*I*I*T csc_minus_csc v iiIITIIT*I*I*T csc_maximum_csc v iiIITIIT*I*I*T csc_minimum_csc v iiIITIIT*I*I*T csc_ne_csc v iiIITIIT*I*I*B csc_lt_csc v iiIITIIT*I*I*B csc_gt_csc v iiIITIIT*I*I*B csc_le_csc v iiIITIIT*I*I*B csc_ge_csc v iiIITIIT*I*I*B a csr_matmat_maxnnz l iiIIII csr_matmat v iiIITIIT*I*I*T csr_diagonal v iiiIIT*T csr_tocsc v iiIIT*I*I*T csr_tobsr v iiiiIIT*I*I*T csr_todense v iiIIT*T csr_matvec v iiIITT*T csr_matvecs v iiiIITT*T csr_elmul_csr v iiIITIIT*I*I*T csr_eldiv_csr v iiIITIIT*I*I*T csr_plus_csr v iiIITIIT*I*I*T csr_minus_csr v iiIITIIT*I*I*T csr_maximum_csr v iiIITIIT*I*I*T csr_minimum_csr v iiIITIIT*I*I*T csr_ne_csr v iiIITIIT*I*I*B csr_lt_csr v iiIITIIT*I*I*B csr_gt_csr v iiIITIIT*I*I*B csr_le_csr v iiIITIIT*I*I*B csr_ge_csr v iiIITIIT*I*I*B csr_scale_rows v iiII*TT csr_scale_columns v iiII*TT csr_sort_indices v iI*I*T csr_eliminate_zeros v ii*I*I*T csr_sum_duplicates v ii*I*I*T get_csr_submatrix v iiIITiiii*V*V*W csr_row_index v iIIIT*I*T csr_row_slice v iiiIIT*I*T csr_column_index1 v iIiiII*I*I csr_column_index2 v IIiIT*I*T csr_sample_values v iiIITiII*T csr_count_blocks i iiiiII csr_sample_offsets i iiIIiII*I expandptr v iI*I test_throw_error i csr_has_sorted_indices i iII csr_has_canonical_format i iII z coo_tocsr v iiiIIT*I*I*T coo_todense v iilIIT*Ti coo_matvec v lIITT*T dia_matvec v iiiiITT*T cs_graph_components i iII*I ZbsrZcsrZcscother)Z NPY_INT32Z npy_int32)Z NPY_INT64Z npy_int64))ZNPY_BOOLZnpy_bool_wrapper)ZNPY_BYTEZnpy_byte)Z NPY_UBYTEZ npy_ubyte)Z NPY_SHORTZ npy_short)Z NPY_USHORTZ npy_ushort)ZNPY_INTZnpy_int)ZNPY_UINTZnpy_uint)ZNPY_LONGZnpy_long)Z NPY_ULONGZ npy_ulong)Z NPY_LONGLONGZ npy_longlong)Z NPY_ULONGLONGZ npy_ulonglong)Z NPY_FLOATZ npy_float)Z NPY_DOUBLEZ npy_double)ZNPY_LONGDOUBLEZnpy_longdouble)Z NPY_CFLOATZnpy_cfloat_wrapper)Z NPY_CDOUBLEZnpy_cdouble_wrapper)ZNPY_CLONGDOUBLEZnpy_clongdouble_wrapperzf static PY_LONG_LONG %(name)s_thunk(int I_typenum, int T_typenum, void **a) { %(thunk_content)s } z NPY_VISIBILITY_HIDDEN PyObject * %(name)s_method(PyObject *self, PyObject *args) { return call_thunk('%(ret_spec)s', "%(arg_spec)s", %(name)s_thunk, args); } z] static int get_thunk_case(int I_typenum, int T_typenum) { %(content)s; return -1; } c Csg}g}d}d}tD]\}}d}||t||d7}|||d|df|d7}tD]<\}}d}||t||d7}||||||f|d7}qT|d 7}q||tt|d fS) a Get a list containing cartesian product of data types, plus a getter routine. Returns ------- i_types : list [(j, I_typenum, None, I_type, None), ...] Pairing of index type numbers and the corresponding C++ types, and an unique index `j`. This is for routines that are parameterized only by I but not by T. it_types : list [(j, I_typenum, T_typenum, I_type, T_type), ...] Same as `i_types`, but for routines parameterized both by T and I. getter_code : str C++ code for a function that takes I_typenum, T_typenum and returns the unique index corresponding to the lists, or -1 if no match was found. rz if (0) {}zb else if (I_typenum == %(I_typenum)s) { if (T_typenum == -1) { return %(j)s; }) I_typenumjNzC else if (T_typenum == %(T_typenum)s) { return %(j)s; }) T_typenumrz })content)I_TYPESdictappendT_TYPESGET_THUNK_CASE_TEMPLATE) it_typesi_typesr getter_coderI_typepiecerT_typerq/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/scipy/sparse/generate_sparsetools.pyget_thunk_type_sets     rc s|d}|ddfdd}d}|D]T\}}}} } || | } d} |dkrV| d 7} n| d 7} || t|| | ||| |d 7}q(|d 7}tt||d } tt||d}| |fS)a3 Generate thunk and method code for a given routine. Parameters ---------- name : str Name of the C++ routine args : str Argument list specification (in format explained above) types : list List of types to instantiate, as returned `get_thunk_type_set` rrNcsBg}d}d}D]$}|rdnd}d}|dkr6d}qn|dkrV|d|||fn|d krv|d |||fn|d kr|d |||fn|d kr|d |fn~|dkr|rtd|d||fnV|dkr|rtd|d||fn,|dkr |d||fntd|f|d7}qd|S)zE Generate argument list for calling the C++ function Frzconst *Tiz *(%s*)a[%d]Iz (%s*)a[%d]TBz(npy_bool_wrapper*)a[%d]Vz"'V' argument must be an output argz(std::vector<%s>*)a[%d]Wz"'W' argument must be an output arglz*(%snpy_int64*)a[%d]zInvalid spec character %rrz, )r ValueErrorjoin)rrargsZnext_is_writeablertconstarg_specrr get_arglists<     z"parse_routine..get_arglistz>int j = get_thunk_case(I_typenum, T_typenum); switch (j) {z case %(j)s:vz? (void)%(name)s(%(arglist)s); return 0;z* return %(name)s(%(arglist)s);)rrrrrarglistnamezb default: throw std::runtime_error("internal error: invalid argument typenums"); })r* thunk_content)r*ret_specr&)r THUNK_TEMPLATEMETHOD_TEMPLATE)r*r"typesr,r'r+rrrrrr)rZ thunk_codeZ method_coderr%r parse_routines.  &    r0c Cstjtp dd}|jddddd|\}}g}t\}}}tD]\}}g} g} |D]} | } | r`| dr|q`z| dd \} }Wn4t y} zt d | f| WYd} ~ n d} ~ 00d | }d |vsd |vrt | ||\}}nt | ||\}}| |vrt d | f|| | || |q`tj tjtd|d}tt|sn|jrtd|ft|dN}t|||| D]}||q| D]}||qWdn1s0YqFtd|fqFd}|D]} |d| f7}qd}|D]} |dt| d7}q|d7}tj tjtdd}tt|sl|jrtd|ft|d,}t|||||Wdn1s0Yntd|fdS)Nr)usagez --no-force store_falseforceT)actiondestdefault#rzMalformed line: %rr#rzDuplicate routine %rZ sparsetoolsz_impl.hz$[generate_sparsetools] generating %rwz,[generate_sparsetools] %r already up-to-datezCNPY_VISIBILITY_HIDDEN PyObject *%s_method(PyObject *, PyObject *); z4 static struct PyMethodDef sparsetools_methods[] = {zH {"%(name)s", (PyCFunction)%(name)s_method, METH_VARARGS, NULL},)r*z% {NULL, NULL, 0, NULL} };zsparsetools_impl.h)optparse OptionParser__doc__strip add_option parse_argsrCOMPILATION_UNITS splitlines startswithsplitr r!r0r ospathdirname__file__rr3printopenwrite_autogen_blurbwriter )poptionsr"namesrrrZ unit_nameZroutinesZthunksmethodsliner*eZthunkmethoddstfZ method_defsZ method_structrrrmainNsz   &      0   ,rTcCs|ddS)Nzh/* This file is autogenerated by generate_sparsetools.py * Do not edit manually or check into VCS. */ )rJ)streamrrrrIsrI__main__)r;r9rCdistutils.dep_utilrZ BSR_ROUTINESZ CSC_ROUTINESZ CSR_ROUTINESZOTHER_ROUTINESr?r r r-r.r rr0rTrI__name__rrrrs2 (   0ZS