403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.156
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/scipy/sparse/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/scipy/sparse/__pycache__/_generate_sparsetools.cpython-310.pyc
o

��EbA1�@s�dZddlZddlZddlmZdZdZdZdZdefd	efd
efdefgZ	dd
gZ
gd�ZdZdZ
dZdd�Zdd�Zdd�Zdd�ZedkrMe�dSdS)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<integer>*
    'W':  std::vector<data>*
    '*':  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
csr_hstack          v iiIIIT*I*I*T
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
�bsr�csr�csc�other)�	NPY_INT32�	npy_int32)�	NPY_INT64�	npy_int64))�NPY_BOOL�npy_bool_wrapper)�NPY_BYTE�npy_byte)�	NPY_UBYTE�	npy_ubyte)�	NPY_SHORT�	npy_short)�
NPY_USHORT�
npy_ushort)�NPY_INT�npy_int)�NPY_UINT�npy_uint)�NPY_LONG�npy_long)�	NPY_ULONG�	npy_ulong)�NPY_LONGLONG�npy_longlong)�
NPY_ULONGLONG�
npy_ulonglong)�	NPY_FLOAT�	npy_float)�
NPY_DOUBLE�
npy_double)�NPY_LONGDOUBLE�npy_longdouble)�
NPY_CFLOAT�npy_cfloat_wrapper)�NPY_CDOUBLE�npy_cdouble_wrapper)�NPY_CLONGDOUBLE�npy_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		Cs�g}g}d}d}tD]C\}}d}||t||d�7}|�||d|df�|d7}tD]\}}d}||t||d�7}|�|||||f�|d7}q*|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_typenum�jN�zC
            else if (T_typenum == %(T_typenum)s) { return %(j)s; })�	T_typenumr.z

        })�content)�I_TYPES�dict�append�T_TYPES�GET_THUNK_CASE_TEMPLATE)	�it_types�i_typesr.�getter_coder-�I_type�piecer0�T_type�r=�D/usr/lib/python3/dist-packages/scipy/sparse/_generate_sparsetools.py�get_thunk_type_set�s 

r?cs�|d}|dd���fdd�}d}|D]*\}}}}	}
||	|
�}d}|dkr+|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`

    rr/Ncs:g}d}d}�D]�}|rdnd}d}|dkrd}q|dkr)|�d|||f�nj|d	kr9|�d
|||f�nZ|dkrI|�d
|||f�nJ|dkrV|�d
|f�n=|dkrj|r`td��|�d||f�n)|dkr~|rttd��|�d||f�n|dkr�|�d||f�ntd|f��|d7}qd�|�S)zE
        Generate argument list for calling the C++ function
        Fr�zconst �*T�iz*(%s*)a[%d]�Iz
(%s*)a[%d]�T�Bz(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 arg�lz*(%snpy_int64*)a[%d]zInvalid spec character %rr/z, )r4�
ValueError�join)r:r<�args�next_is_writeabler.�t�const��arg_specr=r>�get_arglists<

z"parse_routine.<locals>.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);)r.r:r<r-r0�arglist�namezb
    default:
        throw std::runtime_error("internal error: invalid argument typenums");
    })rT�
thunk_content)rT�ret_specrP)r3�THUNK_TEMPLATE�METHOD_TEMPLATE)rTrK�typesrVrQrUr.r-r0r:r<rSr;�
thunk_code�method_coder=rOr>�
parse_routine�s.&

���r\cCs�tjtpd��d�}|jddddd�|��\}}g}t�\}}}tD]�\}}g}	g}
|��D]g}|��}|r<|�	d�r=q/z
|�
dd	�\}}Wnty[}
ztd
|f�|
�d}
~
wwd�|�
��}d|vskd|vrtt
|||�\}}nt
|||�\}}||vr�td
|f��|�|�|	�|�|
�|�q/tj�tj�t�d|d�}tt|�s�|jr�td|f�t|d��%}t|�|�|�|	D]}|�|�q�|
D]}|�|�q�Wd�n1s�wYq#td|f�q#d}|D]	}|d|f7}q�d}|D]}|dt|d�7}�q|d7}tj�tj�t�dd�}tt|��s(|j�rVtd|f�t|d��}t|�|�|�|�|�Wd�dS1�sOwYdStd|f�dS)Nr@)�usagez
--no-force�store_false�forceT)�action�dest�default�#r/zMalformed line: %rrMrDzDuplicate routine %r�sparsetoolsz_impl.hz$[generate_sparsetools] generating %r�wz,[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},)rTz%
        {NULL, NULL, 0, NULL}
    };zsparsetools_impl.h)�optparse�OptionParser�__doc__�strip�
add_option�
parse_argsr?�COMPILATION_UNITS�
splitlines�
startswith�splitrIrJr\r4�os�path�dirname�__file__rr_�print�open�write_autogen_blurb�writer3)�p�optionsrK�namesr8r7r9�	unit_name�routines�thunks�methods�linerT�e�thunk�method�dst�f�method_defs�
method_structr=r=r>�mainOs����

�
���
��
$�r�cCs|�d�dS)Nzh/* This file is autogenerated by generate_sparsetools.py
 * Do not edit manually or check into VCS.
 */
)rw)�streamr=r=r>rv�srv�__main__)rhrfrp�distutils.dep_utilr�BSR_ROUTINES�CSC_ROUTINES�CSR_ROUTINES�OTHER_ROUTINESrlr2r5rWrXr6r?r\r�rv�__name__r=r=r=r>�<module>s6	)
��
0ZS
�

Youez - 2016 - github.com/yon3zu
LinuXploit