
    gZt                         d Z ddlZddlZddlmZ ddlZddlZddlm	Z	m
Z
mZ ddlmZ  ej                  e      Z G d d      Z G d d	e      Z G d
 de      Z G d d      Z G d d      Zy)a  
:mod:`~matplotlib.gridspec` contains classes that help to layout multiple
`~.axes.Axes` in a grid-like pattern within a figure.

The `GridSpec` specifies the overall grid structure. Individual cells within
the grid are referenced by `SubplotSpec`\s.

Often, users need not access this module directly, and can use higher-level
methods like `~.pyplot.subplots`, `~.pyplot.subplot_mosaic` and
`~.Figure.subfigures`. See the tutorial :ref:`arranging_axes` for a guide.
    N)Integral)_api_pylab_helpers_tight_layout)Bboxc                       e Zd ZdZddZd Z ed d      Z ed d	      Zd
 Z	ddZ
ddZd Zd Zd Zd Zd Zed        Zd ZddddddZy)GridSpecBasezm
    A base class of GridSpec that specifies the geometry of the grid
    that a subplot will be placed.
    Nc                     t        |t              r|dk  rt        d|      t        |t              r|dk  rt        d|      ||c| _        | _        | j                  |       | j                  |       y)a  
        Parameters
        ----------
        nrows, ncols : int
            The number of rows and columns of the grid.
        width_ratios : array-like of length *ncols*, optional
            Defines the relative widths of the columns. Each column gets a
            relative width of ``width_ratios[i] / sum(width_ratios)``.
            If not given, all columns will have the same width.
        height_ratios : array-like of length *nrows*, optional
            Defines the relative heights of the rows. Each row gets a
            relative height of ``height_ratios[i] / sum(height_ratios)``.
            If not given, all rows will have the same height.
        r   z/Number of rows must be a positive integer, not z2Number of columns must be a positive integer, not N)
isinstancer   
ValueError_nrows_ncolsset_height_ratiosset_width_ratios)selfnrowsncolsheight_ratioswidth_ratioss        F/var/www/html/venv/lib/python3.12/site-packages/matplotlib/gridspec.py__init__zGridSpecBase.__init__    s     %*eqjA%KM M%*eqjDUINP P#(% T[}-l+    c                 J   t        t        | j                              dk7  rd| j                  nd}t        t        | j                              dk7  rd| j                  nd}dj	                  | j
                  j                  | j                  | j                  ||z         S )N   z, height_ratios= z, width_ratios=z&{clsname}({nrows}, {ncols}{optionals}))clsnamer   r   	optionals)	lenset_row_height_ratios_col_width_ratiosformat	__class____name__r   r   )r   
height_arg	width_args      r   __repr__zGridSpecBase.__repr__9   s    S!8!89:a? ))@)@(CDEG 	 C 6 678A= 't'='=&@ACE 	7>>NN++++++ 9,	 ?  	r   c                     | j                   S N)r   r   s    r   <lambda>zGridSpecBase.<lambda>E   
    $++ r   zThe number of rows in the grid.)docc                     | j                   S r)   )r   r*   s    r   r+   zGridSpecBase.<lambda>G   r,   r   z"The number of columns in the grid.c                 2    | j                   | j                  fS )zW
        Return a tuple containing the number of rows and columns in the grid.
        )r   r   r*   s    r   get_geometryzGridSpecBase.get_geometryJ   s     {{DKK''r   c                      y r)    )r   figures     r   get_subplot_paramszGridSpecBase.get_subplot_paramsP   s    r   c                 2    |\  }}| |||z   |||z   f   }|S )a[  
        Create and return a `.SubplotSpec` instance.

        Parameters
        ----------
        loc : (int, int)
            The position of the subplot in the grid as
            ``(row_index, column_index)``.
        rowspan, colspan : int, default: 1
            The number of rows and columns the subplot should span in the grid.
        r2   )r   locrowspancolspanloc1loc2subplotspecs          r   new_subplotspeczGridSpecBase.new_subplotspecT   s4     
d4W,d4<.??@r   c                     |dg| j                   z  }|| _        yt        |      | j                   k7  rt        d      || _        y)z
        Set the relative widths of the columns.

        *width_ratios* must be of length *ncols*. Each column gets a relative
        width of ``width_ratios[i] / sum(width_ratios)``.
        Nr   zTExpected the given number of width ratios to match the number of columns of the grid)r   r   r   r!   )r   r   s     r   r   zGridSpecBase.set_width_ratiosd   sT     3,L ". $++- G H H!-r   c                     | j                   S )zo
        Return the width ratios.

        This is *None* if no width ratios have been set explicitly.
        )r!   r*   s    r   get_width_ratioszGridSpecBase.get_width_ratiosr   s     %%%r   c                     |dg| j                   z  }|| _        yt        |      | j                   k7  rt        d      || _        y)z
        Set the relative heights of the rows.

        *height_ratios* must be of length *nrows*. Each row gets a relative
        height of ``height_ratios[i] / sum(height_ratios)``.
        Nr   zRExpected the given number of height ratios to match the number of rows of the grid)r   r   r   r    )r   r   s     r   r   zGridSpecBase.set_height_ratiosz   sT      C$++-M #0 4;;. D E E"/r   c                     | j                   S )zq
        Return the height ratios.

        This is *None* if no height ratios have been set explicitly.
        )r    r*   s    r   get_height_ratioszGridSpecBase.get_height_ratios   s     &&&r   c                    | j                         \  }}| j                  |      }|j                  }|j                  }|j                  }|j
                  }|j                  }	|j                  }
||z
  }||z
  }|||
|dz
  z  z   z  }|
|z  }||z  t        | j                        z  }| j                  D cg c]  }||z  	 }}dg|g|dz
  z  z   }t        j                  t        j                  ||g      j                        }|||	|dz
  z  z   z  }|	|z  }||z  t        | j                        z  }| j                  D cg c]  }||z  	 }}dg|g|dz
  z  z   }t        j                  t        j                  ||g      j                        }||z
  j                  d      j                   \  }}||z   j                  d      j                   \  }}||||fS c c}w c c}w )a  
        Return the positions of the grid cells in figure coordinates.

        Parameters
        ----------
        fig : `~matplotlib.figure.Figure`
            The figure the grid should be applied to. The subplot parameters
            (margins and spacing between subplots) are taken from *fig*.

        Returns
        -------
        bottoms, tops, lefts, rights : array
            The bottom, top, left, right positions of the grid cells in
            figure coordinates.
        r   r   )   )r0   r4   leftrightbottomtopwspacehspacesumr    npcumsumcolumn_stackflatr!   reshapeT)r   figr   r   subplot_paramsrF   rG   rH   rI   rJ   rK   	tot_width
tot_heightcell_hsep_hnormrcell_heightssep_heightscell_hscell_wsep_wcell_widths
sep_widthscell_wsfig_topsfig_bottoms	fig_lefts
fig_rightss                                r   get_grid_positionszGridSpecBase.get_grid_positions   s     ((*u005""$$&&  &&&&DL	6\
 uvuQw'778~D$;$; <<*.*A*ABQDBBceWa01))BOO[,,GHMMN efeAg&667~D$:$: ;;)-)?)?@Aq4x@@SUGuQw/0
))BOOZ,EFKKL!$w 7 7 @ B B+!% 8 8 A C C	:Hi;; C As   3G>Gc                     | j                         D ]X  }|j                         }|t        |d      r|j                         j                         }|j	                         ||fk(  sV|c S  t        |||       S )zo
        Check if the figure already has a gridspec with these dimensions,
        or create a new one
        get_topmost_subplotspecr3   )get_axesget_gridspechasattrri   r0   GridSpec)r3   r   r   axgss        r   _check_gridspec_existsz#GridSpecBase._check_gridspec_exists   sx     //# 	B"B~289 335BBDB??$6I	 uV44r   c                 *   | j                         \  }}d }t        |t              r4	 |\  }}t	        j
                   |||d       |||d      g||f      \  }}	n ||||z  d      \  }}	t        | ||	      S # t        $ r}t        d      |d}~ww xY w)z,Create and return a `.SubplotSpec` instance.c                     | }t        | t              r,| j                  |      \  }}}||kD  r||dz
  fS t        d      | dk  r| |z   } d| cxk  r|k  r| | fS  |t        d| d| d|       t        d| d|       )Nr   z=GridSpec slice would result in no space allocated for subplotr   zindex z is out of bounds for axis z with size z) is out of bounds for GridSpec with size )r   sliceindices
IndexError)keysizeaxisorig_keystartstop_s          r   
_normalizez,GridSpecBase.__getitem__.<locals>._normalize   s    H#u%!$T!2tQ%< $(?*  "9 : : 7*C?d?8O #%$vhZ 8--1F+dV&E F F %vhZ 8;;?&&B C Cr   zUnrecognized subplot specNr   r   )r0   r   tupler   rM   ravel_multi_indexSubplotSpec)
r   rw   r   r   r~   k1k2errnum1num2s
             r   __getitem__zGridSpecBase.__getitem__   s    ((*u	C( c5!GB --Bq):b%+CD JD$ $C=JD$4t,,  G !<=3FGs   A8 8	BBBFT)sharexshareysqueeze
subplot_kwc                6   | j                   }|t        d      t        |t              s|rdnd}t        |t              s|rdnd}t	        j
                  g d||       |i }|j                         }t        j                  | j                  | j                  ft              }t        | j                        D ]]  }t        | j                        D ]C  }d|d   ||d	f   |d	|f   d
}	|	|   |d<   |	|   |d<    |j                  | ||f   fi ||||f<   E _ |dv r#|j                  D ]  }
|
j                  d        |dv r#|j                  D ]  }
|
j!                  d        |r/|j"                  dk(  r|j%                         S |j'                         S |S )z
        Add all subplots specified by this `GridSpec` to its parent figure.

        See `.Figure.subplots` for detailed documentation.
        NzIGridSpec.subplots() only works for GridSpecs created with a parent figureallnone)r   rowcolr   FT)r   r   )dtype)r   r   r   )r   r   r   r   r   r   )r   r   T)skip_non_rectangular_axes)r   r   r   )r3   r   r   strr   check_in_listcopyrM   emptyr   r   objectrangeadd_subplotrP   _label_outer_xaxis_label_outer_yaxisrx   itemr   )r   r   r   r   r   r3   axarrr   r   shared_withro   s              r   subplotszGridSpecBase.subplots   s    > < = = &#&$U&F&#&$U&FE"(	9J__&
 $++t{{36B% 	2CT[[) 2'+E$K&+CFmE!S&MK'26':
8$'26':
8$"4&"4"4cN#2&0#2c3h2	2 ^#jj F%%%EF^#jj F%%%EF  $)::?5::<GG Lr   )NNr)   )r   r   )r$   
__module____qualname____doc__r   r'   propertyr   r   r0   r4   r<   r   r?   r   rB   rg   staticmethodrq   r   r   r2   r   r   r	   r	      s    
,2
 -:<E-=?E( .&0'-<^ 5 5(#-J "'ud 3r   r	   c                   T     e Zd ZdZ	 	 	 	 d fd	Zg dZd Zd	dZd Z	 	 d
dZ	 xZ
S )rn   a  
    A grid layout to place subplots within a figure.

    The location of the grid cells is determined in a similar way to
    `.SubplotParams` using *left*, *right*, *top*, *bottom*, *wspace*
    and *hspace*.

    Indexing a GridSpec instance returns a `.SubplotSpec`.
    c                     || _         || _        || _        || _        || _        |	| _        || _        t        | !  |||
|       y)a  
        Parameters
        ----------
        nrows, ncols : int
            The number of rows and columns of the grid.

        figure : `.Figure`, optional
            Only used for constrained layout to create a proper layoutgrid.

        left, right, top, bottom : float, optional
            Extent of the subplots as a fraction of figure width or height.
            Left cannot be larger than right, and bottom cannot be larger than
            top. If not given, the values will be inferred from a figure or
            rcParams at draw time. See also `GridSpec.get_subplot_params`.

        wspace : float, optional
            The amount of width reserved for space between subplots,
            expressed as a fraction of the average axis width.
            If not given, the values will be inferred from a figure or
            rcParams when necessary. See also `GridSpec.get_subplot_params`.

        hspace : float, optional
            The amount of height reserved for space between subplots,
            expressed as a fraction of the average axis height.
            If not given, the values will be inferred from a figure or
            rcParams when necessary. See also `GridSpec.get_subplot_params`.

        width_ratios : array-like of length *ncols*, optional
            Defines the relative widths of the columns. Each column gets a
            relative width of ``width_ratios[i] / sum(width_ratios)``.
            If not given, all columns will have the same width.

        height_ratios : array-like of length *nrows*, optional
            Defines the relative heights of the rows. Each row gets a
            relative height of ``height_ratios[i] / sum(height_ratios)``.
            If not given, all rows will have the same height.

        r   r   N)	rF   rH   rG   rI   rJ   rK   r3   superr   )r   r   r   r3   rF   rH   rG   rI   rJ   rK   r   r   r#   s               r   r   zGridSpec.__init__9  sS    T 	
&2'4 	 	6r   rF   rH   rG   rI   rJ   rK   c                 0   |j                         D ].  \  }}|| j                  v rt        | ||       "t        | d       t        j
                  j                  j                         D ]  }|j                  j                  j                  D ]  }|j                         |j                         j                         }|j                         | k(  sF|j                  d      }|j                  |j                         j!                  |               y)a  
        Update the subplot parameters of the grid.

        Parameters that are not explicitly given are not changed. Setting a
        parameter to *None* resets it to :rc:`figure.subplot.*`.

        Parameters
        ----------
        left, right, top, bottom : float or None, optional
            Extent of the subplots as a fraction of figure width or height.
        wspace, hspace : float, optional
            Spacing between the subplots as a fraction of the average subplot
            width / height.
        z is an unknown keywordNF)root)items_AllowedKeyssetattrAttributeErrorr   Gcffigsvaluescanvasr3   axesget_subplotspecri   rl   
get_figure_set_positionget_position)r   kwargskv
figmanagerro   ssrS   s           r   updatezGridSpec.updateq  s     LLN 	CDAqD%%%a#$s*@%ABB		C
 ),,1188: 	QJ ''..33 Q%%'3++-EEGB(D0 mmm7((););)=)J)J3)OPQ	Qr   c                 :   |:| j                   D ci c]  }|t        j                  d|z       }}t        di |}nt	        j                  |j
                        } |j                  di | j                   D ci c]  }|t        | |       c} |S c c}w c c}w )a:  
        Return the `.SubplotParams` for the GridSpec.

        In order of precedence the values are taken from

        - non-*None* attributes of the GridSpec
        - the provided *figure*
        - :rc:`figure.subplot.*`

        Note that the ``figure`` attribute of the GridSpec is always ignored.
        figure.subplot.r2   )r   mplrcParamsSubplotParamsr   subplotparsr   getattr)r   r3   r   kwr   s        r   r4   zGridSpec.get_subplot_params  s     >,,. S\\"3A"566 .B .'-"-K))F$6$67KN4;L;LMaaq!11MN. Ns   B8Bc                 Z    | j                   D cg c]  }t        | |      s| c}S c c}w )z
        Return a list of the names of the subplot parameters explicitly set
        in the GridSpec.

        This is a subset of the attributes of `.SubplotParams`.
        )r   r   )r   r   s     r   locally_modified_subplot_paramsz(GridSpec.locally_modified_subplot_params  s'      ,,Aaa0@AAAs   ((c           
          ||j                         }t        j                  ||j                  t        j                  |j                  |       |||||      }|r | j
                  di | yy)a  
        Adjust subplot parameters to give specified padding.

        Parameters
        ----------
        figure : `.Figure`
            The figure.
        renderer :  `.RendererBase` subclass, optional
            The renderer to be used.
        pad : float
            Padding between the figure edge and the edges of subplots, as a
            fraction of the font-size.
        h_pad, w_pad : float, optional
            Padding (height/width) between edges of adjacent subplots.
            Defaults to *pad*.
        rect : tuple (left, bottom, right, top), default: None
            (left, bottom, right, top) rectangle in normalized figure
            coordinates that the whole subplots area (including labels) will
            fit into. Default (None) is the whole figure.
        N)	grid_spec)padh_padw_padrectr2   )_get_rendererr   get_tight_layout_figurer   get_subplotspec_listr   )r   r3   rendererr   r   r   r   r   s           r   tight_layoutzGridSpec.tight_layout  sl    , ++-H66FKK..v{{dK#U%dD DKK!&! r   )	NNNNNNNNNr)   )NgHzG?NNN)r$   r   r   r   r   r   r   r4   r   r   __classcell__r#   s   @r   rn   rn   /  sB     -19=%)2646l JLQ8.B -1<@"r   rn   c                   6     e Zd ZdZ	 	 d fd	ZddZd Z xZS )GridSpecFromSubplotSpeczx
    GridSpec whose subplot layout parameters are inherited from the
    location specified by a given SubplotSpec.
    c                     || _         || _        t        |t              r|| _        nt        d      | j                  j                         j                  | _        t        | %  ||||       y)ak  
        Parameters
        ----------
        nrows, ncols : int
            Number of rows and number of columns of the grid.
        subplot_spec : SubplotSpec
            Spec from which the layout parameters are inherited.
        wspace, hspace : float, optional
            See `GridSpec` for more details. If not specified default values
            (from the figure or rcParams) are used.
        height_ratios : array-like of length *nrows*, optional
            See `GridSpecBase` for details.
        width_ratios : array-like of length *ncols*, optional
            See `GridSpecBase` for details.
        zVsubplot_spec must be type SubplotSpec, usually from GridSpec, or axes.get_subplotspec.r   N)
_wspace_hspacer   r   _subplot_spec	TypeErrorrl   r3   r   r   )	r   r   r   subplot_specrJ   rK   r   r   r#   s	           r   r   z GridSpecFromSubplotSpec.__init__  st    & lK0!-DNO O ((557>>&2'4 	 	6r   c                    | j                   | j                   n*||j                  j                  nt        j                  d   }| j
                  | j
                  n*||j                  j                  nt        j                  d   }| j                  j                  |      }|j                  \  }}}}t        ||||||      S )z1Return a dictionary of subplot layout parameters.zfigure.subplot.hspacezfigure.subplot.wspace)rF   rG   rH   rI   rJ   rK   )r   r   rK   r   r   r   rJ   r   r   extentsr   )	r   r3   rK   rJ   figboxrF   rH   rG   rI   s	            r   r4   z*GridSpecFromSubplotSpec.get_subplot_params  s    "&,,":$,,4:4Fv))00||$;< 	 #',,":$,,4:4Fv))00||$;< 	 ##008#)>> feS$e$*$*6; 	;r   c                 6    | j                   j                         S )zY
        Return the topmost `.SubplotSpec` instance associated with the subplot.
        )r   ri   r*   s    r   ri   z/GridSpecFromSubplotSpec.get_topmost_subplotspec  s     !!99;;r   )NNNNr)   )r$   r   r   r   r   r4   ri   r   r   s   @r   r   r     s      &*266@; <r   r   c                       e Zd ZdZddZd Zed        Zed        Z	e	j                  d        Z	d Zd	 Zed
        Zed        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)r   a]  
    The location of a subplot in a `GridSpec`.

    .. note::

        Likely, you will never instantiate a `SubplotSpec` yourself. Instead,
        you will typically obtain one from a `GridSpec` using item-access.

    Parameters
    ----------
    gridspec : `~matplotlib.gridspec.GridSpec`
        The GridSpec, which the subplot is referencing.
    num1, num2 : int
        The subplot will occupy the *num1*-th cell of the given
        *gridspec*.  If *num2* is provided, the subplot will span between
        *num1*-th cell and *num2*-th cell **inclusive**.

        The index starts from 0.
    Nc                 .    || _         || _        || _        y r)   )	_gridspecr   r   )r   gridspecr   r   s       r   r   zSubplotSpec.__init__  s    !		r   c           
          | j                          d| j                  j                   d| j                  j                   d| j                  j                   d| j                  j                   d
S )N[:z, ])rl   r7   r{   r|   r8   r*   s    r   r'   zSubplotSpec.__repr__"  sc    $$&'q<<%%&a(9(9':"<<%%&a(9(9':!= 	>r   c                    t        |      dk(  rS|\  }t        |t              r|S t        |t              st	        d|      	 t        t        t        |            \  }}}n6t        |      dk(  r|\  }}}n!t        j                  ddt        |            t        j                  | ||      }|t        |||       }t        |t              r4t        |      d	k(  r&t        d
 |D              st	        d|       |\  }}n5t        |t              r|dk  s|||z  kD  rt	        d||z   d|      |x}}||dz
  | S # t        $ r t	        d|      dw xY w)z
        Construct a `.SubplotSpec` from a parent `.Figure` and either

        - a `.SubplotSpec` -- returned as is;
        - one or three numbers -- a MATLAB-style subplot specifier.
        r   z>Single argument to subplot must be a three-digit integer, not N   subplotz1 or 3)takesgivenrj   rE   c              3   <   K   | ]  }t        |t                y wr)   )r   r   ).0ns     r   	<genexpr>z1SubplotSpec._from_subplot_args.<locals>.<genexpr>F  s     <1z!X.<s   z3Subplot specifier tuple must contain integers, not z(num must be an integer with 1 <= num <= z, not )r   r   r   r   r   mapintr   r   nargs_errorrn   rq   r   r   )	r3   argsargrowscolsnumrp   ijs	            r   _from_subplot_argszSubplotSpec._from_subplot_args'  s    t9>DC#{+
X. $$'7,- -7"%c3s8"4dC
 Y!^"OD$""9HCINN,,VT4@:$V4Bc5!c#h!m<<< I#O  DAqc8,a3d? >tDyk J'#  KA!A#ay3  7 $$'7,-2677s   E   Ec                 J    | j                   | j                  S | j                   S r)   )_num2r   r*   s    r   r   zSubplotSpec.num2W  s     JJ.tyy>DJJ>r   c                     || _         y r)   )r   )r   values     r   r   zSubplotSpec.num2[  s	    
r   c                     | j                   S r)   )r   r*   s    r   rl   zSubplotSpec.get_gridspec_  s    ~~r   c                 x    | j                         j                         \  }}||| j                  | j                  fS )a  
        Return the subplot geometry as tuple ``(n_rows, n_cols, start, stop)``.

        The indices *start* and *stop* define the range of the subplot within
        the `GridSpec`. *stop* is inclusive (i.e. for a single cell
        ``start == stop``).
        )rl   r0   r   r   )r   r   r   s      r   r0   zSubplotSpec.get_geometryb  s6     &&(557
dT499dii//r   c                     | j                         j                  }t        | j                  |z  | j                  |z  dz         S )z6The rows spanned by this subplot, as a `range` object.r   )rl   r   r   r   r   )r   r   s     r   r7   zSubplotSpec.rowspanm  s<     !!#))TYY%'e);a)?@@r   c                     | j                         j                  }t        | j                  |z  | j                  |z  g      \  }}t        ||dz         S )z9The columns spanned by this subplot, as a `range` object.r   )rl   r   sortedr   r   r   )r   r   c1c2s       r   r8   zSubplotSpec.colspans  sP     !!#)) U*DII,=>?BRa  r   c                 4    | j                   j                  dk(  S Nr   )r7   r{   r*   s    r   is_first_rowzSubplotSpec.is_first_row|      ||!!Q&&r   c                 d    | j                   j                  | j                         j                  k(  S r)   )r7   r|   rl   r   r*   s    r   is_last_rowzSubplotSpec.is_last_row  &    ||  D$5$5$7$=$===r   c                 4    | j                   j                  dk(  S r
  )r8   r{   r*   s    r   is_first_colzSubplotSpec.is_first_col  r  r   c                 d    | j                   j                  | j                         j                  k(  S r)   )r8   r|   rl   r   r*   s    r   is_last_colzSubplotSpec.is_last_col  r  r   c                    | j                         }|j                         \  }}t        j                  | j                  | j
                  g||f      \  }}|j                  |      \  }}}	}
||   j                         }||   j                         }|	|   j                         }|
|   j                         }t        j                  ||||      S )zJ
        Update the subplot position from ``figure.subplotpars``.
        )rl   r0   rM   unravel_indexr   r   rg   minmaxr   from_extents)r   r3   r   r   r   r   r   rd   rc   re   rf   
fig_bottomfig_topfig_left	fig_rights                  r   r   zSubplotSpec.get_position  s     $$&,,.u%%tyy$))&<uenM
d''/ 	5Xy* !&**,
4.$$&T?&&(t$((*	  :y'JJr   c                 ^    | j                         }t        |d      r|j                         S | S )zX
        Return the topmost `SubplotSpec` instance associated with the subplot.
        ri   )rl   rm   ri   )r   r   s     r   ri   z#SubplotSpec.get_topmost_subplotspec  s1     $$&8673355Kr   c           	          | j                   | j                  | j                  ft        |dt	                     t        |dt	                     t        |dt	                     fk(  S )z}
        Two SubplotSpecs are considered equal if they refer to the same
        position(s) in the same `GridSpec`.
        r   r   r   )r   r   r   r   r   )r   others     r   __eq__zSubplotSpec.__eq__  sS     DII6E;9E6684E668466 	7r   c                 Z    t        | j                  | j                  | j                  f      S r)   )hashr   r   r   r*   s    r   __hash__zSubplotSpec.__hash__  s     T^^TYY		:;;r   c                     t        ||| fi |S )a  
        Create a GridSpec within this subplot.

        The created `.GridSpecFromSubplotSpec` will have this `SubplotSpec` as
        a parent.

        Parameters
        ----------
        nrows : int
            Number of rows in grid.

        ncols : int
            Number of columns in grid.

        Returns
        -------
        `.GridSpecFromSubplotSpec`

        Other Parameters
        ----------------
        **kwargs
            All other parameters are passed to `.GridSpecFromSubplotSpec`.

        See Also
        --------
        matplotlib.pyplot.subplots

        Examples
        --------
        Adding three subplots in the space occupied by a single subplot::

            fig = plt.figure()
            gs0 = fig.add_gridspec(3, 1)
            ax1 = fig.add_subplot(gs0[0])
            ax2 = fig.add_subplot(gs0[1])
            gssub = gs0[2].subgridspec(1, 3)
            for i in range(3):
                fig.add_subplot(gssub[0, i])
        )r   )r   r   r   r   s       r   subgridspeczSubplotSpec.subgridspec  s    P 'ueTDVDDr   r)   )r$   r   r   r   r   r'   r   r   r   r   setterrl   r0   r7   r8   r  r  r  r  r   ri   r   r#  r%  r2   r   r   r   r   	  s    &
>
 * *^ ? ? 
[[ 	0 A A
 ! !'>'>K 	7<(Er   r   c                   (    e Zd ZdZ	 	 ddZ	 	 ddZy)r   zM
    Parameters defining the positioning of a subplots grid in a figure.
    Nc                     dD ]#  }t        | |t        j                  d|           % | j                  ||||||       y)au  
        Defaults are given by :rc:`figure.subplot.[name]`.

        Parameters
        ----------
        left : float
            The position of the left edge of the subplots,
            as a fraction of the figure width.
        right : float
            The position of the right edge of the subplots,
            as a fraction of the figure width.
        bottom : float
            The position of the bottom edge of the subplots,
            as a fraction of the figure height.
        top : float
            The position of the top edge of the subplots,
            as a fraction of the figure height.
        wspace : float
            The width of the padding between subplots,
            as a fraction of the average Axes width.
        hspace : float
            The height of the padding between subplots,
            as a fraction of the average Axes height.
        r   r   N)r   r   r   r   )r   rF   rH   rG   rI   rJ   rK   rw   s           r   r   zSubplotParams.__init__  sH    4 J 	FCD#s||ocU,CDE	FD&%ff=r   c                 "   ||n| j                   ||n| j                  k\  rt        d      ||n| j                  ||n| j                  k\  rt        d      ||| _         ||| _        ||| _        ||| _        ||| _        ||| _        yy)zY
        Update the dimensions of the passed parameters. *None* means unchanged.
        Nzleft cannot be >= rightzbottom cannot be >= top)rF   rG   r   rH   rI   rJ   rK   )r   rF   rH   rG   rI   rJ   rK   s          r   r   zSubplotParams.update  s    
 %T499".EDJJ@677)Vt{{?C:677DIDJ DK?DH DK DK r   )NNNNNN)r$   r   r   r   r   r   r2   r   r   r   r     s$     @D%)>< >B#'!r   r   )r   r   loggingnumbersr   numpyrM   
matplotlibr   r   r   r   matplotlib.transformsr   	getLoggerr$   _logr	   rn   r   r   r   r2   r   r   <module>r1     sx   
      : : &w"R Rj["| ["|9<l 9<xOE OEd9! 9!r   