B
    Z!                 @   s   d dl mZ d dlZdd Zyd dlmZ W n6 ek
rb   d dlZddl	m
Z
 G dd	 d	ZY nX d
d ZejdfddZdddZyd dlmZ W n$ ek
r   d dlmZ eZY nX dS )    )absolute_importNc             C   s,   | dkrdS | dkrdS t t| d S d S )Nr         )lenbin)x r   7lib/python3.7/site-packages/statsmodels/compat/scipy.py_bit_length_26   s
    r
   )NumpyVersionr   )string_typesc               @   sh   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zdd Zdd ZdS )r   a  Parse and compare numpy version strings.

        Numpy has the following versioning scheme (numbers given are examples; they
        can be >9) in principle):

        - Released version: '1.8.0', '1.8.1', etc.
        - Alpha: '1.8.0a1', '1.8.0a2', etc.
        - Beta: '1.8.0b1', '1.8.0b2', etc.
        - Release candidates: '1.8.0rc1', '1.8.0rc2', etc.
        - Development versions: '1.8.0.dev-f1234afa' (git commit hash appended)
        - Development versions after a1: '1.8.0a1.dev-f1234afa',
                                        '1.8.0b2.dev-f1234afa',
                                        '1.8.1rc1.dev-f1234afa', etc.
        - Development versions (no git hash available): '1.8.0.dev-Unknown'

        Comparing needs to be done against a valid version string or other
        `NumpyVersion` instance.

        Parameters
        ----------
        vstring : str
            Numpy version string (``np.__version__``).

        Notes
        -----
        All dev versions of the same (pre-)release compare equal.

        Examples
        --------
        >>> from scipy.lib._version import NumpyVersion
        >>> if NumpyVersion(np.__version__) < '1.7.0':
        ...     print('skip')
        skip

        >>> NumpyVersion('1.7')  # raises ValueError, add ".0"

        c             C   s   || _ td|}|std| | _dd | jdD \| _| _| _	t
|| krbd| _nvtd|| d  }td|| d  }td	|| d  }d
d |||gD }|r|d  | _nd| _ttd|| _d S )Nz\d[.]\d+[.]\d+z Not a valid numpy version stringc             S   s   g | ]}t |qS r   )int).0r   r   r   r	   
<listcomp>B   s    z)NumpyVersion.__init__.<locals>.<listcomp>.finalza\dzb\dzrc\dc             S   s   g | ]}|d k	r|qS )Nr   )r   mr   r   r	   r   J   s    r    z.dev-)vstringrematch
ValueErrorgroupversionsplitmajorminorbugfixr   endpre_releaseboolsearchis_devversion)selfr   Zver_mainZalphaZbetaZrcZpre_relr   r   r	   __init__;   s"    
zNumpyVersion.__init__c             C   st   | j |j krZ| j|jkrB| j|jkr*d}qX| j|jkr<d}qXd}qp| j|jkrTd}qpd}n| j |j krld}nd}|S )zCompare major.minor.bugfixr   r   )r   r   r   )r#   othervercmpr   r   r	   _compare_versionR   s    zNumpyVersion._compare_versionc             C   sL   | j |j krd}n6| j dkr"d}n&|j dkr2d}n| j |j krDd}nd}|S )zCompare alpha/beta/rc/final.r   r   r   r%   )r   )r#   r&   r'   r   r   r	   _compare_pre_releaseg   s    

z!NumpyVersion._compare_pre_releasec             C   sr   t |ttfstdt |tr(t|}| |}|dkrn| |}|dkrn| j|jkr^d}n| jrjd}nd}|S )Nz,Invalid object to compare with NumpyVersion.r   r%   r   )
isinstancer   r   r   r(   r)   r"   )r#   r&   r'   r   r   r	   _comparev   s    


zNumpyVersion._comparec             C   s   |  |dk S )Nr   )r+   )r#   r&   r   r   r	   __lt__   s    zNumpyVersion.__lt__c             C   s   |  |dkS )Nr   )r+   )r#   r&   r   r   r	   __le__   s    zNumpyVersion.__le__c             C   s   |  |dkS )Nr   )r+   )r#   r&   r   r   r	   __eq__   s    zNumpyVersion.__eq__c             C   s   |  |dkS )Nr   )r+   )r#   r&   r   r   r	   __ne__   s    zNumpyVersion.__ne__c             C   s   |  |dkS )Nr   )r+   )r#   r&   r   r   r	   __gt__   s    zNumpyVersion.__gt__c             C   s   |  |dkS )Nr   )r+   )r#   r&   r   r   r	   __ge__   s    zNumpyVersion.__ge__c             C   s
   d| j  S )NzNumpyVersion(%s))r   )r#   r   r   r	   Z__repr   s    zNumpyVersion.__reprN)__name__
__module____qualname____doc__r$   r(   r)   r+   r,   r-   r.   r/   r0   r1   Z_NumpyVersion__reprr   r   r   r	   r      s   %r   c             C   s   | dkr| S | | d @ s| S t d}d}x|| k r|}x|| k r|  |  }yd|d   }W n$ tk
r   dt|d  }Y nX || }|| kr|S ||k r|}|d9 }|| kr8|S q8W ||k r|}|d9 }|| kr*|S q*W ||k r|}|S )a!  
    Find the next regular number greater than or equal to target.
    Regular numbers are composites of the prime factors 2, 3, and 5.
    Also known as 5-smooth numbers or Hamming numbers, these are the optimal
    size for inputs to FFTPACK.

    Target must be a positive integer.
       r   infr         )float
bit_lengthAttributeErrorr
   )targetr   Zp5Zp35ZquotientZp2Nr   r   r	   _next_regular   s<    	

r?   c             C   s>   t j| td| }|dk	r$||}t|t js:t |}|S )z"Return an array of all value.
    )dtypeN)npZonesr    Zastyper*   ZndarrayZasarray)shapevaluetypecodeoutr   r   r	   	_valarray   s    

rF   c                s   |dkr"|dkrt dq2tj}n|dk	r2t dtj| }t fdd|D }tdd |D }tt|d ||d	}t| ||  |dk	rt fd
d|D }t|  ||  |S )a  
    np.where(cond, x, fillvalue) always evaluates x even where cond is False.
    This one only evaluates f(arr1[cond], arr2[cond], ...).
    For example,
    >>> a, b = np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8])
    >>> def f(a, b):
        return a*b
    >>> _lazywhere(a > 2, (a, b), f, np.nan)
    array([ nan,  nan,  21.,  32.])
    Notice it assumes that all `arrays` are of the same shape, or can be
    broadcasted together.
    Nz%One of (fillvalue, f2) must be given.z)Only one of (fillvalue, f2) can be given.c             3   s   | ]}t  |V  qd S )N)rA   extract)r   arr)condr   r	   	<genexpr>   s    z_lazywhere.<locals>.<genexpr>c             S   s   g | ]}|j jqS r   )r@   char)r   ar   r   r	   r      s    z_lazywhere.<locals>.<listcomp>r   )rC   rD   c             3   s   | ]}t   |V  qd S )N)rA   rG   )r   rH   )rI   r   r	   rJ      s    )	r   rA   nanZbroadcast_arraystupleZmintypecoderF   rB   Zplace)rI   Zarraysf	fillvaluef2ZtempZtcoderE   r   )rI   r	   
_lazywhere   s    

rR   )loggamma)gammaln)NN)Z
__future__r   ZnumpyrA   r
   Zscipy.lib._versionr   ImportErrorr   Zpythonr   r?   rM   rF   rR   Zscipy.specialrS   rT   r   r   r   r	   <module>   s"   	 0
#