Ë
    £�DjgO  ã                   óB  — d Z ddlmZmZ ddlZddlZddlm	Z	 ddlm
Z
mZmZmZmZmZ  G d„ d«      Z G d„ d	«      Z G d
„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Zy)a  
This models contains the Kernels for Kernel smoothing.

Hopefully in the future they may be reused/extended for other kernel based
method

References:
----------

Pointwise Kernel Confidence Bounds
(smoothconf)
http://fedc.wiwi.hu-berlin.de/xplore/ebooks/html/anr/anrhtmlframe62.html
é    )ÚlzipÚlfilterN)Ú	factorial)ÚexpÚmultiplyÚsquareÚdivideÚsubtractÚinfc                   óL   — e Zd ZdZdd„Zd„ Zd„ Z eeed¬«      Zd„ Z	d	„ Z
d
„ Zy)ÚNdKernela  Generic N-dimensial kernel

    Parameters
    ----------
    n : int
        The number of series for kernel estimates
    kernels : list
        kernels

    Can be constructed from either
    a) a list of n kernels which will be treated as
    indepent marginals on a gaussian copula (specified by H)
    or b) a single univariate kernel which will be applied radially to the
    mahalanobis distance defined by H.

    In the case of the Gaussian these are both equivalent, and the second constructiong
    is prefered.
    Nc                 óö   — |€
t        «       }|| _        d | _        |€(t        j                  t        j
                  |«      «      }|| _        t        j                  j                  |j                  «      | _
        y )N)ÚGaussianÚ_kernelsÚweightsÚnpÚmatrixÚidentityÚ_HÚlinalgÚcholeskyÚIÚ	_Hrootinv)ÚselfÚnÚkernelsÚHs       úmC:\Crop_Prediction\Backend\crop-ai-system\venv\Lib\site-packages\statsmodels/sandbox/nonparametric/kernels.pyÚ__init__zNdKernel.__init__-   sX   € Øˆ?Ü“jˆGàˆŒØˆŒàˆ9Ü—	‘	œ2Ÿ;™; q›>Ó*ˆAàˆŒÜŸ™×+Ñ+¨Q¯S©SÓ2ˆ�ó    c                 ó   — | j                   S )zGetter for kernel bandwidth, H©r   ©r   s    r   ÚgetHzNdKernel.getH:   ó   € à�w‰wˆr    c                 ó   — || _         y)zSetter for kernel bandwidth, HNr"   ©r   Úvalues     r   ÚsetHzNdKernel.setH>   ó	   € àˆ�r    zKernel bandwidth matrix©Údocc                 óz  — t        |«      }t        |«      dkD  r“| j                  �Zt        j                   | ||z
  | j                  z  «      j
                  | j                  z  «      t        | j                  «      z  }|S t        j                   | ||z
  | j                  z  «      «      }|S t        j                  S )Nr   )Úlenr   r   Úmeanr   ÚTÚsumÚnan)r   ÚxsÚxr   Úws        r   ÚdensityzNdKernel.densityD   s›   € ä�‹Gˆô ˆr‹7�1Š9ð �|‰|Ð'Ü—G‘G™D " Q¡$¨$¯.©.Ñ!8Ó9×;Ñ;¸d¿l¹lÑJÓKÌCÐPT×P\ÑP\ÓL]Ñ]�ð ˆHô —G‘G™D " Q¡$¨$¯.©.Ñ!8Ó:Ó;�àˆHä—6‘6ˆMr    c                 óÒ   — t        | j                  t        «      rMt        j                  |«      }||z  j                  d«      }| j                  t        j                  |«      «      S y)zAreturns the kernel weight for the independent multivariate kerneléÿÿÿÿN)Ú
isinstancer   ÚCustomKernelr   Úasarrayr1   )r   r4   Úds      r   Ú_kernweightzNdKernel._kernweightU   sL   € ä�t—}‘}¤lÔ4ô
 —
‘
˜1“ˆAà�Q‘—‘˜B“ˆAØ—=‘=¤"§*¡*¨Q£-Ó1Ð1ð 5r    c                 ó$   — | j                  |«      S ©zŠ
        This simply returns the value of the kernel function at x

        Does the same as weight if the function is normalised
        )r=   ©r   r4   s     r   Ú__call__zNdKernel.__call__a   s   € ð ×Ñ Ó"Ð"r    )NN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r$   r)   Úpropertyr   r6   r=   rA   © r    r   r   r      s6   „ ñó$3òòñ 	��tÐ!:Ô;€Aòò"
2ó#r    r   c                   óº   — e Zd ZdZdd„Zd„ Zd„ Z eeed¬«      Zd„ Z	d	„ Z
d
„ Zdd„Zd„ Zd„ Zdd„Zed„ «       Zed„ «       Zed„ «       Zd„ Zed„ «       Zd„ Zd„ Zy)r:   zà
    Generic 1D Kernel object.
    Can be constructed by selecting a standard named Kernel,
    or providing a lambda expression and domain.
    The domain allows some algorithms to run faster for finite domain kernels.
    Nc                 ó°   — || _         || _        d| _        t        |«      r|| _        nt        d«      ‚|| _        d| _        d| _        d| _	        d| _
        y)a   
        shape should be a function taking and returning numeric type.

        For sanity it should always return positive or zero but this is not
        enforced in case you want to do weird things. Bear in mind that the
        statistical tests etc. may not be valid for non-positive kernels.

        The bandwidth of the kernel is supplied as h.

        You may specify a domain as a list of 2 values [min, max], in which case
        kernel will be treated as zero outside these values. This will speed up
        calculation.

        You may also specify the normalisation constant for the supplied Kernel.
        If you do this number will be stored and used as the normalisation
        without calculation.  It is recommended you do this if you know the
        constant, to speed up calculation.  In particular if the shape function
        provided is already normalised you should provide norm = 1.0.

        Warning: I think several calculations assume that the kernel is
        normalized. No tests for non-normalized kernel.
        Nz(shape must be a callable object/function)Ú
_normconstÚdomainr   ÚcallableÚ_shapeÚ	TypeErrorÚ_hÚ_L2NormÚ_kernel_varÚ_normal_reference_constantÚ_order)r   ÚshapeÚhrK   Únorms        r   r   zCustomKernel.__init__u   sX   € ð. ˆŒØˆŒØˆŒÜ�EŒ?ØˆD�KäÐFÓGÐGØˆŒØˆŒØˆÔØ*.ˆÔ'Øˆ�r    c                 ó   — | j                   S )zGetter for kernel bandwidth, h©rO   r#   s    r   ÚgethzCustomKernel.geth™   r%   r    c                 ó   — || _         y)zSetter for kernel bandwidth, hNrX   r'   s     r   ÚsethzCustomKernel.sethœ   r*   r    zKernel Bandwidthr+   c                 ó    ‡ ‡— ˆ ˆfd„}‰ j                   €||fS t        |t        ||«      «      }t        |«      dkD  rt        |Ž \  }}||fS g g fS )zW
        Returns the filtered (xs, ys) based on the Kernel domain centred on x
        c                 óž   •— | d   ‰z
  ‰j                   z  }t        j                  |‰j                  d   k\  |‰j                  d   k  z  «      S )z2Used for filter to check if point is in the domainr   é   )rU   r   ÚallrK   )ÚxyÚur   r4   s     €€r   Ú
isInDomainz*CustomKernel.in_domain.<locals>.isInDomain¨   sG   ø€ à�A‘�q‘˜$Ÿ&™&Ñ ˆAÜ—6‘6˜1 §¡¨A¡Ñ.°1¸¿¹ÀA¹Ñ3FÑGÓHÐHr    r   )rK   r   r   r.   )r   r3   Úysr4   rb   Úfiltereds   `  `  r   Ú	in_domainzCustomKernel.in_domain¡   s[   ù€ õ	Ið
 �;‰;ÐØ˜�8ˆOä˜z¬4°°B«<Ó8ˆHÜ�8‹}˜qÒ Ü˜x˜‘��BØ˜B�x�à˜B�x�r    c                 óZ  — t        j                  |«      }t        |«      }| j                  �!| j	                  || j                  |«      \  }}n| j	                  |||«      d   }t        j                  |«      }|j
                  dk(  r	|dd…df   }t        |«      dkD  r~| j                  }| j                  �8d|z  t        j                   | ||z
  |z  «      j                  z  d¬«      z  }|S d||z  z  t        j                   | ||z
  |z  «      d¬«      z  }|S t         j                  S )zUReturns the kernel density estimate for point x based on x-values
        xs
        Nr   r^   )Úaxisç      ð?)
r   r;   r.   r   re   ÚndimrU   r1   r0   r2   )r   r3   r4   r   r   rU   r5   s          r   r6   zCustomKernel.density·   s  € ô �Z‰Z˜‹^ˆÜ�‹GˆØ�<‰<Ð#ØŸ.™.¨"¨d¯l©l¸AÓ?‰KˆB‘à—‘  R¨Ó,¨QÑ/ˆBÜ�Z‰Z˜‹^ˆà�7‰7�aŠ<Ø’A�d�F‘ˆBÜˆr‹7�1Š9Ø—‘ˆAØ�|‰|Ð'Ø˜‘EœBŸF™F¡4¨¨A©¨q©£>×#3Ñ#3°gÑ#=ÀAÔFÑF�ð ˆHð ˜!˜a™%‘L¤2§6¡6©$°°1±°a©x«.¸qÔ#AÑA�ØˆHä—6‘6ˆMr    c                 óf   — t        j                  |«      | j                  z  | j                  z  |z  S )a  approximate pointwise variance for kernel density

        not verified

        Parameters
        ----------
        density : array_lie
            pdf of the kernel density
        nobs : int
            number of observations used in the KDE estimation

        Returns
        -------
        kde_var : ndarray
            estimated variance of the density estimate

        Notes
        -----
        This uses the asymptotic normal approximation to the distribution of
        the density estimate.
        )r   r;   ÚL2NormrU   )r   r6   Únobss      r   Údensity_varzCustomKernel.density_varÏ   s*   € ô, �z‰z˜'Ó" T§[¡[Ñ0°4·6±6Ñ9¸DÑ@Ð@r    c                 ó  — ddl m} |j                  j                  |dz  «      }t	        j
                  |«      }|t	        j                  | j                  ||«      «      z  }t	        j                  ||z
  ||z   f«      }|S )a+  approximate pointwise confidence interval for kernel density

        The confidence interval is centered at the estimated density and
        ignores the bias of the density estimate.

        not verified

        Parameters
        ----------
        density : array_lie
            pdf of the kernel density
        nobs : int
            number of observations used in the KDE estimation

        Returns
        -------
        conf_int : ndarray
            estimated confidence interval of the density estimate, lower bound
            in first column and upper bound in second column

        Notes
        -----
        This uses the asymptotic normal approximation to the distribution of
        the density estimate. The lower bound can be negative for density
        values close to zero.
        r   ©Ústatsç       @)	Úscipyrp   rV   Úisfr   r;   Úsqrtrm   Úcolumn_stack)r   r6   rl   Úalpharp   ÚcritÚ
half_widthÚconf_ints           r   Údensity_confintzCustomKernel.density_confintç   sm   € õ6 	 Ø�z‰z�~‰~˜e b™jÓ)ˆÜ—*‘*˜WÓ%ˆØœBŸG™G D×$4Ñ$4°W¸dÓ$CÓDÑDˆ
Ü—?‘? G¨jÑ$8¸'ÀJÑ:NÐ#OÓPˆØˆr    c                 ól  — | j                  |||«      \  }}t        |«      dkD  r{t        j                   | ||z
  | j                  z  «      «      }t        j                  t        ||«      D ��cg c]   \  }}| | ||z
  | j                  z  «      z  ‘Œ" c}}«      }||z  S t        j                  S c c}}w )z—Returns the kernel smoothing estimate for point x based on x-values
        xs and y-values ys.
        Not expected to be called by the user.
        r   )re   r.   r   r1   rU   Úzipr2   )r   r3   rc   r4   r5   ÚxxÚyyÚvs           r   ÚsmoothzCustomKernel.smooth	  s•   € ð
 —‘  B¨Ó*‰ˆˆBäˆr‹7�1Š9Ü—‘‘t˜R ™T 4§6¡6™MÓ*Ó+ˆAä—‘¼SÀÀR»[×I±6°2°r˜™4  A¡ t§v¡v¡Ó.Ó.ÓIÓJˆAØ�q‘5ˆLä—6‘6ˆMùó Js   Á.%B0
c                 ó  — | j                  |||«      \  }}t        |«      dkD  rÄt        j                  |D �cg c]  }| j	                  |||«      ‘Œ c}«      }t        t        ||«      «      }t        j                   | ||z
  | j                  z  «      «      }t        j                  t        ||«      D ��cg c]   \  }}| | ||z
  | j                  z  «      z  ‘Œ" c}}«      }	|	|z  S t        j                  S c c}w c c}}w )zJReturns the kernel smoothing estimate of the variance at point x.
        r   )re   r.   r   Úarrayr€   r   r
   r1   rU   r|   r2   )
r   r3   rc   r4   r}   Ú
fittedvalsÚsqresidr5   Úrrr   s
             r   Ú	smoothvarzCustomKernel.smoothvar  sÓ   € ð —‘  B¨Ó*‰ˆˆBäˆr‹7�QŠ;ÜŸ™ÀRÖ"H¸r 4§;¡;¨r°2°rÕ#:Ò"HÓIˆJÜœh r¨:Ó6Ó8ˆGÜ—‘‘t˜R ™T 4§6¡6™MÓ*Ó+ˆAÜ—‘¼SÀÀWÓ=M×N±6°2°r˜™4  A¡ t§v¡v¡Ó.Ó.ÓNÓOˆAØ�q‘5ˆLä—6‘6ˆMùò #Iùó Os   ¸C9Â7%C>
c                 ó¤  — | j                  |||«      \  }}t        |«      dkD  �rrt        j                  |D �cg c]  }| j	                  |||«      ‘Œ c}«      }t        t        ||«      «      }t        j                   | ||z
  | j                  z  «      «      }t        j                  t        ||«      D ��	cg c]   \  }}	|	 | ||z
  | j                  z  «      z  ‘Œ" c}	}«      }
|
|z  }t        j                  |«      }| j                  }| j	                  |||«      }ddlm} |j                  j                  |dz  «      }||z  t        j                  |«      z  t        j                  || j                  z  | j                   z  «      z  }||z
  |||z   fS t        j"                  t        j"                  t        j"                  fS c c}w c c}	}w )úLReturns the kernel smoothing estimate with confidence 1sigma bounds
        r   ro   é   )re   r.   r   r‚   r€   r   r
   r1   rU   r|   rt   rk   rr   rp   rV   rs   Ú
norm_constr2   )r   r3   rc   r4   rv   r}   rƒ   r„   r5   r…   r   ÚvarÚsdÚKÚyhatrp   rw   Úerrs                     r   Ú
smoothconfzCustomKernel.smoothconf&  ss  € ð —‘  B¨Ó*‰ˆˆBäˆr‹7�Q‹;ÜŸ™ÀRÖ"H¸r 4§;¡;¨r°2°rÕ#:Ò"HÓIˆJäÜ˜˜ZÓ(óˆGô —‘‘t˜R ™T 4§6¡6™MÓ*Ó+ˆAä—‘¼SÀÀWÓ=M×N±6°2°r˜™4  A¡ t§v¡v¡Ó.Ó.ÓNÓOˆAØ�a‘%ˆCÜ—‘˜“ˆBØ—‘ˆAØ—;‘;˜r 2 qÓ)ˆDÝ#Ø—:‘:—>‘> %¨!¡)Ó,ˆDØ˜‘)œbŸg™g a›jÑ(¬2¯7©7°1°t·v±v±:ÀÇÁÑ3OÓ+PÑPˆCØ˜3‘J  d¨S¡jÐ1Ð1ä—F‘FœBŸF™F¤B§F¡FÐ+Ð+ùò# #Iùó Os   ¹GÂ8%G
c                 óX  ‡ — ‰ j                   €’ˆ fd„}‰ j                  €>t        j                  j	                  |t
         t
        «      d   ‰ _         ‰ j                   S t        j                  j	                  |‰ j                  d   ‰ j                  d   «      d   ‰ _         ‰ j                   S )zAReturns the integral of the square of the kernal from -inf to infc                 óF   •— ‰j                   ‰j                  | «      z  dz  S ©Nr‰   ©rŠ   rM   ©r4   r   s    €r   ú<lambda>z%CustomKernel.L2Norm.<locals>.<lambda>C  s   ø€  §¡°·±¸A³Ñ >ÀÑB€ r    r   r^   )rP   rK   rr   Ú	integrateÚquadr   )r   ÚL2Funcs   ` r   rk   zCustomKernel.L2Norm?  s�   ø€ ð �<‰<ÐÛBˆFØ�{‰{Ð"Ü$Ÿ™×3Ñ3°F¼S¸DÄ#ÓFÀqÑI�”ð �|‰|Ðô  %Ÿ™×3Ñ3°F¸D¿K¹KÈ¹NØ/3¯{©{¸1©~ó ?Ø?@ñ B�”à�|‰|Ðr    c                 óX  — | j                   €“| j                  €5t        j                  j	                  | j
                  t         t        «      }nEt        j                  j	                  | j
                  | j                  d   | j                  d   «      }d|d   z  | _         | j                   S )zM
        Normalising constant for kernel (integral from -inf to inf)
        r   r^   rh   )rJ   rK   rr   r—   r˜   rM   r   )r   Úquadress     r   rŠ   zCustomKernel.norm_constK  s   € ð
 �?‰?Ð"Ø�{‰{Ð"ÜŸ/™/×.Ñ.¨t¯{©{¼S¸DÄ#ÓF‘äŸ/™/×.Ñ.¨t¯{©{¸D¿K¹KÈ¹NØ/3¯{©{¸1©~ó?�à! 7¨1¡:Ñ.ˆDŒOØ�‰Ðr    c                 óX  ‡ — ‰ j                   €’ˆ fd„}‰ j                  €>t        j                  j	                  |t
         t
        «      d   ‰ _         ‰ j                   S t        j                  j	                  |‰ j                  d   ‰ j                  d   «      d   ‰ _         ‰ j                   S )z'Returns the second moment of the kernelc                 óL   •— | dz  ‰j                   z  ‰j                  | «      z  S r“   r”   r•   s    €r   r–   z)CustomKernel.kernel_var.<locals>.<lambda>]  s!   ø€ ˜Q ™T D§O¡OÑ3°d·k±kÀ!³nÑD€ r    r   r^   )rQ   rK   rr   r—   r˜   r   )r   Úfuncs   ` r   Ú
kernel_varzCustomKernel.kernel_varY  s•   ø€ ð ×ÑÐ#ÛDˆDØ�{‰{Ð"Ü#(§?¡?×#7Ñ#7¸¼s¸dÄCÓ#HÈÑ#K�Ô ð ×ÑÐô $)§?¡?×#7Ñ#7¸¸d¿k¹kÈ!¹nØ/3¯{©{¸1©~ó$?Ø?@ñ$B�Ô à×ÑÐr    c                 óV   — |dkD  rd}t        |«      ‚|dk(  ry|dk(  r| j                  S y )Nr‰   z2Only first and second moment currently implementedr^   r   )ÚNotImplementedErrorrŸ   )r   r   Úmsgs      r   ÚmomentszCustomKernel.momentse  s9   € àˆqŠ5ØFˆCÜ% cÓ*Ð*à�Š6Øà�Š6Ø—?‘?Ð"ð r    c                 óT  — | j                   }|dk(  sd}t        |«      ‚| j                  €st        j                  dz  t        |«      dz  z  | j                  z  }|d|z  t        d|z  «      z  | j                  |«      dz  z  z  }d|dd|z  dz   z  z  z  }|| _        | j                  S )a^  
        Constant used for silverman normal reference asymtotic bandwidth
        calculation.

        C  = 2((pi^(1/2)*(nu!)^3 R(k))/(2nu(2nu)!kap_nu(k)^2))^(1/(2nu+1))
        nu = kernel order
        kap_nu = nu'th moment of kernel
        R = kernel roughness (square of L^2 norm)

        Note: L2Norm property returns square of norm.
        r‰   z)Only implemented for second order kernelsç      à?é   rh   r^   )rS   r¡   rR   r   Úpir   rk   r£   )r   Únur¢   ÚCs       r   Únormal_reference_constantz&CustomKernel.normal_reference_constantq  s²   € ð �[‰[ˆà�QŠwØ=ˆCÜ% cÓ*Ð*à×*Ñ*Ð2Ü—‘˜‘œi¨›m¨QÑ.Ñ.°·±Ñ<ˆAØ�!�b‘&œ9 Q¨¡VÓ,Ñ,¨t¯|©|¸BÓ/?ÀÑ/BÑBÑCˆAØ�!�c˜1˜R™4 ™6‘lÑ#Ñ#ˆAØ./ˆDÔ+à×.Ñ.Ð.r    c                 ó>   — | j                   | j                  |«      z  S )z0This returns the normalised weight at distance xr”   r@   s     r   ÚweightzCustomKernel.weight�  s   € à�‰˜tŸ{™{¨1›~Ñ-Ð-r    c                 ó$   — | j                  |«      S r?   )rM   r@   s     r   rA   zCustomKernel.__call__‘  s   € ð �{‰{˜1‹~Ðr    )rh   NN)gš™™™™™©?)rB   rC   rD   rE   r   rY   r[   rF   rU   re   r6   rm   rz   r€   r†   r�   rk   rŠ   rŸ   r£   rª   r¬   rA   rG   r    r   r:   r:   j   s¬   „ ñó"òHòñ 	��tÐ!3Ô4€Aò ò,ò0Aó0 òDòó,ð2 ñ	ó ð	ð ñó ðð ñ	 ó ð	 ò
#ð ñ/ó ð/ò6.ór    r:   c                   ó   — e Zd Zdd„Zy)ÚUniformc                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 óF   — dt        j                  | j                  «      z  S )Nr¥   )r   ÚonesrT   ©r4   s    r   r–   z"Uniform.__init__.<locals>.<lambda>œ  s   € °C¼"¿'¹'À!Ç'Á'Ó:JÑ4J€ r    ç      ð¿rh   ©rT   rU   rK   rV   r¥   gUUUUUUÕ?r‰   ©r:   r   rP   rQ   rS   ©r   rU   s     r   r   zUniform.__init__›  s;   € Ü×Ñ˜dÑ*JÈaØ&*¨C [¸ð 	ô 	>àˆŒØ!ˆÔØˆ�r    N©rh   ©rB   rC   rD   r   rG   r    r   r¯   r¯   š  ó   „ ôr    r¯   c                   ó   — e Zd Zdd„Zy)Ú
Triangularc                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 ó   — dt        | «      z
  S )Nr^   ©Úabsr³   s    r   r–   z%Triangular.__init__.<locals>.<lambda>¥  s   € °A¼¸A»±J€ r    r´   rh   rµ   gUUUUUUå?gUUUUUUÅ?r‰   r¶   r·   s     r   r   zTriangular.__init__¤  s;   € Ü×Ñ˜dÑ*>À!Ø&*¨C [¸ð 	ô 	>àˆŒØ!ˆÔØˆ�r    Nr¸   r¹   rG   r    r   r¼   r¼   £  rº   r    r¼   c                   ó   — e Zd Zdd„Zy)ÚEpanechnikovc                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 ó   — dd| | z  z
  z  S )Ng      è?r^   rG   r³   s    r   r–   z'Epanechnikov.__init__.<locals>.<lambda>®  s   € °D¸!¸aÀ¹c¹'±N€ r    r´   rh   rµ   g333333ã?gš™™™™™É?r‰   r¶   r·   s     r   r   zEpanechnikov.__init__­  s;   € Ü×Ñ˜dÑ*BÀaØ&*¨C [¸ð 	ô 	>àˆŒØˆÔØˆ�r    Nr¸   r¹   rG   r    r   rÂ   rÂ   ¬  rº   r    rÂ   c                   ó&   — e Zd Zdd„Zd„ Zd„ Zd„ Zy)ÚBiweightc                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 ó   — dd| | z  z
  dz  z  S )Nç      î?r^   r‰   rG   r³   s    r   r–   z#Biweight.__init__.<locals>.<lambda>·  s   € °F¸AÀÀ!Á¹GÀa¹<Ñ4G€ r    r´   rh   rµ   g·mÛ¶mÛæ?g’$I’$IÂ?r‰   r¶   r·   s     r   r   zBiweight.__init__¶  s;   € Ü×Ñ˜dÑ*GÈ1Ø&*¨C [¸ð 	ô 	>àˆŒØ!ˆÔØˆ�r    c                 óÄ  — | j                  |||«      \  }}t        |«      dkD  r­t        j                  t	        t        dt	        t        t        ||«      | j                  «      «      «      «      «      }t        j                  t        |t	        t        dt	        t        t        ||«      | j                  «      «      «      «      «      «      }||z  S t        j                  S )zÏReturns the kernel smoothing estimate for point x based on x-values
        xs and y-values ys.
        Not expected to be called by the user.

        Special implementation optimized for Biweight.
        r   r^   )
re   r.   r   r1   r   r
   r	   rU   r   r2   ©r   r3   rc   r4   r5   r   s         r   r€   zBiweight.smooth½  sÁ   € ð —‘  B¨Ó*‰ˆˆBäˆr‹7�QŠ;Ü—‘”vœh q¬&´¼ÀÀQ»Ø8<¿¹ó2@ó +Aó Bó Có DˆAä—‘”x ¤F¬8°A´v¼fÜ08¸¸Q³ÀÇÁó?Ió 8Jó ,Kó %Ló Mó NˆAà�q‘5ˆLä—6‘6ˆMr    c                 ó`  — | j                  |||«      \  }}t        |«      dkD  röt        j                  |D �cg c]  }| j	                  |||«      ‘Œ c}«      }t        t        ||«      «      }t        j                  t        t        dt        t        t        ||«      | j                  «      «      «      «      «      }t        j                  t        |t        t        dt        t        t        ||«      | j                  «      «      «      «      «      «      }||z  S t        j                  S c c}w )zS
        Returns the kernel smoothing estimate of the variance at point x.
        r   rh   r^   )re   r.   r   r‚   r€   r   r
   r1   r	   rU   r   r2   )	r   r3   rc   r4   r}   rƒ   Úrsr5   r   s	            r   r†   zBiweight.smoothvarÏ  sþ   € ð —‘  B¨Ó*‰ˆˆBäˆr‹7�QŠ;ÜŸ™ÀRÖ"H¸r 4§;¡;¨r°2°rÕ#:Ò"HÓIˆJÜœ  ZÓ0Ó1ˆBÜ—‘”vœh s¬F´6¼(À2Àq»/Ø8<¿¹ó4@ó -Aó Bó Có DˆAä—‘”x ¤F¬8°A´v¼fÜ08¸¸Q³ÀÇÁó?Ió 8Jó ,Kó %Ló Mó NˆAà�q‘5ˆLä—6‘6ˆMùò #Is   ¸D+c                 ót  — | j                  |||«      \  }}t        |«      dkD  �r`t        j                  |D �cg c]  }| j	                  |||«      ‘Œ c}«      }t        t        ||«      «      }t        j                  t        t        dt        t        t        ||«      | j                  «      «      «      «      «      }t        j                  t        |t        t        dt        t        t        ||«      | j                  «      «      «      «      «      «      }||z  }	t        j                  |	«      }
| j                  }| j	                  |||«      }|
|z  t        j                  d|z  | j                  z  «      z  }||z
  |||z   fS t        j                  t        j                  t        j                  fS c c}w )rˆ   r   rh   r^   rÉ   )re   r.   r   r‚   r€   r   r
   r1   r	   rU   r   rt   rk   r2   )r   r3   rc   r4   r}   rƒ   rÍ   r5   r   r‹   rŒ   r�   rŽ   r�   s                 r   Úsmoothconf_zBiweight.smoothconf_à  so  € ð —‘  B¨Ó*‰ˆˆBäˆr‹7�Q‹;ÜŸ™ÀRÖ"H¸r 4§;¡;¨r°2°rÕ#:Ò"HÓIˆJÜœ  ZÓ0Ó1ˆBÜ—‘”vœh s¬F´6¼(À2Àq»/Ø8<¿¹ó4@ó -Aó Bó Có DˆAä—‘”x ¤F¬8°A´v¼fÜ08¸¸Q³ÀÇÁó?Ió 8Jó ,Kó %Ló Mó NˆAà�a‘%ˆCÜ—‘˜“ˆBØ—‘ˆAØ—;‘;˜r 2 qÓ)ˆDØ�q‘&œ2Ÿ7™7 6¨A¡:°·±Ñ#6Ó7Ñ7ˆCØ˜3‘J  d¨S¡jÐ1Ð1ä—F‘FœBŸF™F¤B§F¡FÐ+Ð+ùò #Is   ¹F5Nr¸   )rB   rC   rD   r   r€   r†   rÏ   rG   r    r   rÆ   rÆ   µ  s   „ óòò$ó",r    rÆ   c                   ó   — e Zd Zdd„Zy)Ú	Triweightc                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 ó   — dd| | z  z
  dz  z  S )Ng     €ñ?r^   r¦   rG   r³   s    r   r–   z$Triweight.__init__.<locals>.<lambda>÷  s   € °G¸QÀÀ1Á¹WÀq¹LÑ4H€ r    r´   rh   rµ   gCÐ�+sê?gÇqÇq¼?r‰   r¶   r·   s     r   r   zTriweight.__init__ö  s;   € Ü×Ñ˜dÑ*HÈAØ&*¨C [¸ð 	ô 	>à"ˆŒØ!ˆÔØˆ�r    Nr¸   r¹   rG   r    r   rÑ   rÑ   õ  rº   r    rÑ   c                   ó   — e Zd ZdZdd„Zd„ Zy)r   zN
    Gaussian (Normal) Kernel

    K(u) = 1 / (sqrt(2*pi)) exp(-0.5 u**2)
    c                 ó²   — t         j                  | d„ |d d¬«       ddt        j                  t        j                  «      z  z  | _        d| _        d| _        y )Nc                 ó@   — dt        j                  | dz   dz  «      z  S )NgQ6Ô3EˆÙ?r‰   rq   )r   r   r³   s    r   r–   z#Gaussian.__init__.<locals>.<lambda>  s"   € Ð6HÜŸ™  1¡˜u S™yÓ)ñ7*€ r    rh   rµ   rq   r‰   )r:   r   r   rt   r§   rP   rQ   rS   r·   s     r   r   zGaussian.__init__  sP   € Ü×Ñ˜dñ -*Ø/0¸4Èð 	ô 	Mà˜C¤§¡¬¯©£Ñ.Ñ/ˆŒØˆÔØˆ�r    c                 ó\  — t        j                  t        t        t	        t        t        ||«      | j                  «      «      d«      «      «      }t        j                  t        |t        t        t	        t        t        ||«      | j                  «      «      d«      «      «      «      }||z  S )zÏReturns the kernel smoothing estimate for point x based on x-values
        xs and y-values ys.
        Not expected to be called by the user.

        Special implementation optimized for Gaussian.
        ç      à¿)r   r1   r   r   r   r	   r
   rU   rË   s         r   r€   zGaussian.smooth  s”   € ô �F‰F”3”x¤¤v¬h°r¸1«oØ.2¯f©fó(6ó !7Ø7;ó=ó >ó ?ˆä�F‰F”8˜B¤¤H¬V´F¼8ÀBÈ»?Ø:>¿&¹&ó5Bó .CØDHó%Jó !Kó Ló Mˆà�‰sˆ
r    Nr¸   )rB   rC   rD   rE   r   r€   rG   r    r   r   r   þ  s   „ ñó
ór    r   c                   ó   — e Zd ZdZdd„Zy)ÚCosinezO
    Cosine Kernel

    K(u) = pi/4 cos(0.5 * pi * u) between -1.0 and 1.0
    c                 ó�   — t         j                  | d„ |ddgd¬«       t        j                  dz  dz  | _        d| _        d| _        y )Nc                 óZ   — dt        j                  t         j                  dz  | z  «      z  S )Ng-DTû!é?rq   ©r   Úcosr§   r³   s    r   r–   z!Cosine.__init__.<locals>.<lambda>  s$   € Ð4GÜ—‘”r—u‘u˜S‘y 1‘}Ó%ñ5&€ r    r´   rh   rµ   r‰   g      0@g€ãtwB?È?)r:   r   r   r§   rP   rQ   rS   r·   s     r   r   zCosine.__init__  sJ   € Ü×Ñ˜dñ +&Ø)*°D¸#°;Àsð 	ô 	Lä—u‘u˜a‘x ‘}ˆŒØ-ˆÔØˆ�r    Nr¸   ©rB   rC   rD   rE   r   rG   r    r   rÚ   rÚ     ó   „ ñô
r    rÚ   c                   ó   — e Zd ZdZdd„Zy)ÚCosine2zˆ
    Cosine2 Kernel

    K(u) = 1 + cos(2 * pi * u) between -0.5 and 0.5

    Note: this  is the same Cosine kernel that Stata uses
    c                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )	Nc                 óZ   — dt        j                  dt         j                  z  | z  «      z   S )Nr^   rq   rÝ   r³   s    r   r–   z"Cosine2.__init__.<locals>.<lambda>/  s    € °A¼¿¹¸sÄRÇUÁU¹{ÈQ¹Ó8OÑ4O€ r    rØ   r¥   rh   rµ   g      ø?gŠã‡H{º ?r‰   r¶   r·   s     r   r   zCosine2.__init__.  s;   € Ü×Ñ˜dÑ*OØ˜t S˜k°#ð 	ô 	7àˆŒØ.ˆÔØˆ�r    Nr¸   rß   rG   r    r   râ   râ   &  s   „ ñôr    râ   c                   ó   — e Zd ZdZdd„Zy)ÚTricubez]
    Tricube Kernel

    K(u) = 0.864197530864 * (1 - abs(x)**3)**3 between -1.0 and 1.0
    c                 óh   — t         j                  | d„ |ddgd¬«       d| _        d| _        d| _        y )Nc                 ó0   — ddt        | «      dz  z
  dz  z  S )NgÚ‹”�§ë?r^   r¦   r¿   r³   s    r   r–   z"Tricube.__init__.<locals>.<lambda><  s   € °>ÀQÌÈQËÐQRÉÁ]ÐUVÑDVÑ3V€ r    r´   rh   rµ   gÁjïo¬æ?g4µ\¸«oÂ?r‰   r¶   r·   s     r   r   zTricube.__init__;  s<   € Ü×Ñ˜dÑ)VØ !¨4°¨+¸cð 	ô 	Cà"ˆŒØ%ˆÔØˆ�r    Nr¸   rß   rG   r    r   ræ   ræ   5  rà   r    ræ   )rE   Ústatsmodels.compat.pythonr   r   Únumpyr   Úscipy.integraterr   Úscipy.specialr   r   r   r   r	   r
   r   r   r:   r¯   r¼   rÂ   rÆ   rÑ   r   rÚ   râ   ræ   rG   r    r   ú<module>rí      s¥   ðñ÷$ 4Û Û Ý #ß >× >÷M#ñ M#÷`mñ mô`	ˆlô ô�ô ô�<ô ô>,ˆ|ô >,ô@�ô ôˆ|ô ô4ˆ\ô ôˆlô ôˆlõ r    