def OLS(reg, vm, w, nonspat_diag, spat_diag, moran, white_test, regimes=False):
reg.__summary = {}
# compute diagnostics and organize summary output
beta_diag_ols(reg, reg.robust)
if nonspat_diag:
# compute diagnostics
reg.sig2ML = reg.sig2n
reg.f_stat = diagnostics.f_stat(reg)
reg.logll = diagnostics.log_likelihood(reg)
reg.aic = diagnostics.akaike(reg)
reg.schwarz = diagnostics.schwarz(reg)
reg.mulColli = diagnostics.condition_index(reg)
reg.jarque_bera = diagnostics.jarque_bera(reg)
reg.breusch_pagan = diagnostics.breusch_pagan(reg)
reg.koenker_bassett = diagnostics.koenker_bassett(reg)
if white_test:
reg.white = diagnostics.white(reg)
# organize summary output
reg.__summary['summary_nonspat_diag_1'] = summary_nonspat_diag_1(reg)
reg.__summary['summary_nonspat_diag_2'] = summary_nonspat_diag_2(reg)
if spat_diag:
# compute diagnostics and organize summary output
spat_diag_ols(reg, w, moran)
if regimes:
summary_regimes(reg)
summary_warning(reg)
summary(reg=reg, vm=vm, instruments=False,
nonspat_diag=nonspat_diag, spat_diag=spat_diag)
def OLS(reg, vm, w, nonspat_diag, spat_diag, moran, regimes=False):
reg.__summary = {}
# compute diagnostics and organize summary output
beta_diag_ols(reg, reg.robust)
if nonspat_diag:
# compute diagnostics
reg.sig2ML = reg.sig2n
reg.f_stat = diagnostics.f_stat(reg)
reg.logll = diagnostics.log_likelihood(reg)
reg.aic = diagnostics.akaike(reg)
reg.schwarz = diagnostics.schwarz(reg)
reg.mulColli = diagnostics.condition_index(reg)
reg.jarque_bera = diagnostics.jarque_bera(reg)
reg.breusch_pagan = diagnostics.breusch_pagan(reg)
reg.koenker_bassett = diagnostics.koenker_bassett(reg)
reg.white = diagnostics.white(reg)
# organize summary output
reg.__summary['summary_nonspat_diag_1'] = summary_nonspat_diag_1(reg)
reg.__summary['summary_nonspat_diag_2'] = summary_nonspat_diag_2(reg)
if spat_diag:
# compute diagnostics and organize summary output
spat_diag_ols(reg, w, moran)
if regimes:
summary_regimes(reg)
summary(reg=reg,
vm=vm,
instruments=False,
nonspat_diag=nonspat_diag,
spat_diag=spat_diag)
def __init__(self,
y,
x,
w,
method='full',
epsilon=0.0000001,
spat_diag=False,
vm=False,
name_y=None,
name_x=None,
name_w=None,
name_ds=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
x_constant = USER.check_constant(x)
method = method.upper()
BaseML_Error.__init__(self,
y=y,
x=x_constant,
w=w,
method=method,
epsilon=epsilon)
self.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR" + \
" (METHOD = " + method + ")"
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_x = USER.set_name_x(name_x, x)
self.name_x.append('lambda')
self.name_w = USER.set_name_w(name_w, w)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
SUMMARY.ML_Error(reg=self, w=w, vm=vm, spat_diag=spat_diag)
def __init__(self, y, x, w, method='full', epsilon=0.0000001,
spat_diag=False, vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
x_constant = USER.check_constant(x)
method = method.upper()
if method in ['FULL', 'ORD']:
BaseML_Lag.__init__(self, y=y, x=x_constant,
w=w, method=method, epsilon=epsilon)
# increase by 1 to have correct aic and sc, include rho in count
self.k += 1
self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG" + \
" (METHOD = " + method + ")"
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_x = USER.set_name_x(name_x, x)
name_ylag = USER.set_name_yend_sp(self.name_y)
self.name_x.append(name_ylag) # rho changed to last position
self.name_w = USER.set_name_w(name_w, w)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
SUMMARY.ML_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag)
else:
raise Exception, "{0} is an unsupported method".format(method)
def OLS_multi(reg, multireg, vm, nonspat_diag, spat_diag, moran, regimes=False):
for m in multireg:
mreg = multireg[m]
mreg.__summary = {}
# compute diagnostics and organize summary output
beta_diag_ols(mreg, mreg.robust)
if nonspat_diag:
# compute diagnostics
mreg.sig2ML = mreg.sig2n
mreg.f_stat = diagnostics.f_stat(mreg)
mreg.logll = diagnostics.log_likelihood(mreg)
mreg.aic = diagnostics.akaike(mreg)
mreg.schwarz = diagnostics.schwarz(mreg)
mreg.mulColli = diagnostics.condition_index(mreg)
mreg.jarque_bera = diagnostics.jarque_bera(mreg)
mreg.breusch_pagan = diagnostics.breusch_pagan(mreg)
mreg.koenker_bassett = diagnostics.koenker_bassett(mreg)
mreg.white = diagnostics.white(mreg)
# organize summary output
mreg.__summary["summary_nonspat_diag_1"] = summary_nonspat_diag_1(mreg)
mreg.__summary["summary_nonspat_diag_2"] = summary_nonspat_diag_2(mreg)
if spat_diag:
# compute diagnostics and organize summary output
spat_diag_ols(mreg, mreg.w, moran)
if regimes:
summary_regimes(mreg, chow=False)
multireg[m].__summary = mreg.__summary
reg.__summary = {}
summary_chow(reg)
summary_warning(reg)
summary_multi(reg=reg, multireg=multireg, vm=vm, instruments=False, nonspat_diag=nonspat_diag, spat_diag=spat_diag)
def __init__(self, y, x, w, method='full', epsilon=0.0000001,
spat_diag=False, vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
x_constant = USER.check_constant(x)
method = method.upper()
if method in ['FULL', 'ORD']:
BaseML_Lag.__init__(
self, y=y, x=x_constant, w=w, method=method, epsilon=epsilon)
# increase by 1 to have correct aic and sc, include rho in count
self.k += 1
self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG" + \
" (METHOD = " + method + ")"
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_x = USER.set_name_x(name_x, x)
name_ylag = USER.set_name_yend_sp(self.name_y)
self.name_x.append(name_ylag) # rho changed to last position
self.name_w = USER.set_name_w(name_w, w)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
SUMMARY.ML_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag)
else:
raise Exception, "{0} is an unsupported method".format(method)
def __init__(self, y, x, regimes, w=None, constant_regi='many',\
cols2regi='all', method='full', epsilon=0.0000001,\
regime_lag_sep=False, cores=None, spat_diag=False,\
vm=False, name_y=None, name_x=None,\
name_w=None, name_ds=None, name_regimes=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
USER.check_spat_diag(spat_diag, w)
name_y = USER.set_name_y(name_y)
self.name_y = name_y
self.name_x_r = USER.set_name_x(name_x, x) + [USER.set_name_yend_sp(name_y)]
self.method = method
self.epsilon = epsilon
self.name_regimes = USER.set_name_ds(name_regimes)
self.constant_regi=constant_regi
self.n = n
cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x, add_cons=False)
self.cols2regi = cols2regi
self.regimes_set = REGI._get_regimes_set(regimes)
self.regimes = regimes
self.regime_lag_sep = regime_lag_sep
self._cache = {}
self.name_ds = USER.set_name_ds(name_ds)
self.name_w = USER.set_name_w(name_w, w)
USER.check_regimes(self.regimes_set,self.n,x.shape[1])
if regime_lag_sep == True:
if not (set(cols2regi) == set([True]) and constant_regi == 'many'):
raise Exception, "All variables must vary by regimes if regime_lag_sep = True."
cols2regi += [True]
w_i,regi_ids,warn = REGI.w_regimes(w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi)+1)
set_warn(self,warn)
else:
cols2regi += [False]
if set(cols2regi) == set([True]) and constant_regi == 'many':
self.y = y
self.ML_Lag_Regimes_Multi(y, x, w_i, w, regi_ids,\
cores=cores, cols2regi=cols2regi, method=method, epsilon=epsilon,\
spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,\
name_regimes=self.name_regimes,\
name_w=name_w, name_ds=name_ds)
else:
#if regime_lag_sep == True:
# w = REGI.w_regimes_union(w, w_i, self.regimes_set)
name_x = USER.set_name_x(name_x, x,constant=True)
x, self.name_x = REGI.Regimes_Frame.__init__(self, x, \
regimes, constant_regi, cols2regi=cols2regi[:-1], names=name_x)
self.name_x.append("_Global_"+USER.set_name_yend_sp(name_y))
BaseML_Lag.__init__(self, y=y, x=x, w=w, method=method, epsilon=epsilon)
self.kf += 1 #Adding a fixed k to account for spatial lag.
self.chow = REGI.Chow(self)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
self.regime_lag_sep=regime_lag_sep
self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIMES" + " (METHOD = " + method + ")"
SUMMARY.ML_Lag(reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, w=None, constant_regi='many',
cols2regi='all', method='full', epsilon=0.0000001,
regime_err_sep=False, cores=None, spat_diag=False,
vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None, name_regimes=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
self.constant_regi = constant_regi
self.cols2regi = cols2regi
self.regime_err_sep = regime_err_sep
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_w = USER.set_name_w(name_w, w)
self.name_regimes = USER.set_name_ds(name_regimes)
self.n = n
self.y = y
x_constant = USER.check_constant(x)
name_x = USER.set_name_x(name_x, x)
self.name_x_r = name_x
cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x)
self.regimes_set = REGI._get_regimes_set(regimes)
self.regimes = regimes
USER.check_regimes(self.regimes_set, self.n, x.shape[1])
self.regime_err_sep = regime_err_sep
if regime_err_sep == True:
if set(cols2regi) == set([True]):
self._error_regimes_multi(y, x, regimes, w, cores,
method, epsilon, cols2regi, vm, name_x, spat_diag)
else:
raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True."
else:
regimes_att = {}
regimes_att['x'] = x_constant
regimes_att['regimes'] = regimes
regimes_att['cols2regi'] = cols2regi
x, name_x = REGI.Regimes_Frame.__init__(self, x_constant,
regimes, constant_regi=None, cols2regi=cols2regi,
names=name_x)
BaseML_Error.__init__(
self, y=y, x=x, w=w, method=method, epsilon=epsilon, regimes_att=regimes_att)
self.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIMES" + \
" (METHOD = " + method + ")"
self.name_x = USER.set_name_x(name_x, x, constant=True)
self.name_x.append('lambda')
self.kf += 1 # Adding a fixed k to account for lambda.
self.chow = REGI.Chow(self)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
self._cache = {}
SUMMARY.ML_Error(reg=self, w=w, vm=vm,
spat_diag=spat_diag, regimes=True)
def __init__(self, y, x, regimes, w=None, constant_regi='many',
cols2regi='all', method='full', epsilon=0.0000001,
regime_err_sep=False, regime_lag_sep=False, cores=False, spat_diag=False,
vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None, name_regimes=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
self.constant_regi = constant_regi
self.cols2regi = cols2regi
self.regime_err_sep = regime_err_sep
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_w = USER.set_name_w(name_w, w)
self.name_regimes = USER.set_name_ds(name_regimes)
self.n = n
self.y = y
x_constant = USER.check_constant(x)
name_x = USER.set_name_x(name_x, x)
self.name_x_r = name_x
cols2regi = REGI.check_cols2regi(constant_regi, cols2regi, x)
self.regimes_set = REGI._get_regimes_set(regimes)
self.regimes = regimes
USER.check_regimes(self.regimes_set, self.n, x.shape[1])
self.regime_err_sep = regime_err_sep
if regime_err_sep == True:
if set(cols2regi) == set([True]):
self._error_regimes_multi(y, x, regimes, w, cores,
method, epsilon, cols2regi, vm, name_x, spat_diag)
else:
raise Exception, "All coefficients must vary accross regimes if regime_err_sep = True."
else:
regimes_att = {}
regimes_att['x'] = x_constant
regimes_att['regimes'] = regimes
regimes_att['cols2regi'] = cols2regi
x, name_x = REGI.Regimes_Frame.__init__(self, x_constant,
regimes, constant_regi=None, cols2regi=cols2regi,
names=name_x)
BaseML_Error.__init__(
self, y=y, x=x, w=w, method=method, epsilon=epsilon, regimes_att=regimes_att)
self.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIMES" + \
" (METHOD = " + method + ")"
self.name_x = USER.set_name_x(name_x, x, constant=True)
self.name_x.append('lambda')
self.kf += 1 # Adding a fixed k to account for lambda.
self.chow = REGI.Chow(self)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
self._cache = {}
SUMMARY.ML_Error(
reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
def OLS_multi(reg,
multireg,
vm,
nonspat_diag,
spat_diag,
moran,
white_test,
regimes=False,
sur=False,
w=False):
for m in multireg:
mreg = multireg[m]
mreg.__summary = {}
# compute diagnostics and organize summary output
beta_diag_ols(mreg, mreg.robust)
if nonspat_diag:
# compute diagnostics
mreg.sig2ML = mreg.sig2n
mreg.f_stat = diagnostics.f_stat(mreg)
mreg.logll = diagnostics.log_likelihood(mreg)
mreg.aic = diagnostics.akaike(mreg)
mreg.schwarz = diagnostics.schwarz(mreg)
mreg.mulColli = diagnostics.condition_index(mreg)
mreg.jarque_bera = diagnostics.jarque_bera(mreg)
mreg.breusch_pagan = diagnostics.breusch_pagan(mreg)
mreg.koenker_bassett = diagnostics.koenker_bassett(mreg)
if white_test:
mreg.white = diagnostics.white(mreg)
# organize summary output
mreg.__summary['summary_nonspat_diag_1'] = summary_nonspat_diag_1(
mreg)
mreg.__summary['summary_nonspat_diag_2'] = summary_nonspat_diag_2(
mreg)
if spat_diag:
# compute diagnostics and organize summary output
spat_diag_ols(mreg, mreg.w, moran)
if regimes:
summary_regimes(mreg, chow=False)
if sur:
summary_sur(mreg)
summary_warning(mreg)
multireg[m].__summary = mreg.__summary
reg.__summary = {}
if regimes:
summary_chow(reg)
if sur:
summary_sur(reg, u_cov=True)
if spat_diag:
# compute global diagnostics and organize summary output
spat_diag_ols(reg, w, moran)
summary_warning(reg)
summary_multi(reg=reg,
multireg=multireg,
vm=vm,
instruments=False,
nonspat_diag=nonspat_diag,
spat_diag=spat_diag)
def _work(y, x, regi_ids, r, w_r, method, epsilon, name_ds, name_y, name_x, name_w, name_regimes):
y_r = y[regi_ids[r]]
x_r = x[regi_ids[r]]
x_constant = USER.check_constant(x_r)
model = BaseML_Lag(y_r, x_constant, w_r, method=method, epsilon=epsilon)
model.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIME " + str(r) + " (METHOD = " + method + ")"
model.name_ds = name_ds
model.name_y = "%s_%s" % (str(r), name_y)
model.name_x = ["%s_%s" % (str(r), i) for i in name_x]
model.name_w = name_w
model.name_regimes = name_regimes
model.aic = DIAG.akaike(reg=model)
model.schwarz = DIAG.schwarz(reg=model)
return model
def _work(y, x, regi_ids, r, w_r, method, epsilon, name_ds, name_y, name_x, name_w, name_regimes):
y_r = y[regi_ids[r]]
x_r = x[regi_ids[r]]
x_constant = USER.check_constant(x_r)
model = BaseML_Lag(y_r, x_constant, w_r, method=method, epsilon=epsilon)
model.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIME " + \
str(r) + " (METHOD = " + method + ")"
model.name_ds = name_ds
model.name_y = '%s_%s' % (str(r), name_y)
model.name_x = ['%s_%s' % (str(r), i) for i in name_x]
model.name_w = name_w
model.name_regimes = name_regimes
model.k += 1 # add 1 for proper df and aic, sc
model.aic = DIAG.akaike(reg=model)
model.schwarz = DIAG.schwarz(reg=model)
return model
def _work_error(y,x,regi_ids,r,w,method,epsilon,name_ds,name_y,name_x,name_w,name_regimes):
w_r,warn = REGI.w_regime(w, regi_ids[r], r, transform=True)
y_r = y[regi_ids[r]]
x_r = x[regi_ids[r]]
x_constant = USER.check_constant(x_r)
model = BaseML_Error(y=y_r,x=x_constant,w=w_r,method=method,epsilon=epsilon)
set_warn(model, warn)
model.w = w_r
model.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIME "+str(r)+" (METHOD = "+method+")"
model.name_ds = name_ds
model.name_y = '%s_%s'%(str(r), name_y)
model.name_x = ['%s_%s'%(str(r), i) for i in name_x]
model.name_w = name_w
model.name_regimes = name_regimes
model.aic = DIAG.akaike(reg=model)
model.schwarz = DIAG.schwarz(reg=model)
return model
def _work_error(y, x, regi_ids, r, w, method, epsilon, name_ds, name_y, name_x, name_w, name_regimes):
w_r, warn = REGI.w_regime(w, regi_ids[r], r, transform=True)
y_r = y[regi_ids[r]]
x_r = x[regi_ids[r]]
x_constant = USER.check_constant(x_r)
model = BaseML_Error(
y=y_r, x=x_constant, w=w_r, method=method, epsilon=epsilon)
set_warn(model, warn)
model.w = w_r
model.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR - REGIME " + \
str(r) + " (METHOD = " + method + ")"
model.name_ds = name_ds
model.name_y = '%s_%s' % (str(r), name_y)
model.name_x = ['%s_%s' % (str(r), i) for i in name_x]
model.name_w = name_w
model.name_regimes = name_regimes
model.aic = DIAG.akaike(reg=model)
model.schwarz = DIAG.schwarz(reg=model)
return model
def __init__(self, y, x, w, method='full', epsilon=0.0000001,
spat_diag=False, vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
x_constant = USER.check_constant(x)
method = method.upper()
BaseML_Error.__init__(self, y=y, x=x_constant,
w=w, method=method, epsilon=epsilon)
self.title = "MAXIMUM LIKELIHOOD SPATIAL ERROR" + \
" (METHOD = " + method + ")"
self.name_ds = USER.set_name_ds(name_ds)
self.name_y = USER.set_name_y(name_y)
self.name_x = USER.set_name_x(name_x, x)
self.name_x.append('lambda')
self.name_w = USER.set_name_w(name_w, w)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
SUMMARY.ML_Error(reg=self, w=w, vm=vm, spat_diag=spat_diag)
def __init__(self, y, x, regimes, w=None, constant_regi='many',
cols2regi='all', method='full', epsilon=0.0000001,
regime_lag_sep=False, regime_err_sep=False, cores=False, spat_diag=False,
vm=False, name_y=None, name_x=None,
name_w=None, name_ds=None, name_regimes=None):
n = USER.check_arrays(y, x)
USER.check_y(y, n)
USER.check_weights(w, y, w_required=True)
USER.check_spat_diag(spat_diag, w)
name_y = USER.set_name_y(name_y)
self.name_y = name_y
self.name_x_r = USER.set_name_x(
name_x, x) + [USER.set_name_yend_sp(name_y)]
self.method = method
self.epsilon = epsilon
self.name_regimes = USER.set_name_ds(name_regimes)
self.constant_regi = constant_regi
self.n = n
cols2regi = REGI.check_cols2regi(
constant_regi, cols2regi, x, add_cons=False)
self.cols2regi = cols2regi
self.regimes_set = REGI._get_regimes_set(regimes)
self.regimes = regimes
self.regime_lag_sep = regime_lag_sep
self._cache = {}
self.name_ds = USER.set_name_ds(name_ds)
self.name_w = USER.set_name_w(name_w, w)
USER.check_regimes(self.regimes_set, self.n, x.shape[1])
# regime_err_sep is ignored, always False
if regime_lag_sep == True:
if not (set(cols2regi) == set([True]) and constant_regi == 'many'):
raise Exception, "All variables must vary by regimes if regime_lag_sep = True."
cols2regi += [True]
w_i, regi_ids, warn = REGI.w_regimes(
w, regimes, self.regimes_set, transform=True, get_ids=True, min_n=len(cols2regi) + 1)
set_warn(self, warn)
else:
cols2regi += [False]
if set(cols2regi) == set([True]) and constant_regi == 'many':
self.y = y
self.ML_Lag_Regimes_Multi(y, x, w_i, w, regi_ids,
cores=cores, cols2regi=cols2regi, method=method, epsilon=epsilon,
spat_diag=spat_diag, vm=vm, name_y=name_y, name_x=name_x,
name_regimes=self.name_regimes,
name_w=name_w, name_ds=name_ds)
else:
# if regime_lag_sep == True:
# w = REGI.w_regimes_union(w, w_i, self.regimes_set)
name_x = USER.set_name_x(name_x, x, constant=True)
x, self.name_x = REGI.Regimes_Frame.__init__(self, x,
regimes, constant_regi, cols2regi=cols2regi[:-1], names=name_x)
self.name_x.append("_Global_" + USER.set_name_yend_sp(name_y))
BaseML_Lag.__init__(
self, y=y, x=x, w=w, method=method, epsilon=epsilon)
self.kf += 1 # Adding a fixed k to account for spatial lag in Chow
# adding a fixed k to account for spatial lag in aic, sc
self.k += 1
self.chow = REGI.Chow(self)
self.aic = DIAG.akaike(reg=self)
self.schwarz = DIAG.schwarz(reg=self)
self.regime_lag_sep = regime_lag_sep
self.title = "MAXIMUM LIKELIHOOD SPATIAL LAG - REGIMES" + \
" (METHOD = " + method + ")"
SUMMARY.ML_Lag(
reg=self, w=w, vm=vm, spat_diag=spat_diag, regimes=True)
