� <��g�-��dZddgZddlZddlZddlmZ ddlmZn #e$rdZYnwxYw ddlm Z dZ n#e$rd Z dZ YnwxYwdZdd lT[d�dD��Z e �d �dD��e �ddddd��dejd��fdejd��fdejd��fdejd��fd�Zddddd d!d"d"d#d#d$� Zd*d&�Z d+d'�Zd(�Zed,d)��ZdS)-a Low-level BLAS functions (:mod:`scipy.linalg.blas`) =================================================== This module contains low-level functions from the BLAS library. .. versionadded:: 0.12.0 .. note:: The common ``overwrite_<>`` option in many routines, allows the input arrays to be overwritten to avoid extra memory allocation. However this requires the array to satisfy two conditions which are memory order and the data type to match exactly the order and the type expected by the routine. As an example, if you pass a double precision float array to any ``S....`` routine which expects single precision arguments, f2py will create an intermediate array to match the argument types and overwriting will be performed on that intermediate array. Similarly, if a C-contiguous array is passed, f2py will pass a FORTRAN-contiguous array internally. Please make sure that these details are satisfied. More information can be found in the f2py documentation. .. warning:: These functions do little to no error checking. It is possible to cause crashes by mis-using them, so prefer using the higher-level routines in `scipy.linalg`. Finding functions ----------------- .. autosummary:: :toctree: generated/ get_blas_funcs find_best_blas_type BLAS Level 1 functions ---------------------- .. autosummary:: :toctree: generated/ caxpy ccopy cdotc cdotu crotg cscal csrot csscal cswap dasum daxpy dcopy ddot dnrm2 drot drotg drotm drotmg dscal dswap dzasum dznrm2 icamax idamax isamax izamax sasum saxpy scasum scnrm2 scopy sdot snrm2 srot srotg srotm srotmg sscal sswap zaxpy zcopy zdotc zdotu zdrot zdscal zrotg zscal zswap BLAS Level 2 functions ---------------------- .. autosummary:: :toctree: generated/ sgbmv sgemv sger ssbmv sspr sspr2 ssymv ssyr ssyr2 stbmv stpsv strmv strsv dgbmv dgemv dger dsbmv dspr dspr2 dsymv dsyr dsyr2 dtbmv dtpsv dtrmv dtrsv cgbmv cgemv cgerc cgeru chbmv chemv cher cher2 chpmv chpr chpr2 ctbmv ctbsv ctpmv ctpsv ctrmv ctrsv csyr zgbmv zgemv zgerc zgeru zhbmv zhemv zher zher2 zhpmv zhpr zhpr2 ztbmv ztbsv ztpmv ztrmv ztrsv zsyr BLAS Level 3 functions ---------------------- .. autosummary:: :toctree: generated/ sgemm ssymm ssyr2k ssyrk strmm strsm dgemm dsymm dsyr2k dsyrk dtrmm dtrsm cgemm chemm cher2k cherk csymm csyr2k csyrk ctrmm ctrsm zgemm zhemm zher2k zherk zsymm zsyr2k zsyrk ztrmm ztrsm �get_blas_funcs�find_best_blas_type�N)�_fblas)�_cblas)� _fblas_64TF)�*c��i|]}|d��S)��.0�xs �a/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/scipy/linalg/blas.py� <dictcomp>r�s��'�'�'��q�!�'�'�'�z?bBhHefc��i|]}|d��S)�rrs rrr�s��,�,�,�Q�A�q�,�,�,r�iIlLqQd��r)�F�D�g�G�s�float32�d�float64�c� complex64�z� complex128)r rrr�scnrm2�dznrm2�cdotc�zdotc�cgerc�zgerc�sdot�ddot) �cnrm2�znrm2�cdot�zdot�cger�zger�sdotc�sdotu�ddotc�ddoturc�&�tj|��}t�|jd��}d}|r�t|��dkr?t�|djjd��}|djd}nQd�|D��}t|��}|�|��}|dkrd|vrd }||jdrd }t�|dtjd��f��\}}|||fS) a�Find best-matching BLAS/LAPACK type. Arrays are used to determine the optimal prefix of BLAS routines. Parameters ---------- arrays : sequence of ndarrays, optional Arrays can be given to determine optimal prefix of BLAS routines. If not given, double-precision routines will be used, otherwise the most generic type in arrays will be used. dtype : str or dtype, optional Data-type specifier. Not used if `arrays` is non-empty. Returns ------- prefix : str BLAS/LAPACK prefix character. dtype : dtype Inferred Numpy data type. prefer_fortran : bool Whether to prefer Fortran order routines over C order. Examples -------- >>> import numpy as np >>> import scipy.linalg.blas as bla >>> rng = np.random.default_rng() >>> a = rng.random((10,15)) >>> b = np.asfortranarray(a) # Change the memory layout order >>> bla.find_best_blas_type((a,)) ('d', dtype('float64'), False) >>> bla.find_best_blas_type((a*1j,)) ('z', dtype('complex128'), False) >>> bla.find_best_blas_type((b,)) ('d', dtype('float64'), True) �Fr r�FORTRANc�X�g|]'}t�|jjd��(S)r6)�_type_score�get�dtype�charrs r� <listcomp>z'find_best_blas_type.<locals>.<listcomp>4s*��G�G�G�1�k�o�o�a�g�l�A�6�6�G�G�GrrrrTrr) �npr;r9r:r<�len�flags�max�index� _type_conv)�arraysr;� max_score�prefer_fortran�scores� ind_max_score�prefixs rrrs ��L �H�U�O�O�E�� A�.�.�I��N� �&��v�;�;�!��#��q� ��(<�a�@�@�I�#�A�Y�_�Y�7�N�N�H�G��G�G�G�F��F��I�"�L�L��3�3�M��A�~�~�1��;�;�� m�$�*�9�5� &�!%��N�N�9�s�B�H�Y�4G�4G�.H�I�I�M�F�E��5�.�(�(rc ��g} d}tj|��}||f}||f} t|t��r|f}d}t ||��\}}}|r| |} }|D]�}||z}|�||��}t |d|d��}|d}|�t | d|d��}| d}|�t|�d|�d��||c|_|_ ||_| s$tjtj ��|_n#tjtj��|_||_ | �|��|r| dS| S)zp Return available BLAS/LAPACK functions. Used also in lapack.py. See get_blas_funcs for docstring. FTrNr z function z could not be found)r>r;� isinstance�strrr:�getattr� ValueError�module_name�typecode�intc� int_dtype�int64rI�append)�namesrDr;�lib_name�fmodule�cmodule�fmodule_name�cmodule_name�alias�ilp64�funcs�unpack�module1�module2rIrF�name� func_name�funcrOs r� _get_funcsrdFs�� E� �F��H�U�O�O�E��%�G��%�G��%��$7��$F�$F�!�F�E�>��,�"�G��T�M� ��I�I�i��3�3� ��w�q�z�9�d�3�3��a�j��<��7�1�:�y�$�7�7�D�!�!�*�K��<��E�E�y�E�E�E�G�G� G�*5�v�'��$�-�� 0��X�b�g�.�.�D�N�N��X�b�h�/�/�D�N�� T�� Q�x��rc�^��i��_tj��d��fd� ��}|S)z5 Memoized fast path for _get_funcs instances rNFc��|||f}|D]}||jj|jjfz }� ��|��}n#t $rd}d}YnwxYw|�|S�||||��}|�|�|<|S)N)r;r<r@�fortranr:� TypeError) rUrDr;r\�key�array�valuerc�memos ��r�getterz"_memoize_get_funcs.<locals>.getter�s��e�U�#�� ;� ;�E��E�K�$�e�k�&9�:�:�C�C� ��H�H�S�M�M�E�E�� C��E�E�E� �� L��U�F�E�5�1�1��?��D��I��s�>�A�A�rNF)rl� functools�wraps)rcrmrls` @r�_memoize_get_funcsrqysQ��D��D�I��_�T��.�Mrc�,�t|t��r|dkrt}ntd��|s(t |||dt tddtd�� Ststd��t |||dtd d d td�� S)aReturn available BLAS function objects from names. Arrays are used to determine the optimal prefix of BLAS routines. Parameters ---------- names : str or sequence of str Name(s) of BLAS functions without type prefix. arrays : sequence of ndarrays, optional Arrays can be given to determine optimal prefix of BLAS routines. If not given, double-precision routines will be used, otherwise the most generic type in arrays will be used. dtype : str or dtype, optional Data-type specifier. Not used if `arrays` is non-empty. ilp64 : {True, False, 'preferred'}, optional Whether to return ILP64 routine variant. Choosing 'preferred' returns ILP64 routine if available, and otherwise the 32-bit routine. Default: False Returns ------- funcs : list List containing the found function(s). Notes ----- This routine automatically chooses between Fortran/C interfaces. Fortran code is used whenever possible for arrays with column major order. In all other cases, C code is preferred. In BLAS, the naming convention is that all functions start with a type prefix, which depends on the type of the principal matrix. These can be one of {'s', 'd', 'c', 'z'} for the NumPy types {float32, float64, complex64, complex128} respectively. The code and the dtype are stored in attributes `typecode` and `dtype` of the returned functions. Examples -------- >>> import numpy as np >>> import scipy.linalg as LA >>> rng = np.random.default_rng() >>> a = rng.random((3,2)) >>> x_gemv = LA.get_blas_funcs('gemv', (a,)) >>> x_gemv.typecode 'd' >>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,)) >>> x_gemv.typecode 'z' � preferredzInvalid value for 'ilp64'�BLAS�fblas�cblasF)r\zFBLAS ILP64 routine requested, but Scipy compiled only with 32-bit BLASN�fblas_64T) rKrL� HAS_ILP64rNrdrr�_blas_alias�RuntimeErrorr)rUrDr;r\s rrr�s��r�%��:��K��E�E��8�9�9�9�� 3��%�� &�&�'�7�%�U�4�4�4� 4�� A�� @�A�A� A��%�� )�T�:�t�%�T�3�3�3� 3r)rN)Frn)�__doc__�__all__�numpyr>ro�scipy.linalgrr�ImportErrorrrx�empty_module�scipy.linalg._fblasr9�updater;rCryrrdrqrrrr�<module>r�s7��I�I�^�2� 3��#�#�#�#�#�#�#�� F�F�F��&�&�&�&�&�&��I�I��I��I�I�I�� !�!�!�!��(�'�Y�'�'�'��,�,�)�,�,�,�-�-�-��3�3�4�4�4��x�r�x� �*�*�+��x�r�x� �*�*�+��x�r�x��,�,�-��x�r�x��-�-�.�0�0� �!�8�� 1�1��@)�@)�@)�@)�L�0�0�0�0�f��D�H3�H3�H3��H3�H3�H3s��'�'�4� A�A