| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/stats/__pycache__/ |
Upload File : |
�
x�f�a � � � d dl Z d dlmZmZ d dlmZ d dlmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZ d dlZddlmZ ddlmZm Z dgZ G d � d� Z d
� Z y) � N)�linalg�special)�check_random_state)�asarray�
atleast_2d�reshape�zeros�newaxis�exp�pi�sqrt�ravel�power�
atleast_1d�squeeze�sum� transpose�ones�cov� )�_mvn)�gaussian_kernel_estimate� gaussian_kernel_estimate_log� gaussian_kdec � � e Zd ZdZdd�Zd� ZeZd� Zd� Zdd�Z d� Z
dd �Z d
� Z d � Z
e Zd e_ dd
�Zd� Zed� � Zd� Zd� Zd� Zed� � Zed� � Zy)r a& Representation of a kernel-density estimate using Gaussian kernels.
Kernel density estimation is a way to estimate the probability density
function (PDF) of a random variable in a non-parametric way.
`gaussian_kde` works for both uni-variate and multi-variate data. It
includes automatic bandwidth determination. The estimation works best for
a unimodal distribution; bimodal or multi-modal distributions tend to be
oversmoothed.
Parameters
----------
dataset : array_like
Datapoints to estimate from. In case of univariate data this is a 1-D
array, otherwise a 2-D array with shape (# of dims, # of data).
bw_method : str, scalar or callable, optional
The method used to calculate the estimator bandwidth. This can be
'scott', 'silverman', a scalar constant or a callable. If a scalar,
this will be used directly as `kde.factor`. If a callable, it should
take a `gaussian_kde` instance as only parameter and return a scalar.
If None (default), 'scott' is used. See Notes for more details.
weights : array_like, optional
weights of datapoints. This must be the same shape as dataset.
If None (default), the samples are assumed to be equally weighted
Attributes
----------
dataset : ndarray
The dataset with which `gaussian_kde` was initialized.
d : int
Number of dimensions.
n : int
Number of datapoints.
neff : int
Effective number of datapoints.
.. versionadded:: 1.2.0
factor : float
The bandwidth factor, obtained from `kde.covariance_factor`. The square
of `kde.factor` multiplies the covariance matrix of the data in the kde
estimation.
covariance : ndarray
The covariance matrix of `dataset`, scaled by the calculated bandwidth
(`kde.factor`).
inv_cov : ndarray
The inverse of `covariance`.
Methods
-------
evaluate
__call__
integrate_gaussian
integrate_box_1d
integrate_box
integrate_kde
pdf
logpdf
resample
set_bandwidth
covariance_factor
Notes
-----
Bandwidth selection strongly influences the estimate obtained from the KDE
(much more so than the actual shape of the kernel). Bandwidth selection
can be done by a "rule of thumb", by cross-validation, by "plug-in
methods" or by other means; see [3]_, [4]_ for reviews. `gaussian_kde`
uses a rule of thumb, the default is Scott's Rule.
Scott's Rule [1]_, implemented as `scotts_factor`, is::
n**(-1./(d+4)),
with ``n`` the number of data points and ``d`` the number of dimensions.
In the case of unequally weighted points, `scotts_factor` becomes::
neff**(-1./(d+4)),
with ``neff`` the effective number of datapoints.
Silverman's Rule [2]_, implemented as `silverman_factor`, is::
(n * (d + 2) / 4.)**(-1. / (d + 4)).
or in the case of unequally weighted points::
(neff * (d + 2) / 4.)**(-1. / (d + 4)).
Good general descriptions of kernel density estimation can be found in [1]_
and [2]_, the mathematics for this multi-dimensional implementation can be
found in [1]_.
With a set of weighted samples, the effective number of datapoints ``neff``
is defined by::
neff = sum(weights)^2 / sum(weights^2)
as detailed in [5]_.
`gaussian_kde` does not currently support data that lies in a
lower-dimensional subspace of the space in which it is expressed. For such
data, consider performing principle component analysis / dimensionality
reduction and using `gaussian_kde` with the transformed data.
References
----------
.. [1] D.W. Scott, "Multivariate Density Estimation: Theory, Practice, and
Visualization", John Wiley & Sons, New York, Chicester, 1992.
.. [2] B.W. Silverman, "Density Estimation for Statistics and Data
Analysis", Vol. 26, Monographs on Statistics and Applied Probability,
Chapman and Hall, London, 1986.
.. [3] B.A. Turlach, "Bandwidth Selection in Kernel Density Estimation: A
Review", CORE and Institut de Statistique, Vol. 19, pp. 1-33, 1993.
.. [4] D.M. Bashtannyk and R.J. Hyndman, "Bandwidth selection for kernel
conditional density estimation", Computational Statistics & Data
Analysis, Vol. 36, pp. 279-298, 2001.
.. [5] Gray P. G., 1969, Journal of the Royal Statistical Society.
Series A (General), 132, 272
Examples
--------
Generate some random two-dimensional data:
>>> import numpy as np
>>> from scipy import stats
>>> def measure(n):
... "Measurement model, return two coupled measurements."
... m1 = np.random.normal(size=n)
... m2 = np.random.normal(scale=0.5, size=n)
... return m1+m2, m1-m2
>>> m1, m2 = measure(2000)
>>> xmin = m1.min()
>>> xmax = m1.max()
>>> ymin = m2.min()
>>> ymax = m2.max()
Perform a kernel density estimate on the data:
>>> X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
>>> positions = np.vstack([X.ravel(), Y.ravel()])
>>> values = np.vstack([m1, m2])
>>> kernel = stats.gaussian_kde(values)
>>> Z = np.reshape(kernel(positions).T, X.shape)
Plot the results:
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> ax.imshow(np.rot90(Z), cmap=plt.cm.gist_earth_r,
... extent=[xmin, xmax, ymin, ymax])
>>> ax.plot(m1, m2, 'k.', markersize=2)
>>> ax.set_xlim([xmin, xmax])
>>> ax.set_ylim([ymin, ymax])
>>> plt.show()
Nc � � t t |� � | _ | j j dkD s t d� �| j j
\ | _ | _ |��t |� j t � | _ | xj t | j � z c_ | j j dk7 r t d� �t | j � | j k7 r t d� �dt | j dz � z | _ | j | j kD r
d}t |� � | j# |�� y # t$ j& $ r }d}t% j& |� |�d }~ww xY w) Nr z.`dataset` input should have multiple elements.z*`weights` input should be one-dimensional.z%`weights` input should be of length n� a1 Number of dimensions is greater than number of samples. This results in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Note that `gaussian_kde` interprets each *column* of `dataset` to be a point; consider transposing the input to `dataset`.�� bw_methodab The data appears to lie in a lower-dimensional subspace of the space in which it is expressed. This has resulted in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Consider performing principle component analysis / dimensionality reduction and using `gaussian_kde` with the transformed data.)r r �dataset�size�
ValueError�shape�d�nr �astype�float�_weightsr �weights�ndim�len�_neff�
set_bandwidthr � LinAlgError)�selfr r r) �msg�es �2/usr/lib/python3/dist-packages/scipy/stats/_kde.py�__init__zgaussian_kde.__init__� sA � �!�'�'�"2�3�� ��|�|� � �1�$� � M�N� N� � � �+�+������ � � &�w� /� 6� 6�u� =�D�M� �M�M�S�� � � /� /�M��|�|� � �A�%� �!M�N�N��4�=�=�!�T�V�V�+� �!H�I�I��3�t�}�}�a� /�0�0�D�J� �6�6�D�F�F�?�-�C� �S�/� !�
1� � � �� � 3���!�!� 1�?�C� �$�$�S�)�q� 0�� 1�s �E �F �,F�F c �� � t t |� � }|j \ }}|| j k7 rL|dk( r*|| j k( rt || j df� }d}n d|� d| j � �}t |� �t
| j |� \ }}t | | j j | j dd�df |j | j |� }|dd�df S )a Evaluate the estimated pdf on a set of points.
Parameters
----------
points : (# of dimensions, # of points)-array
Alternatively, a (# of dimensions,) vector can be passed in and
treated as a single point.
Returns
-------
values : (# of points,)-array
The values at each point.
Raises
------
ValueError : if the dimensionality of the input points is different than
the dimensionality of the KDE.
r �points have dimension �, dataset has dimension Nr )
r r r# r$ r r" �_get_output_dtype�
covariancer r �Tr) �cho_cov)r/ �pointsr$ �mr0 � output_dtype�spec�results r2 �evaluatezgaussian_kde.evaluate� s� � �( �G�F�O�,���|�|���1� ����;��A�v�!�t�v�v�+� ��$�&�&�!��5����/��s� 30�04���x�9�� ��o�%� .�t���� G�� �d�)�$�/� �L�L�N�N�D�L�L��D�� 1� �H�H�d�l�l�L�2�� �a��d�|�� c �� � t t |� � }t |� }|j | j fk7 rt d| j z � �|j | j | j fk7 rt d| j z � �|dd�t f }| j |z }t j |� }| j |z
}t j ||� }t j t j |d � � }t dt z |j d dz � |z }t# ||z d�� dz } t# t% | � | j& z d�� |z }
|
S )aW
Multiply estimated density by a multivariate Gaussian and integrate
over the whole space.
Parameters
----------
mean : aray_like
A 1-D array, specifying the mean of the Gaussian.
cov : array_like
A 2-D array, specifying the covariance matrix of the Gaussian.
Returns
-------
result : scalar
The value of the integral.
Raises
------
ValueError
If the mean or covariance of the input Gaussian differs from
the KDE's dimensionality.
z mean does not have dimension %sz%covariance does not have dimension %sNr r � @��axis)r r r r# r$ r" r
r8 r �
cho_factorr � cho_solve�np�prod�diagonalr r r r r) ) r/ �meanr �sum_cov� sum_cov_chol�diff�tdiff�sqrt_det�
norm_const�energiesr? s r2 �integrate_gaussianz gaussian_kde.integrate_gaussian s8 � �0 �'�$�-�(����o�� �:�:�$�&�&�� "� � >���� G�H� H� �9�9�������(� (� � D�t�v�v� M�N� N� �A�w�J� ���/�/�C�'��
�(�(��1� ��|�|�d�"��� � � �t�4���7�7�2�;�;�|�A��7�8���1�r�6�7�=�=��#3�c�#9�:�X�E�
��t�e�|�!�,�s�2���S�(��^�D�L�L�0�q�9�J�F���
rA c �~ � | j dk7 r t d� �t t | j � � d }t || j
z
|z � }t || j
z
|z � }t
j | j t j |� t j |� z
z � }|S )a�
Computes the integral of a 1D pdf between two bounds.
Parameters
----------
low : scalar
Lower bound of integration.
high : scalar
Upper bound of integration.
Returns
-------
value : scalar
The result of the integral.
Raises
------
ValueError
If the KDE is over more than one dimension.
r z'integrate_box_1d() only handles 1D pdfsr ) r$ r" r r
r8 r rH r r) r �ndtr)r/ �low�high�stdev�normalized_low�normalized_high�values r2 �integrate_box_1dz gaussian_kde.integrate_box_1dI s� � �, �6�6�Q�;� � F�G� G��d�4�?�?�+�,�Q�/�� ��d�l�l� 2�e� ;�<�� ��� � �!4�� =�>�����t�|�|� � � �_�5� � � �^�4�5�6� 7�� � rA c �� � |�d|i}ni }t j ||| j | j | j fi |��\ }}|r'd| j
dz z }t
j |� |S )a� Computes the integral of a pdf over a rectangular interval.
Parameters
----------
low_bounds : array_like
A 1-D array containing the lower bounds of integration.
high_bounds : array_like
A 1-D array containing the upper bounds of integration.
maxpts : int, optional
The maximum number of points to use for integration.
Returns
-------
value : scalar
The result of the integral.
�maxptsz6An integral in _mvn.mvnun requires more points than %si� )r �mvnun_weightedr r) r8 r$ �warnings�warn)r/ �
low_bounds� high_boundsr^ �
extra_kwdsr[ �informr0 s r2 �
integrate_boxzgaussian_kde.integrate_boxl sz � �$ � �"�F�+�J��J� �+�+�J� �,0�L�L�$�,�,�,0�O�O�K�?I�K�
��v� �K��F�F�T�M�#�C� �M�M�#� �� rA c �� � |j | j k7 r t d� �|j | j k r|}| }n| }|}|j |j z }t j
|� }d}t
|j � D ]� }|j dd�|t f }|j |z
} t j || � }
t | |
z d�� dz } |t t | � |j z d�� |j | z z
}�� t j t j |d � � } t! dt" z |j$ d dz � | z }
||
z }|S )a�
Computes the integral of the product of this kernel density estimate
with another.
Parameters
----------
other : gaussian_kde instance
The other kde.
Returns
-------
value : scalar
The result of the integral.
Raises
------
ValueError
If the KDEs have different dimensionality.
z$KDEs are not the same dimensionalityg Nr rD rC r )r$ r" r% r8 r rF �ranger r
rG r r r) rH rI rJ r r r# )r/ �other�small�largerL rM r? �irK rN rO rR rP rQ s r2 �
integrate_kdezgaussian_kde.integrate_kde� sP � �* �7�7�d�f�f� � � C�D� D� �7�7�T�V�V� ��E��E��E��E��"�"�U�%5�%5�5�� �(�(��1� ����u�w�w� � Q�A��=�=��A�w� �/�D��=�=�4�'�D��$�$�\�4�8�E��4�%�<�a�0�3�6�H� �c�#�x�i�.�� � �6�Q�?��
�
�a�@P�P� P�F�
Q� �7�7�2�;�;�|�A��7�8���1�r�6�7�=�=��#3�c�#9�:�X�E�
��*� ���
rA c �F � |�t | j � }t |� }t |j t | j ft � | j |�� � }|j | j || j �� }| j dd�|f }||z S )aA Randomly sample a dataset from the estimated pdf.
Parameters
----------
size : int, optional
The number of samples to draw. If not provided, then the size is
the same as the effective number of samples in the underlying
dataset.
seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
If `seed` is None (or `np.random`), the `numpy.random.RandomState`
singleton is used.
If `seed` is an int, a new ``RandomState`` instance is used,
seeded with `seed`.
If `seed` is already a ``Generator`` or ``RandomState`` instance then
that instance is used.
Returns
-------
resample : (self.d, `size`) ndarray
The sampled dataset.
N)r! )r! �p)
�int�neffr r �multivariate_normalr r$ r' r8 �choicer% r) r )r/ r! �seed� random_state�norm�indices�meanss r2 �resamplezgaussian_kde.resample� s� � �. �<��t�y�y�>�D�)�$�/� �� �9�9� �4�6�6�)�U� #�T�_�_�4� :�
� �� �%�%�d�f�f�4�4�<�<�%�H��� � �Q��Z�(���t�|�rA c �N � t | j d| j dz z � S )zoCompute Scott's factor.
Returns
-------
s : float
Scott's factor.
� �� �r rq r$ �r/ s r2 �
scotts_factorzgaussian_kde.scotts_factor� s! � � �T�Y�Y��T�V�V�A�X��/�/rA c �t � t | j | j dz z dz d| j dz z � S )z{Compute the Silverman factor.
Returns
-------
s : float
The silverman factor.
rC g @r{ r| r} r~ s r2 �silverman_factorz gaussian_kde.silverman_factor� s3 � � �T�Y�Y����s�
�+�C�/��d�f�f�Q�h� �@�@rA a0 Computes the coefficient (`kde.factor`) that
multiplies the data covariance matrix to obtain the kernel covariance
matrix. The default is `scotts_factor`. A subclass can overwrite this
method to provide a different method, or set it through a call to
`kde.set_bandwidth`.c �L � �� ��n��dk( r� j � _ nx�dk( r� j � _ nat j �� r"t �t � sd� _ �fd�� _ n*t �� r�� _ � fd�� _ n
d}t |� �� j � y)aX Compute the estimator bandwidth with given method.
The new bandwidth calculated after a call to `set_bandwidth` is used
for subsequent evaluations of the estimated density.
Parameters
----------
bw_method : str, scalar or callable, optional
The method used to calculate the estimator bandwidth. This can be
'scott', 'silverman', a scalar constant or a callable. If a
scalar, this will be used directly as `kde.factor`. If a callable,
it should take a `gaussian_kde` instance as only parameter and
return a scalar. If None (default), nothing happens; the current
`kde.covariance_factor` method is kept.
Notes
-----
.. versionadded:: 0.11
Examples
--------
>>> import numpy as np
>>> import scipy.stats as stats
>>> x1 = np.array([-7, -5, 1, 4, 5.])
>>> kde = stats.gaussian_kde(x1)
>>> xs = np.linspace(-10, 10, num=50)
>>> y1 = kde(xs)
>>> kde.set_bandwidth(bw_method='silverman')
>>> y2 = kde(xs)
>>> kde.set_bandwidth(bw_method=kde.factor / 3.)
>>> y3 = kde(xs)
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> ax.plot(x1, np.full(x1.shape, 1 / (4. * x1.size)), 'bo',
... label='Data points (rescaled)')
>>> ax.plot(xs, y1, label='Scott (default)')
>>> ax.plot(xs, y2, label='Silverman')
>>> ax.plot(xs, y3, label='Const (1/3 * Silverman)')
>>> ax.legend()
>>> plt.show()
N�scott� silvermanz use constantc � �� � S �N� r s �r2 �<lambda>z,gaussian_kde.set_bandwidth.<locals>.<lambda>2 s �� �Y� rA c �& �� � j � � S r� )�
_bw_methodr~ s �r2 r� z,gaussian_kde.set_bandwidth.<locals>.<lambda>5 s �� �T�_�_�T�-B� rA zC`bw_method` should be 'scott', 'silverman', a scalar or a callable.) r �covariance_factorr� rH �isscalar�
isinstance�strr� �callabler" �_compute_covariance)r/ r r0 s `` r2 r- zgaussian_kde.set_bandwidth� s� �� �X � � �
�'�
!�%)�%7�%7�D� "�
�+�
%�%)�%:�%:�D� "�
�[�[��
#�J�y�#�,F� ,�D�O�%6�D� "�
�i�
� '�D�O�%B�D� "�#�C� �S�/� !� � � �"rA c
�v � | j � | _ t | d� sWt t | j
dd| j �� � | _ t j | j d�� | _
| j | j dz z | _ | j | j z j t j � | _ dt j t j" | j t j$ dt& z � z � � j) � z | _ y) zcComputes the covariance matrix for each Gaussian kernel using
covariance_factor().
�
_data_cho_covr F��rowvar�bias�aweightsT)�lowerr N)r� �factor�hasattrr r r r) �_data_covariancer �choleskyr� r8 r& rH �float64r: �log�diagr
r r �log_detr~ s r2 r� z gaussian_kde._compute_covariance= s� � � �,�,�.�� ��t�_�-�$.�s�4�<�<��49�8<� � �0F� %G�D� !� "(� � ��1F�1F�7;�"=�D� � �/�/�$�+�+�q�.�@��� �*�*�T�[�[�8�@�@����L�� ��������� � �*,�'�'�!�B�$�-�)8� !9� :�:=�#�%�@�� rA c �� � | j � | _ t t | j dd| j
�� � | _ t j | j � | j dz z S )Nr Fr� r ) r� r� r r r r) r� r �invr~ s r2 �inv_covzgaussian_kde.inv_covO s] � � �,�,�.�� � *�3�t�|�|�A�05�� � �,N� !O�� ��z�z�$�/�/�0�4�;�;��>�A�ArA c �$ � | j |� S )z�
Evaluate the estimated pdf on a provided set of points.
Notes
-----
This is an alias for `gaussian_kde.evaluate`. See the ``evaluate``
docstring for more details.
)r@ )r/ �xs r2 �pdfzgaussian_kde.pdf[ s � � �}�}�Q� � rA c �� � t |� }|j \ }}|| j k7 rL|dk( r*|| j k( rt || j df� }d}n d|� d| j � �}t |� �t | j |� \ }}t | | j j | j dd�df |j | j |� }|dd�df S )zT
Evaluate the log of the estimated pdf on a provided set of points.
r r5 r6 Nr ) r r# r$ r r" r7 r8 r r r9 r) r: ) r/ r� r; r$ r< r0 r= r> r? s r2 �logpdfzgaussian_kde.logpdfg s� � � �A� ���|�|���1� ����;��A�v�!�t�v�v�+� ��$�&�&�!��5����/��s� 30�04���x�9�� ��o�%� .�t���� G�� �d�-�d�3� �L�L�N�N�D�L�L��D�� 1� �H�H�d�l�l�L�2�� �a��d�|�rA c �X � t j |� }t j |j t j � s
d}t |� �t
| j � }|j � }|||dk z ||dk < t
t j |� � t
|� k7 r
d}t |� �|dk ||k\ z }t j |� rd|| � d|� d�}t |� �| j | }| j }t || j � |�� S )a) Return a marginal KDE distribution
Parameters
----------
dimensions : int or 1-d array_like
The dimensions of the multivariate distribution corresponding
with the marginal variables, that is, the indices of the dimensions
that are being retained. The other dimensions are marginalized out.
Returns
-------
marginal_kde : gaussian_kde
An object representing the marginal distribution.
Notes
-----
.. versionadded:: 1.10.0
zaElements of `dimensions` must be integers - the indices of the marginal variables being retained.r z,All elements of `dimensions` must be unique.z Dimensions z# are invalid for a distribution in z dimensions.)r r) )rH r �
issubdtype�dtype�integerr" r+ r �copy�unique�anyr) r r� ) r/ �
dimensions�dimsr0 r% �
original_dims� i_invalidr r) s r2 �marginalzgaussian_kde.marginal s � �* �}�}�Z�(���}�}�T�Z�Z����4�?�C� �S�/� !� �� � � �� � � � �
��T�$��(�^�+��T�A�X�� �r�y�y��� �3�t�9� ,�A�C� �S�/� !��A�X�$�!�)�,� �
�6�6�)� � � �y�!9� :� ;,�,-�3�l�<�C� �S�/� !��,�,�t�$���,�,���G�t�/E�/E�/G�$+�-� -rA c � � | j S # t $ r6 t | j � | j z | _ | j cY S w xY wr� )r( �AttributeErrorr r% r~ s r2 r) zgaussian_kde.weights� sB � � !��=�=� �� � !� ����L���� /�D�M��=�=� � !�s � �<A
� A
c � � | j S # t $ r/ dt | j dz � z | _ | j cY S w xY w)Nr r )r, r� r r) r~ s r2 rq zgaussian_kde.neff� sC � � ��:�:� �� � ��3�t�|�|�Q��/�/�D�J��:�:� � �s � �5A�A)NNr� )�__name__�
__module__� __qualname__�__doc__r3 r@ �__call__rS r\ rf rm ry r r� r� r- r� �propertyr� r� r� r� r) rq r� rA r2 r r ( s� � �Z�v$1�L& �P �H�3�j!�F �B0�d! �F0�A� &��! �� � =#�~@�$ � B� � B�
� �0/-�b �!� �!� � � � rA c �� � t j | |� }t j |� j }|dk( rd}||fS |dk( rd}||fS |dv rd}||fS t |� d|� �� �)z�
Calculates the output dtype and the "spec" (=C type name).
This was necessary in order to deal with the fused types in the Cython
routine `gaussian_kernel_estimate`. See gh-10824 for details.
r| r' � �double)� � z long doublez has unexpected item size: )rH � common_typer� �itemsizer" )r8 r; r= r� r> s r2 r7 r7 � s� � � �>�>�*�f�5�L��x�x� �%�.�.�H��1�}��� �� � �
�Q� ��� �� � �
�X� � �� �� � � � �.� ;�H�:�F�� rA ) r` �scipyr r �scipy._lib._utilr �numpyr r r r r
r r r
r r r r r r r r rH � r �_statsr r �__all__r r7 r� rA r2 �<module>r� sT ��* � "� /� � � � � � � � J� �
��V
� V
�r rA