
    M/Phlo                     L   d Z ddlmZ ddlmZmZmZmZmZ ddl	m
Z
 ddlZddlmZmZmZ ddlmZ ddlmZ dd	lmZmZ dd
lmZmZ ddlmZmZmZ d Z e
dg d          Z d!                     e"eej#        $                    d                              Z%dZ&dZ'dZ(e(Z)e&e'z   e)z   Z*dZ+ edde%e*           ee+           G d d                                  Z,e&e)z   Z* edde%e*           ee+           G d de,                                  Z- G d d          Z.dS )z
Rolling OLS and WLS

Implements an efficient rolling estimator that avoids repeated matrix
multiplication.

Copyright (c) 2019 Kevin Sheppard
License: 3-clause BSD
    )lstsq)AppenderSubstitutioncache_readonlycall_cached_funcget_cached_doc)
namedtupleN)	DataFrame
MultiIndexSeries)stats)model)LikelihoodModelResultsModel)RegressionModelRegressionResults)
array_likeint_likestring_likec                 D    |                      d          r
| dd          S | S )N    )
startswith)lines    ^/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/statsmodels/regression/rolling.pystrip4r   "   s(    s ABBxK    RollingStore	paramsssrllfnobss2xpxixeexcentered_tssuncentered_tss
zvwindow : int
    Length of the rolling window. Must be strictly larger than the number
    of variables in the model.
z
weights : array_like, optional
    A 1d array of weights.  If you supply 1/W then the variables are
    pre- multiplied by 1/sqrt(W).  If no weights are supplied the
    default value is 1 and WLS results are the same as OLS.
a)  min_nobs : {int, None}
    Minimum number of observations required to estimate a model when
    data are missing.  If None, the minimum depends on the number of
    regressors in the model. Must be smaller than window.
missing : str, default "drop"
    Available options are "drop", "skip" and "raise". If "drop", any
    observations with nans are dropped and the estimates are computed using
    only the non-missing values in each window. If 'skip' blocks containing
    missing values are skipped and the corresponding results contains NaN.
    If 'raise', an error is raised. Default is 'drop'.
expanding : bool, default False
    If True, then the initial observations after min_nobs are filled using
    an expanding scheme until ``window`` observations are available, after
    which rolling is used.
aB  
Rolling %(model_type)s Least Squares

%(parameters)s
%(extra_parameters)s

See Also
--------
statsmodels.regression.linear_model.%(model)s
    %(model)s estimation and parameter testing.

Notes
-----
Tested against %(model)s for accuracy.

Results may differ from %(model)s applied to windows of data if this
model contains an implicit constant (i.e., includes dummies for all
categories) rather than an explicit constant (e.g., a column of 1s).

Examples
--------
>>> from statsmodels.regression.rolling import Rolling%(model)s
>>> from statsmodels.datasets import longley
>>> data = longley.load()
>>> exog = add_constant(data.exog, prepend=False)
>>> mod = Rolling%(model)s(data.endog, exog)
>>> rolling_res = mod.fit(reset=50)

Use params_only to skip all calculations except parameter estimation

>>> rolling_params = mod.fit(params_only=True)

Use expanding and min_nobs to fill the initial results using an
expanding scheme until window observation, and the roll.

>>> mod = Rolling%(model)s(data.endog, exog, window=60, min_nobs=12,
... expanding=True)
>>> rolling_res = mod.fit()
WeightedWLS)
model_typer   
parametersextra_parametersc                       e Zd Z	 dddddddZd Zd Zd Zd	 Zd
 Zd Z	d Z
	 	 	 	 	 	 ddZe eej        j                  	 dd                        ZdS )
RollingWLSNdropFweightsmin_nobsmissing	expandingc                P   t          |dd          }|dk    rdnd}t          j        | |||d            | j        }	| j        j        }
t          j        | ||dd           |	| _        |
| j        _        t          |d	          | _        | j        j        d
         }t          |d	d|d f          | _	        t          |dd          }t          |dd|f          }||n| j        j        d
         | _        |d u| _        |t          j        |          n|| _        t          j        | j                  }|| j        z  | _        |d d d f         | j	        z  | _        t          |dd          }||n| j	        j        d         | _        | j        | j	        j        d         k     s| j        | j        k    rt)          d          || _        t          j        | j        t.                    | _        |                                 | _        | j        j        | _        |dk    | _        d S )Nr5   )r1   raiseskipoptionsr8   r1   )r5   hasconstnoneFendogr      )ndimshapewindowToptionalr3   )rD   rA   r4      zWmin_nobs must be larger than the number of regressors in the model and less than windowdtyper9   )r   r   __init__
k_constantdata	const_idxr   _yrA   _xr   _window	_weightednpones_weightssqrt_wy_wx	_min_nobs
ValueError
_expanding
zeros_likebool_is_nan
_find_nans_has_nan_skip_missing)selfr>   exogrB   r3   r4   r5   r6   	temp_msngk_constrK   r#   w12s                r   rH   zRollingWLS.__init__   s!    Y(A
 
 
 &00FFg	tUD)dKKKK/I'	tUD&5IIII!'	UG,,w}QT74,GGG&(T:::Wi$tgNNN!'!3vvq9I ,)0ggdm$$=qqq$w<$')Hj4@@@%-%9tw}Q?O>DGM!,,,0M0M?  
 $}TWD999)),$.r   c                 .    t          j        | ||||fi |S N)r   _handle_data)r_   r>   r`   r5   r<   kwargss         r   rf   zRollingWLS._handle_data   s/    !%w
 
4:
 
 	
r   c                    t          j        | j                  }|t          j        t          j        | j                  d          z  }|t          j        | j                  z  }|| j        d d <   t          j        |          }| j        }||dz
  d          |d |dz
            z
  ||dz
  d <   | j	        rd|d | j
        <   n
d|d |dz
  <   |                    t                    S )NrE   axisF)rP   isnanrL   anyrM   rR   r[   cumsumrN   rX   rV   astyperZ   )r_   nanshas_nanws       r   r\   zRollingWLS._find_nans   s    x  rx((q1111'''QQQ)D//L"1q577+gj!a%j.AAA? 	%(-G$dn$%%$GGa!eG~~d###r   c                 `   | j         }||k    rt          ||z
  |          }nt          |          }| j        |         }| j        |         }| j        |         }| j        |         }| j        |         }| }	t          j        |          r ||	         }||	         }||	         }||	         }|||||	fS re   )	rN   slicerL   rT   rU   rR   r[   rP   rl   )
r_   idxrB   locywywxr3   r5   not_missings
             r   	_get_datazRollingWLS._get_data   s    &==fc**CC**CGCLXc]Xc]-$,s#h6'?? 	++AKBKBk*G"b';..r   c                 j   || j         k     rd S 	 |dk    s|st          j                            |          }|dk    r||z  }	n\|                     |          \  }
}}}
}
|dk    rt          ||          d         }	n$t          j                            |          }||z  }	n# t          j        j        $ r Y d S w xY w|	|j        |dz
  <   |rd S |                     |          \  }}}}}
| 	                    |	||||          \  }}}||d d d f         z  }|j
        |z  }|j        d         }|||z
  z  }|                     |||          \  }}||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   ||j        |dz
  <   d S )Ninvr   r   rE   )rV   rP   linalgr|   rz   r   pinvLinAlgErrorr    _loglikeTrA   _sum_of_squaresr!   r"   r#   r$   r%   r&   r'   r(   )r_   rt   wxpwxwxpwyr#   storeparams_onlymethodwxpwxir    _rw   rx   	wxpwxiwxprv   r3   wresidr!   r"   wxwresidwxepwxe
tot_paramsr$   r'   r(   s                            r   _fit_singlezRollingWLS._fit_single   s   $.  F	%u--%"&.."5"52r1aW$$"2r]]1-FF "	r 2 2I&^Fy$ 	 	 	FF	 &S1W 	F $s 3 32r7A==R$GGSqqq$w'*x'Xa[
D:%&'+';';Ar7'K'K$n 	#' 	#'"
37q$
37%
37&237#(6S1W%%%s   BB B76B7c                 4   |dz  }|||z  z
  }t          j        |dz  d          }t          j        |           |z  }	|	dt          j        t           j        |z            z   |z  z  }	|	dt          j        t          j        |                    z  z  }	|||	fS )Ng       @r?   r   ri   rE   g      ?)rP   sumlogpi)
r_   r    rw   rx   r3   r#   nobs2r   r!   r"   s
             r   r   zRollingWLS._loglike  s    s
b6k!fVq[q)))vc{{lU"BF255=)))U22sRVBF7OO,,,,sCr   c                     t          j        ||          }t          j        |||z
  dz  z            }t          j        ||          }||fS )N)r3   r?   )rP   averager   dot)r_   rv   rw   r3   meanr'   r(   s          r   r   zRollingWLS._sum_of_squares  sL    z!W---vgTa788B^++r   c                     |                      |          \  }}}}}|                                }|j        |z  }|j        |z  }|||fS )z.Compute xpx and xpy using a single dot product)rz   r   r   )	r_   rt   r   rw   rx   ry   r#   xpxxpys	            r   _resetzRollingWLS._reset  sO    $(NN3$7$7!2r1k  dRidRiC~r   r|   	nonrobustc                 T   t          |dd          }t          |dd          }|| j        j        d         n|}|d	k     rt	          d
          | j        j        \  }}t          t          j        ||ft          j	                  t          j        |t          j	                  t          j        |t          j	                  t          j
        |t                    t          j        |t          j	                  t          j        |||ft          j	                  t          j        |||ft          j	                  t          j        |t          j	                  t          j        |t          j	                  	  	        }	| j        }
| j        r| j        n|
}|                     |          \  }}}| j        |d	z
           r| j        s|                     |||||	||           | j        | j        }}t+          |d	z   | j        j        d         d	z             D ]}| j        |d	z
           r| j        r||z  dk    r|                     |          \  }}}n| j        ||
z
  d	z
           sI||
k    rC|||
z
  d	z
  ||
z
           }||j        |z  z  }||j        |||
z
  d	z
  ||
z
           z  z  }|d	z  }| j        |d	z
           s7||d	z
  |         }||j        |z  z  }||j        ||d	z
  |         z  z  }|d	z  }|                     |||||	||           t1          | |	| j        ||          S )a  
        Estimate model parameters.

        Parameters
        ----------
        method : {'inv', 'lstsq', 'pinv'}
            Method to use when computing the the model parameters.

            * 'inv' - use moving windows inner-products and matrix inversion.
              This method is the fastest, but may be less accurate than the
              other methods.
            * 'lstsq' - Use numpy.linalg.lstsq
            * 'pinv' - Use numpy.linalg.pinv. This method matches the default
              estimator in non-moving regression estimators.
        cov_type : {'nonrobust', 'HCCM', 'HC0'}
            Covariance estimator:

            * nonrobust - The classic OLS covariance estimator
            * HCCM, HC0 - White heteroskedasticity robust covariance
        cov_kwds : dict
            Unused
        reset : int, optional
            Interval to recompute the moving window inner products used to
            estimate the model parameters. Smaller values improve accuracy,
            although in practice this setting is not required to be set.
        use_t : bool, optional
            Flag indicating to use the Student's t distribution when computing
            p-values.
        params_only : bool, optional
            Flag indicating that only parameters should be computed. Avoids
            calculating all other statistics or performing inference.

        Returns
        -------
        RollingRegressionResults
            Estimation results where all pre-sample values are nan-filled.
        r   )r|   r   r~   r:   resetTrC   Nr   rE   z reset must be a positive integerrF   r   )r   r   rL   rA   rW   rM   r   rP   fullnanzerosintrN   rX   rV   r   r]   r^   r   rU   rT   ranger[   r   RollingRegressionResultsrI   )r_   r   cov_typecov_kwdsr   use_tr   r#   kr   rq   firstr   r   rx   rw   iremove_xadd_xs                      r   fitzRollingWLS.fit#  s7   \ H&>
 
 
 $777$)Ma  u199?@@@'-a7D!9bf--bf%%bf%%$c***wtRV$$$1rv..$1rv..rv..7400

 

 

 L"&/8qU++S$eai( 	PT-? 	PUCdE;OOO48Buqy$'-"2Q"677 	L 	LA}QU# (: 5yA~~!%QS$$|AEAI. 1q55!!a%!)a!e"34H8:00C8:1q519q1u+<(===CAID|AE* q1uqyME57U?*C57RA	]22CAIDQS${FKKKK'%%
 
 	
r   c                 .   ||j         |         }|                    dd           }|d}n|dk    rddlm}	  |	i           }n|dz  }|                    dd          }
dd	lm}m}  |d
g           } ||||d|          }|\  }}|j        dk    r|j        d         dk    s|j        dk    r't          d
                    |j                            |                    |
|d           |||d<    | ||g|R i |}||_        ||j        _        |S )Neval_envr?   r   )EvalEnvironmentrE   r5   r9   )NAAction	dmatricesr8   )on_NANA_types	dataframe)return_type	NA_actionzendog has evaluated to an array with multiple columns that has shape {}. This occurs when the variable converted to endog is non-numeric (e.g., bool or str).)r5   rB   r3   )ru   poppatsyr   getr   r   r@   rA   rW   formatupdateformularJ   frame)clsr   rJ   rB   r3   subsetargsrg   r   r   r5   r   r   	na_actionresultr>   r`   mods                     r   from_formulazRollingWLS.from_formula  s   
 8F#D::j$//HH^^------&r**HHMH**Y//--------H7R888	#
 
 
 tJNNu{1~11ej1nn( )/u{(;(;	   	'V<<=== 'F9c%//////
r   re   )r|   r   NNFF)NN)__name__
__module____qualname__rH   rf   r\   rz   r   r   r   r   r   classmethodr   r   r   __doc__ r   r   r0   r0      s        	0/ 0/ 0/ 0/ 0/ 0/d
 
 

$ $ $/ / /&&7 &7 &7P     , , ,   ]
 ]
 ]
 ]
~ Xe ())9=* * * *) [* * *r   r0   OrdinaryOLSc                   ,     e Zd Z	 ddddd fdZ xZS )
RollingOLSNr1   F)r4   r5   r6   c          	      X    t                                          |||d |||           d S )Nr2   )superrH   )r_   r>   r`   rB   r4   r5   r6   	__class__s          r   rH   zRollingOLS.__init__  sE     	 	 	
 	
 	
 	
 	
r   re   )r   r   r   rH   __classcell__)r   s   @r   r   r     sW         	
 
 
 
 
 
 
 
 
 
 
 
r   r   c                   X   e Zd ZdZ e            ZdefdZd Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Zd*dZe	d	             Ze	 e
 eej                            d
                         Ze	 e
 eej                            d                         Ze	 e
ej        j                  d                         Ze	d             Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
ej        j                  d                         Ze	 e
ej        j                  d                         Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
 eej                            d                         Ze	 e
 eej                             d                         Z e	d             Z!d Z"e	 e
 eej#                            d                         Z#e	 e
 eej$                            d                         Z$e	 e
 eej%                            d                         Z%e	 e
 ee&j'                            d                         Z'e	 e
 ee&j(                            d                         Z(d  Z) e
e&j*        j                  d+d#            Z*e+d$             Z,e- e
e&j.        j                  d%                         Z.e&j/        Z/ e
e&j0        j                  d,d'            Z0	 	 	 	 	 d-d)Z1d"S ).r   a  
    Results from rolling regressions

    Parameters
    ----------
    model : RollingWLS
        Model instance
    store : RollingStore
        Container for raw moving window results
    k_constant : bool
        Flag indicating that the model contains a constant
    use_t : bool
        Flag indicating to use the Student's t distribution when computing
        p-values.
    cov_type : str
        Name of covariance estimator
    r   c                    || _         |j        | _        |j        | _        |j        | _        |j        | _        |j	        | _
        |j        | _        |j        | _        |j        | _        |j        | _        || _        | j        j        d         | _        ||dk    }|| _        || _        | j         j        j        d u| _        g | _        i | _        d S )Nr   r   )r   r    _paramsr!   _ssrr"   _llfr#   _nobsr$   _s2r%   _xpxir&   _xepxer'   _centered_tssr(   _uncentered_tss_k_constantrA   _nvar_use_t	_cov_typerJ   
row_labels_use_pandas
_data_attr_cache)r_   r   r   rI   r   r   s         r   rH   z!RollingRegressionResults.__init__  s     
|I	I	Z
8Z
j"/$3%Z%b)
=+E!:?5TAr   c                 ^   | j         s|S | j        j        j        }| j        j        j        }|j        dk    rt          ||          S |j        dk    rt          |||          S t          j	        ||f          }t          j        |d|j        d         f          }t          |||          S )z4Wrap output as pandas Series or DataFrames as neededrE   )indexr?   columnsr   r   )r   r   rJ   param_namesr   r@   r   r
   r   from_productrP   reshaperA   )r_   val	col_names	row_namesmis        r   _wrapzRollingRegressionResults._wrap  s     	JJO/	JO.	8q==#Y////8q==S)9EEEE()Y)?@@B*S2sy}"566CS)2>>>>r   c                 \    |                      t          t          j        |                     S re   )r   r   r   aicr_   s    r   r   zRollingRegressionResults.aic  %     zz*+<+@$GGHHHr   c                     t          j        d          5  |                     t          t          j        |                     cd d d            S # 1 swxY w Y   d S )Nignore)divide)rP   errstater   r   r   bicr   s    r   r   zRollingRegressionResults.bic  s     [))) 	M 	M::./@/DdKKLL	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M   -AAAr   c                 V    |                      t          j        | ||                    S )N)	dk_params)r   r   info_criteria)r_   critr   s      r   r  z&RollingRegressionResults.info_criteria  s-    zz+D$)LLL
 
 	
r   c                 6    |                      | j                  S )zEstimated model parameters)r   r   r   s    r   r    zRollingRegressionResults.params  s     zz$,'''r   c                 6    |                      | j                  S re   )r   r   r   s    r   r!   zRollingRegressionResults.ssr!       zz$)$$$r   c                 6    |                      | j                  S re   )r   r   r   s    r   r"   zRollingRegressionResults.llf&  r  r   c                      | j         | j        z
  S re   )r   r   r   s    r   df_modelz!RollingRegressionResults.df_model+  s     zD,,,r   c                     | j         S )z5Flag indicating whether the model contains a constant)r   r   s    r   rI   z#RollingRegressionResults.k_constant0  s     r   c                     | j         S re   )r   r   s    r   r'   z%RollingRegressionResults.centered_tss5  s     !!r   c                     | j         S re   )r   r   s    r   r(   z'RollingRegressionResults.uncentered_tss:  s     ##r   c                 \    |                      t          t          j        |                     S re   )r   r   r   rsquaredr   s    r   r  z!RollingRegressionResults.rsquared?  s%     zz*+<+EtLLMMMr   c                 \    |                      t          t          j        |                     S re   )r   r   r   rsquared_adjr   s    r   r  z%RollingRegressionResults.rsquared_adjD  s+     zz.;TBB
 
 	
r   c                 6    |                      | j                  S re   )r   r   r   s    r   r#   zRollingRegressionResults.nobsK  s     zz$*%%%r   c                 V    |                      | j        | j        z
  | j        z
            S re   )r   r   r  r   r   s    r   df_residz!RollingRegressionResults.df_residP  s'     zz$*t}4t7GGHHHr   c                     | j         S re   )r   r   s    r   r   zRollingRegressionResults.use_tU  s     {r   c                 \    |                      t          t          j        |                     S re   )r   r   r   essr   s    r   r  zRollingRegressionResults.essZ  r   r   c                 \    |                      t          t          j        |                     S re   )r   r   r   	mse_modelr   s    r   r  z"RollingRegressionResults.mse_model_  %     zz*+<+FMMNNNr   c                 \    |                      t          t          j        |                     S re   )r   r   r   	mse_residr   s    r   r  z"RollingRegressionResults.mse_residd  r  r   c                 \    |                      t          t          j        |                     S re   )r   r   r   	mse_totalr   s    r   r  z"RollingRegressionResults.mse_totali  r  r   c                 z    | j         dk    r| j        d d d d f         | j        z  S | j        | j        z  | j        z  S )Nr   )r   r   r   r   r   s    r   _cov_paramsz$RollingRegressionResults._cov_paramsn  sC    >[((8AAAtTM*TZ77:+dj88r   c                 6    |                      | j                  S )a  
        Estimated parameter covariance

        Returns
        -------
        array_like
            The estimated model covariances. If the original input is a numpy
            array, the returned covariance is a 3-d array with shape
            (nobs, nvar, nvar). If the original inputs are pandas types, then
            the returned covariance is a DataFrame with a MultiIndex with
            key (observation, variable), so that the covariance for
            observation with index i is cov.loc[i].
        )r   r  r   s    r   
cov_paramsz#RollingRegressionResults.cov_paramsu  s     zz$*+++r   c                     t          j        d          5  |                     t          t          j        |                     cd d d            S # 1 swxY w Y   d S Nr   invalid)rP   r   r   r   r   f_pvaluer   s    r   r%  z!RollingRegressionResults.f_pvalue  s     [*** 	 	:: !2!;TBB 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	r   c                    | j         dk    r| j        | j        z  S | j        j        d         }t          j        |t
          j                  }| j        j        d         }t          j        |          }t          t          |                    }| j        r|                    | j        j                   |s|S ||         }| j        }||z  |j        z  }| j        }t          |          D ]n}	||	|	dz            |j        z  }
|
j        d         }t
          j                            ||	                   }t          j        |
|z  |
j        z            |z  ||	<   o|S )Nr   r   rE   )r   r  r  r   rA   rP   r   r   eyelistr   rI   r   r   rK   r  r   r}   r|   squeeze)r_   r#   statr   rlocsvcvrvcvrpr   rpdenominv_covs                r   fvaluezRollingRegressionResults.fvalue  s?    >[((>DN22<%a(D74((D"1%Aq		Aa>>D /-... $A"CGacMEA4[[ B Bq1q5y\AC')--a11*R'\BD%899EAQKr   c           
          t          j        d          5  |                     t          j        t          j        | j        dd                              cd d d            S # 1 swxY w Y   d S )Nr   r#  r   r?   )rP   r   r   rS   diagonalr  r   s    r   bsezRollingRegressionResults.bse  s     [*** 	L 	L::bgbk$2BAq&I&IJJKK	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	L 	Ls   A A##A'*A'c                     t          j        d          5  |                     t          t          j        |                     cd d d            S # 1 swxY w Y   d S r"  )rP   r   r   r   r   tvaluesr   s    r   r8  z RollingRegressionResults.tvalues  s     [*** 	 	:: !7!?FF 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	r   c                    | j         rt          | d| j                  }t          j        |          d d d f         }t          j        d          5  t          j                            t          j	        | j
                  |          dz  cd d d            S # 1 swxY w Y   d S t          j        d          5  t          j                            t          j	        | j
                            dz  cd d d            S # 1 swxY w Y   d S )Ndf_resid_inferencer   r#  r?   )r   getattrr  rP   asarrayr   r   tsfabsr8  norm)r_   r  s     r   pvaluesz RollingRegressionResults.pvalues  s    : 	?t%94=IIHz(++AAAtG4HX... F Fwzz"&"6"6AAAEF F F F F F F F F F F F F F F F F F X... ? ?z}}RVDL%9%9::Q>? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?s$   :BBB:9D  DDc                 V   t          j        | j                  }| j        r]t          j        }t          | d| j                  }t          j        |          d d d f         }|                    d|dz  z
  |          }n't          j	        }|                    d|dz  z
            }t          j        | j
                  }|||z  z
  }|||z  z   }	|,t          j        |          }|d d |f         }|	d d |f         }	t          j        t          t          ||	                              S )Nr:  rE   r?   )rP   r<  r6  r   r   r=  r;  r  ppfr@  r    r(  zip)
r_   alphacolsr6  distr  qr    loweruppers
             r   	_conf_intz"RollingRegressionResults._conf_int  s   j"": 	(7Dt%94=IIHz(++AAAtG4HUQY11AA:DUQY''ADK((S S :d##D!!!T'NE!!!T'NEz$s5%0011222r   皙?Nc                 f   |                      ||          }| j        s|S d}| j        j        j        }| j        j        j        |fd|D             t          j        |f          }t          j	        t          j
        |dd          |j        d         df          }t          |||          S )N)rI  rJ  c                      g | ]
}|         S r   r   ).0r   r   s     r   
<listcomp>z5RollingRegressionResults.conf_int.<locals>.<listcomp>  s    444!1444r   rE   r?   r   r   r   )rK  r   r   rJ   r   r   r   r   rP   r   swapaxesrA   r
   )r_   rE  rF  cici_namesr   r   r   s          @r   conf_intz!RollingRegressionResults.conf_int  s    ^^E4(( 	I%JO.	JO/	4444t444I$i%:;;ZB1--R/@AARy9999r   c                     | j         S )zName of covariance estimator)r   r   s    r   r   z!RollingRegressionResults.cov_type  s     ~r   c                 *    t          j        |          S re   )r   load)r   fnames     r   rW  zRollingRegressionResults.load  s     &*5111r   Fc                 .    t          j        | ||          S re   )r   save)r_   rX  remove_datas      r   rZ  zRollingRegressionResults.save  s    %*4DDDr   
upper leftc                    ddl m}m} ||                     |d          }| j        j        j        }	|	$t          j        | j	        j
        d                   }	| j	        j
        d         }
| j        j        j        }|t          t          |
                    }nt          |t          t           f          r|g}g }t          t#          |                    D ]}||         }||v r)|                    |                    |                     7t          |t                    r|                    |           bd                    ||         d                    |                    }t-          |           |              |||          }d}ddl}t          |	|j                  r|	                                }	t          j        |	          }	|D ]}}|                    t#          |          d|dz             }| j	        dd|f         }t          j        | j	        dd|f                    }|	|         }|                    |||                    |t          j        |dddd|f         d          }t          j        t          j        |                    sn|                    ||dddf         |         dd	
           |                    ||dddf         |         dd
           |dk    r|                     |           |!                    |d         |d                    |"                    ||                    |dz  }|#                                 |S )ai  
        Plot the recursively estimated coefficients on a given variable

        Parameters
        ----------
        variables : {int, str, Iterable[int], Iterable[str], None}, optional
            Integer index or string name of the variables whose coefficients
            to plot. Can also be an iterable of integers or strings. Default
            plots all coefficients.
        alpha : float, optional
            The confidence intervals for the coefficient are (1 - alpha)%. Set
            to None to exclude confidence intervals.
        legend_loc : str, optional
            The location of the legend in the plot. Default is upper left.
        fig : Figure, optional
            If given, subplots are created in this figure instead of in a new
            figure. Note that the grid will be created in the provided
            figure using `fig.add_subplot()`.
        figsize : tuple, optional
            If a figure is created, this argument allows specifying a size.
            The tuple is (width, height).

        Returns
        -------
        Figure
            The matplotlib Figure object.
        r   )_import_mplcreate_mpl_figNrE   zQvariable {} is not an integer and was not found in the list of variable names: {}z, )r   r?   zk:zLower CI)labelzUpper CI)ru   r   )$statsmodels.graphics.utilsr^  r_  rK  r   rJ   r   rP   aranger   rA   r   r(  r   
isinstancer   strlenappendr   r   joinrW   pandasPeriodIndexto_timestampr<  add_subplotrk   plotr   alllegendset_xlim	set_titletight_layout)r_   	variablesrE  
legend_locfigfigsizer^  r_  rR  r   k_variablesr   variable_idxr   variablemsgru   pdaxr    validrow_lblthis_cis                          r   plot_recursive_coefficientz3RollingRegressionResults.plot_recursive_coefficient  s   F 	KJJJJJJJt,,BZ_/
4<#5a#899Jl(+jo1k 2 233LL)c3Z00 (&K	L3y>>** * *$Q<{** ''(9(9((C(CDDDD#.. 
* ''1111$$*F%aL$))K*@*@% %  %S//)nS'**j".11 	3#0022JZ
++
 	 	A\!2!2AsQw??B\!!!Q$'FXdl111a40111E 'GGGGVE]+++ *R111a['::vbhw//00 2GGAu!5t:     GGAu!5t:     axx		j	111KK
GBK000LLQ(((1HCC
r   )r   )rL  N)F)NrL  r\  NN)2r   r   r   r   tuple_data_in_cacher   rH   r   r   r   r   r   r   r   r  r    r!   r"   r   r  rI   r'   r(   r  r  r#   r  r   r  r  r  r  r  r   r%  r3  r6  r   r8  rA  rK  rT  propertyr   r   rW  r[  rZ  r  r   r   r   r   r     s        $ UWWN(   .? ? ? Xnn.23344I I 54 ^I Xnn.23344M M 54 ^M
 
 
 

 ( ( ^( Xnn.23344% % 54 ^% Xnn.23344% % 54 ^% Xo&.//- - 0/ ^-     ^  Xnn.;<<==" " >= ^" Xnn.=>>??$ $ @? ^$ Xnn.78899N N :9 ^N Xnn.;<<==
 
 >= ^

 Xnn.34455& & 65 ^& Xo&.//I I 0/ ^I X%-..  /. ^ Xnn.23344I I 54 ^I Xnn.899::O O ;: ^O Xnn.899::O O ;: ^O Xnn.899::O O ;: ^O 9 9 ^9, , ,  Xnn.78899  :9 ^ Xnn.56677  87 ^0 Xnn.23344L L 54 ^L Xnn3;<<==  >= ^ Xnn3;<<==? ? >= ^?3 3 3* X$-566: : : 76:   X X$)1222 2 32 [2 )4KX$)122E E E 32E
 b b b b b br   r   )/r   statsmodels.compat.numpyr   statsmodels.compat.pandasr   r   r   r   r   collectionsr	   numpyrP   rh  r
   r   r   scipyr   statsmodels.baser   statsmodels.base.modelr   r   #statsmodels.regression.linear_modelr   r   statsmodels.tools.validationr   r   r   r   r   rg  map_model_params_docsplitcommon_paramswindow_parametersweight_parameters_missing_param_doc
extra_baser.   _docr0   r   r   r   r   r   <module>r     s    + * * * * *              # " " " " "     0 0 0 0 0 0 0 0 0 0       " " " " " " @ @ @ @ @ @ @ @        K J J J J J J J J J   z
 
 
  		##fe&=&C&CD&I&IJJKK   $  
$'88:E &R 
%	   
$d d d d d d d  dN	 %z1  
%	   
$
 
 
 
 
 
 
  
,E E E E E E E E E Er   