#test standalone refactoring assert_almost_equal(sw.se_cov(sw.cov_hc0(self)), self.HC0_se, 15) assert_almost_equal(sw.se_cov(sw.cov_hc1(self)), self.HC1_se, 15) assert_almost_equal(sw.se_cov(sw.cov_hc2(self)), self.HC2_se, 15) assert_almost_equal(sw.se_cov(sw.cov_hc3(self)), self.HC3_se, 15) print self.HC0_se print sw.se_cov(sw.cov_hac_simple(self, nlags=0, use_correction=False)) #test White as HAC with nlags=0, same as nlags=1 ? bse_hac0 = sw.se_cov(sw.cov_hac_simple(self, nlags=0, use_correction=False)) assert_almost_equal(bse_hac0, self.HC0_se, 15) print bse_hac0 #test White as HAC with nlags=0, same as nlags=1 ? bse_hac0c = sw.se_cov(sw.cov_hac_simple(self, nlags=0, use_correction=True)) assert_almost_equal(bse_hac0c, self.HC1_se, 15) bse_w = sw.se_cov(sw.cov_white_simple(self, use_correction=False)) print bse_w #test White assert_almost_equal(bse_w, self.HC0_se, 15) bse_wc = sw.se_cov(sw.cov_white_simple(self, use_correction=True)) print bse_wc #test White assert_almost_equal(bse_wc, self.HC1_se, 15) groups = np.repeat(np.arange(5), 20) idx = np.nonzero(np.diff(groups))[0].tolist() groupidx = zip([0]+idx, idx+[len(groups)]) ngroups = len(groupidx)
def get_robustcov_results(self, cov_type='HC1', use_t=None, **kwds):
"""create new results instance with robust covariance as default
Parameters
----------
cov_type : string
the type of robust sandwich estimator to use. see Notes below
use_t : bool
If true, then the t distribution is used for inference.
If false, then the normal distribution is used.
kwds : depends on cov_type
Required or optional arguments for robust covariance calculation.
see Notes below
Returns
-------
results : results instance
This method creates a new results instance with the requested
robust covariance as the default covariance of the parameters.
Inferential statistics like p-values and hypothesis tests will be
based on this covariance matrix.
Notes
-----
Warning: Some of the options and defaults in cov_kwds may be changed in a
future version.
The covariance keywords provide an option 'scaling_factor' to adjust the
scaling of the covariance matrix, that is the covariance is multiplied by
this factor if it is given and is not `None`. This allows the user to
adjust the scaling of the covariance matrix to match other statistical
packages.
For example, `scaling_factor=(nobs - 1.) / (nobs - k_params)` provides a
correction so that the robust covariance matrices match those of Stata in
some models like GLM and discrete Models.
The following covariance types and required or optional arguments are
currently available:
- 'HC0', 'HC1', 'HC2', 'HC3' and no keyword arguments:
heteroscedasticity robust covariance
- 'HAC' and keywords
- `maxlag` integer (required) : number of lags to use
- `kernel` string (optional) : kernel, default is Bartlett
- `use_correction` bool (optional) : If true, use small sample
correction
- 'cluster' and required keyword `groups`, integer group indicator
- `groups` array_like, integer (required) :
index of clusters or groups
- `use_correction` bool (optional) :
If True the sandwich covariance is calulated with a small
sample correction.
If False the the sandwich covariance is calulated without
small sample correction.
- `df_correction` bool (optional)
If True (default), then the degrees of freedom for the
inferential statistics and hypothesis tests, such as
pvalues, f_pvalue, conf_int, and t_test and f_test, are
based on the number of groups minus one instead of the
total number of observations minus the number of explanatory
variables. `df_resid` of the results instance is adjusted.
If False, then `df_resid` of the results instance is not
adjusted.
- 'hac-groupsum' Driscoll and Kraay, heteroscedasticity and
autocorrelation robust standard errors in panel data
keywords
- `time` array_like (required) : index of time periods
- `maxlag` integer (required) : number of lags to use
- `kernel` string (optional) : kernel, default is Bartlett
- `use_correction` False or string in ['hac', 'cluster'] (optional) :
If False the the sandwich covariance is calulated without
small sample correction.
If `use_correction = 'cluster'` (default), then the same
small sample correction as in the case of 'covtype='cluster''
is used.
- `df_correction` bool (optional)
adjustment to df_resid, see cov_type 'cluster' above
#TODO: we need more options here
- 'hac-panel' heteroscedasticity and autocorrelation robust standard
errors in panel data.
The data needs to be sorted in this case, the time series for
each panel unit or cluster need to be stacked. The membership to
a timeseries of an individual or group can be either specified by
group indicators or by increasing time periods.
keywords
- either `groups` or `time` : array_like (required)
`groups` : indicator for groups
`time` : index of time periods
- `maxlag` integer (required) : number of lags to use
- `kernel` string (optional) : kernel, default is Bartlett
- `use_correction` False or string in ['hac', 'cluster'] (optional) :
If False the the sandwich covariance is calulated without
small sample correction.
- `df_correction` bool (optional)
adjustment to df_resid, see cov_type 'cluster' above
#TODO: we need more options here
Reminder:
`use_correction` in "hac-groupsum" and "hac-panel" is not bool,
needs to be in [False, 'hac', 'cluster']
TODO: Currently there is no check for extra or misspelled keywords,
except in the case of cov_type `HCx`
"""
import statsmodels.stats.sandwich_covariance as sw
#normalize names
if cov_type == 'nw-panel':
cov_type = 'hac-panel'
if cov_type == 'nw-groupsum':
cov_type = 'hac-groupsum'
if 'kernel' in kwds:
kwds['weights_func'] = kwds.pop('kernel')
# pop because HCx raises if any kwds
sc_factor = kwds.pop('scaling_factor', None)
# TODO: make separate function that returns a robust cov plus info
use_self = kwds.pop('use_self', False)
if use_self:
res = self
else:
# this doesn't work for most models, use raw instance instead from fit
res = self.__class__(self.model, self.params,
normalized_cov_params=self.normalized_cov_params,
scale=self.scale)
res.cov_type = cov_type
# use_t might already be defined by the class, and already set
if use_t is None:
use_t = self.use_t
res.cov_kwds = {'use_t':use_t} # store for information
res.use_t = use_t
adjust_df = False
if cov_type in ['cluster', 'hac-panel', 'hac-groupsum']:
df_correction = kwds.get('df_correction', None)
# TODO: check also use_correction, do I need all combinations?
if df_correction is not False: # i.e. in [None, True]:
# user didn't explicitely set it to False
adjust_df = True
res.cov_kwds['adjust_df'] = adjust_df
# verify and set kwds, and calculate cov
# TODO: this should be outsourced in a function so we can reuse it in
# other models
# TODO: make it DRYer repeated code for checking kwds
if cov_type.upper() in ('HC0', 'HC1', 'HC2', 'HC3'):
if kwds:
raise ValueError('heteroscedasticity robust covarians ' +
'does not use keywords')
res.cov_kwds['description'] = ('Standard Errors are heteroscedasticity ' +
'robust ' + '(' + cov_type + ')')
res.cov_params_default = getattr(self, 'cov_' + cov_type.upper(), None)
if res.cov_params_default is None:
# results classes that don't have cov_HCx attribute
res.cov_params_default = sw.cov_white_simple(self,
use_correction=False)
elif cov_type.lower() == 'hac':
maxlags = kwds['maxlags'] # required?, default in cov_hac_simple
res.cov_kwds['maxlags'] = maxlags
weights_func = kwds.get('weights_func', sw.weights_bartlett)
res.cov_kwds['weights_func'] = weights_func
use_correction = kwds.get('use_correction', False)
res.cov_kwds['use_correction'] = use_correction
res.cov_kwds['description'] = ('Standard Errors are heteroscedasticity ' +
'and autocorrelation robust (HAC) using %d lags and %s small ' +
'sample correction') % (maxlags, ['without', 'with'][use_correction])
res.cov_params_default = sw.cov_hac_simple(self, nlags=maxlags,
weights_func=weights_func,
use_correction=use_correction)
elif cov_type.lower() == 'cluster':
#cluster robust standard errors, one- or two-way
groups = kwds['groups']
if not hasattr(groups, 'shape'):
groups = np.asarray(groups).T
if groups.ndim >= 2:
groups = groups.squeeze()
res.cov_kwds['groups'] = groups
use_correction = kwds.get('use_correction', True)
res.cov_kwds['use_correction'] = use_correction
if groups.ndim == 1:
if adjust_df:
# need to find number of groups
# duplicate work
self.n_groups = n_groups = len(np.unique(groups))
res.cov_params_default = sw.cov_cluster(self, groups,
use_correction=use_correction)
elif groups.ndim == 2:
if hasattr(groups, 'values'):
groups = groups.values
if adjust_df:
# need to find number of groups
# duplicate work
n_groups0 = len(np.unique(groups[:,0]))
n_groups1 = len(np.unique(groups[:, 1]))
self.n_groups = (n_groups0, n_groups1)
n_groups = min(n_groups0, n_groups1) # use for adjust_df
# Note: sw.cov_cluster_2groups has 3 returns
res.cov_params_default = sw.cov_cluster_2groups(self, groups,
use_correction=use_correction)[0]
else:
raise ValueError('only two groups are supported')
res.cov_kwds['description'] = ('Standard Errors are robust to' +
'cluster correlation ' + '(' + cov_type + ')')
elif cov_type.lower() == 'hac-panel':
#cluster robust standard errors
res.cov_kwds['time'] = time = kwds.get('time', None)
res.cov_kwds['groups'] = groups = kwds.get('groups', None)
#TODO: nlags is currently required
#nlags = kwds.get('nlags', True)
#res.cov_kwds['nlags'] = nlags
#TODO: `nlags` or `maxlags`
res.cov_kwds['maxlags'] = maxlags = kwds['maxlags']
use_correction = kwds.get('use_correction', 'hac')
res.cov_kwds['use_correction'] = use_correction
weights_func = kwds.get('weights_func', sw.weights_bartlett)
res.cov_kwds['weights_func'] = weights_func
# TODO: clumsy time index in cov_nw_panel
if groups is not None:
groups = np.asarray(groups)
tt = (np.nonzero(groups[:-1] != groups[1:])[0] + 1).tolist()
nobs_ = len(groups)
elif time is not None:
# TODO: clumsy time index in cov_nw_panel
time = np.asarray(time)
tt = (np.nonzero(time[1:] < time[:-1])[0] + 1).tolist()
nobs_ = len(time)
else:
raise ValueError('either time or groups needs to be given')
groupidx = lzip([0] + tt, tt + [nobs_])
self.n_groups = n_groups = len(groupidx)
res.cov_params_default = sw.cov_nw_panel(self, maxlags, groupidx,
weights_func=weights_func,
use_correction=use_correction)
res.cov_kwds['description'] = ('Standard Errors are robust to' +
'cluster correlation ' + '(' + cov_type + ')')
elif cov_type.lower() == 'hac-groupsum':
# Driscoll-Kraay standard errors
res.cov_kwds['time'] = time = kwds['time']
#TODO: nlags is currently required
#nlags = kwds.get('nlags', True)
#res.cov_kwds['nlags'] = nlags
#TODO: `nlags` or `maxlags`
res.cov_kwds['maxlags'] = maxlags = kwds['maxlags']
use_correction = kwds.get('use_correction', 'cluster')
res.cov_kwds['use_correction'] = use_correction
weights_func = kwds.get('weights_func', sw.weights_bartlett)
res.cov_kwds['weights_func'] = weights_func
if adjust_df:
# need to find number of groups
tt = (np.nonzero(time[1:] < time[:-1])[0] + 1)
self.n_groups = n_groups = len(tt) + 1
res.cov_params_default = sw.cov_nw_groupsum(self, maxlags, time,
weights_func=weights_func,
use_correction=use_correction)
res.cov_kwds['description'] = (
'Driscoll and Kraay Standard Errors are robust to ' +
'cluster correlation ' + '(' + cov_type + ')')
else:
raise ValueError('cov_type not recognized. See docstring for ' +
'available options and spelling')
# generic optional factor to scale covariance
res.cov_kwds['scaling_factor'] = sc_factor
if sc_factor is not None:
res.cov_params_default *= sc_factor
if adjust_df:
# Note: df_resid is used for scale and others, add new attribute
res.df_resid_inference = n_groups - 1
return res
weights_func=sw.weights_uniform,
use_correction='cluster')
assert_almost_equal(cov_uni, cov_clu, decimal=7)
#without correction
cov_clu2 = sw.cov_cluster(mod2.res_pooled,
dgp.groups.astype(int),
use_correction=False)
cov_uni2 = sw.cov_nw_panel(mod2.res_pooled,
4,
mod2.group.groupidx,
weights_func=sw.weights_uniform,
use_correction=False)
assert_almost_equal(cov_uni2, cov_clu2, decimal=8)
cov_white = sw.cov_white_simple(mod2.res_pooled)
cov_pnw0 = sw.cov_nw_panel(mod2.res_pooled,
0,
mod2.group.groupidx,
use_correction='hac')
assert_almost_equal(cov_pnw0, cov_white, decimal=13)
time = np.tile(np.arange(nobs_i), n_groups)
#time = mod2.group.group_int
cov_pnw1 = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx)
cov_pnw2 = cov_nw_panel2(mod2.res_pooled, 4, time)
#s = sw.group_sums(x, time)
c2, ct, cg = sw.cov_cluster_2groups(mod2.res_pooled,
time,
dgp.groups.astype(int),
def test_short_panel():
#this checks that some basic statistical properties are satisfied by the
##1lab_results, not verified #1lab_results against other packages
#Note: the ranking of robust bse is different if within=True
#I added within keyword to PanelSample to be able to use old example
#if within is False, then there is no within group variation in exog.
nobs = 100
nobs_i = 5
n_groups = nobs // nobs_i
k_vars = 3
dgp = PanelSample(nobs, k_vars, n_groups, corr_structure=cs.corr_arma,
corr_args=([1], [1., -0.9],), seed=377769, within=False)
#print 'seed', dgp.seed
y = dgp.generate_panel()
noise = y - dgp.y_true
#test dgp
dgp_cov_e = np.array(
[[ 1. , 0.9 , 0.81 , 0.729 , 0.6561],
[ 0.9 , 1. , 0.9 , 0.81 , 0.729 ],
[ 0.81 , 0.9 , 1. , 0.9 , 0.81 ],
[ 0.729 , 0.81 , 0.9 , 1. , 0.9 ],
[ 0.6561, 0.729 , 0.81 , 0.9 , 1. ]])
npt.assert_almost_equal(dgp.cov, dgp_cov_e, 13)
cov_noise = np.cov(noise.reshape(-1,n_groups, order='F'))
corr_noise = cov2corr(cov_noise)
npt.assert_almost_equal(corr_noise, dgp.cov, 1)
#estimate panel model
mod2 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res2 = mod2.fit_iterative(2)
#whitened residual should be uncorrelated
corr_wresid = np.corrcoef(res2.wresid.reshape(-1,n_groups, order='F'))
assert_maxabs(corr_wresid, np.eye(5), 0.1)
#residual should have same correlation as dgp
corr_resid = np.corrcoef(res2.resid.reshape(-1,n_groups, order='F'))
assert_maxabs(corr_resid, dgp.cov, 0.1)
assert_almost_equal(res2.resid.std(),1, decimal=0)
y_pred = np.dot(mod2.exog, res2.params)
assert_almost_equal(res2.fittedvalues, y_pred, 13)
#compare with OLS
res2_ols = mod2._fit_ols()
npt.assert_(mod2.res_pooled is res2_ols)
res2_ols = mod2.res_pooled #TODO: BUG: requires call to _fit_ols
#fitting once is the same as OLS
#note: I need to create new instance, otherwise it continuous fitting
mod1 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res1 = mod1.fit_iterative(1)
assert_almost_equal(res1.params, res2_ols.params, decimal=13)
assert_almost_equal(res1.bse, res2_ols.bse, decimal=13)
res_ols = OLS(y, dgp.exog).fit()
assert_almost_equal(res1.params, res_ols.params, decimal=13)
assert_almost_equal(res1.bse, res_ols.bse, decimal=13)
#compare with old version
mod_old = ShortPanelGLS2(y, dgp.exog, dgp.groups)
res_old = mod_old.fit()
assert_almost_equal(res2.params, res_old.params, decimal=13)
assert_almost_equal(res2.bse, res_old.bse, decimal=13)
mod5 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res5 = mod5.fit_iterative(5)
#make sure it's different
#npt.assert_array_less(0.009, em.maxabs(res5.bse, res2.bse))
cov_clu = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int))
clubse = se_cov(cov_clu)
pnwbse = se_cov(sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx))
bser = np.vstack((res2.bse, res5.bse, clubse, pnwbse))
bser_mean = np.mean(bser, axis=0)
#cov_cluster close to robust and PanelGLS
#is up to 24% larger than mean of bser
#npt.assert_array_less(0, clubse / bser_mean - 1)
npt.assert_array_less(clubse / bser_mean - 1, 0.25)
#cov_nw_panel close to robust and PanelGLS
npt.assert_array_less(pnwbse / bser_mean - 1, 0.1)
#OLS underestimates bse, robust at least 60% larger
npt.assert_array_less(0.6, bser_mean / res_ols.bse - 1)
#cov_hac_panel with uniform_kernel is the same as cov_cluster for balanced
#panel with full length kernel
#I fixe default correction to be equal
cov_uni = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx,
weights_func=sw.weights_uniform,
use_correction='c')
assert_almost_equal(cov_uni, cov_clu, decimal=13)
#without correction
cov_clu2 = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int),
use_correction=False)
cov_uni2 = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx,
weights_func=sw.weights_uniform,
use_correction=False)
assert_almost_equal(cov_uni2, cov_clu2, decimal=13)
cov_white = sw.cov_white_simple(mod2.res_pooled)
cov_pnw0 = sw.cov_nw_panel(mod2.res_pooled, 0, mod2.group.groupidx,
use_correction='hac')
assert_almost_equal(cov_pnw0, cov_white, decimal=13)
# panel with full length kernel
# I fixe default correction to be equal
mod2._fit_ols()
cov_clu = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int))
clubse = se_cov(cov_clu)
cov_uni = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx, weights_func=sw.weights_uniform)
assert_almost_equal(cov_uni, cov_clu, decimal=7)
# without correction
cov_clu2 = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int), use_correction=False)
cov_uni2 = sw.cov_nw_panel(
mod2.res_pooled, 4, mod2.group.groupidx, weights_func=sw.weights_uniform, use_correction=False
)
assert_almost_equal(cov_uni2, cov_clu2, decimal=8)
cov_white = sw.cov_white_simple(mod2.res_pooled)
cov_pnw0 = sw.cov_nw_panel(mod2.res_pooled, 0, mod2.group.groupidx, use_correction="hac")
assert_almost_equal(cov_pnw0, cov_white, decimal=13)
time = np.tile(np.arange(nobs_i), n_groups)
# time = mod2.group.group_int
cov_pnw1 = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx)
cov_pnw2 = cov_nw_panel2(mod2.res_pooled, 4, time)
# s = sw.group_sums(x, time)
c2, ct, cg = sw.cov_cluster_2groups(mod2.res_pooled, time, dgp.groups.astype(int), use_correction=False)
ct_nw0 = cov_nw_panel2(mod2.res_pooled, 0, time, weights_func=sw.weights_uniform, use_correction=False)
cg_nw0 = cov_nw_panel2(
mod2.res_pooled, 0, dgp.groups.astype(int), weights_func=sw.weights_uniform, use_correction=False
)
assert_almost_equal(ct_nw0, ct, decimal=13)
def test_short_panel():
#this checks that some basic statistical properties are satisfied by the
#results, not verified results against other packages
#Note: the ranking of robust bse is different if within=True
#I added within keyword to PanelSample to be able to use old example
#if within is False, then there is no within group variation in exog.
nobs = 100
nobs_i = 5
n_groups = nobs // nobs_i
k_vars = 3
dgp = PanelSample(nobs, k_vars, n_groups, corr_structure=cs.corr_arma,
corr_args=([1], [1., -0.9],), seed=377769, within=False)
#print 'seed', dgp.seed
y = dgp.generate_panel()
noise = y - dgp.y_true
#test dgp
dgp_cov_e = np.array(
[[ 1. , 0.9 , 0.81 , 0.729 , 0.6561],
[ 0.9 , 1. , 0.9 , 0.81 , 0.729 ],
[ 0.81 , 0.9 , 1. , 0.9 , 0.81 ],
[ 0.729 , 0.81 , 0.9 , 1. , 0.9 ],
[ 0.6561, 0.729 , 0.81 , 0.9 , 1. ]])
npt.assert_almost_equal(dgp.cov, dgp_cov_e, 13)
cov_noise = np.cov(noise.reshape(-1,n_groups, order='F'))
corr_noise = cov2corr(cov_noise)
npt.assert_almost_equal(corr_noise, dgp.cov, 1)
#estimate panel model
mod2 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res2 = mod2.fit_iterative(2)
#whitened residual should be uncorrelated
corr_wresid = np.corrcoef(res2.wresid.reshape(-1,n_groups, order='F'))
assert_maxabs(corr_wresid, np.eye(5), 0.1)
#residual should have same correlation as dgp
corr_resid = np.corrcoef(res2.resid.reshape(-1,n_groups, order='F'))
assert_maxabs(corr_resid, dgp.cov, 0.1)
assert_almost_equal(res2.resid.std(),1, decimal=0)
y_pred = np.dot(mod2.exog, res2.params)
assert_almost_equal(res2.fittedvalues, y_pred, 13)
#compare with OLS
res2_ols = mod2._fit_ols()
npt.assert_(mod2.res_pooled is res2_ols)
res2_ols = mod2.res_pooled #TODO: BUG: requires call to _fit_ols
#fitting once is the same as OLS
#note: I need to create new instance, otherwise it continuous fitting
mod1 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res1 = mod1.fit_iterative(1)
assert_almost_equal(res1.params, res2_ols.params, decimal=13)
assert_almost_equal(res1.bse, res2_ols.bse, decimal=13)
res_ols = OLS(y, dgp.exog).fit()
assert_almost_equal(res1.params, res_ols.params, decimal=13)
assert_almost_equal(res1.bse, res_ols.bse, decimal=13)
#compare with old version
mod_old = ShortPanelGLS2(y, dgp.exog, dgp.groups)
res_old = mod_old.fit()
assert_almost_equal(res2.params, res_old.params, decimal=13)
assert_almost_equal(res2.bse, res_old.bse, decimal=13)
mod5 = ShortPanelGLS(y, dgp.exog, dgp.groups)
res5 = mod5.fit_iterative(5)
#make sure it's different
#npt.assert_array_less(0.009, em.maxabs(res5.bse, res2.bse))
cov_clu = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int))
clubse = se_cov(cov_clu)
pnwbse = se_cov(sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx))
bser = np.vstack((res2.bse, res5.bse, clubse, pnwbse))
bser_mean = np.mean(bser, axis=0)
#cov_cluster close to robust and PanelGLS
#is up to 24% larger than mean of bser
#npt.assert_array_less(0, clubse / bser_mean - 1)
npt.assert_array_less(clubse / bser_mean - 1, 0.25)
#cov_nw_panel close to robust and PanelGLS
npt.assert_array_less(pnwbse / bser_mean - 1, 0.1)
#OLS underestimates bse, robust at least 60% larger
npt.assert_array_less(0.6, bser_mean / res_ols.bse - 1)
#cov_hac_panel with uniform_kernel is the same as cov_cluster for balanced
#panel with full length kernel
#I fixe default correction to be equal
cov_uni = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx,
weights_func=sw.weights_uniform,
use_correction='c')
assert_almost_equal(cov_uni, cov_clu, decimal=13)
#without correction
cov_clu2 = sw.cov_cluster(mod2.res_pooled, dgp.groups.astype(int),
use_correction=False)
cov_uni2 = sw.cov_nw_panel(mod2.res_pooled, 4, mod2.group.groupidx,
weights_func=sw.weights_uniform,
use_correction=False)
assert_almost_equal(cov_uni2, cov_clu2, decimal=13)
cov_white = sw.cov_white_simple(mod2.res_pooled)
cov_pnw0 = sw.cov_nw_panel(mod2.res_pooled, 0, mod2.group.groupidx,
use_correction='hac')
assert_almost_equal(cov_pnw0, cov_white, decimal=13)
