From b4df185609227ba3fd96cc0492152b70ab10df71 Mon Sep 17 00:00:00 2001 From: Pedro Amaral Date: Mon, 24 Jun 2024 18:38:31 -0300 Subject: [PATCH] Updating utils.py and a few tests tolerances --- spreg/error_sp_het.py | 6 - spreg/ml_lag_regimes.py | 2 + spreg/tests/test_error_sp_het.py | 769 +++++++++-------------- spreg/tests/test_error_sp_het_regimes.py | 667 +++++++------------- spreg/tests/test_error_sp_het_sparse.py | 769 +++++++++-------------- spreg/tests/test_sp_panels.py | 239 ++----- spreg/utils.py | 11 +- 7 files changed, 904 insertions(+), 1559 deletions(-) diff --git a/spreg/error_sp_het.py b/spreg/error_sp_het.py index abac7638..24c9adcb 100755 --- a/spreg/error_sp_het.py +++ b/spreg/error_sp_het.py @@ -129,12 +129,6 @@ def __init__(self, y, x, w, max_iter=1, epsilon=0.00001, step1c=False, hard_boun else: lambda2 = lambda1 - # Forcing the 1st step lambda to be in the range [-0.9, 0.9] to avoid perfect collinearity in step 2 in case of SLX-Error or GNS models - #if lambda2 > 0.9: - # lambda_old = 0.9 - #elif lambda2 < -0.9: - # lambda_old = -0.9 - #else: lambda_old = lambda2 self.iteration, eps = 0, 1 diff --git a/spreg/ml_lag_regimes.py b/spreg/ml_lag_regimes.py index bfed43f1..93da512f 100644 --- a/spreg/ml_lag_regimes.py +++ b/spreg/ml_lag_regimes.py @@ -643,6 +643,8 @@ def _work( model.aic = DIAG.akaike(reg=model) model.schwarz = DIAG.schwarz(reg=model) model.slx_lags = slx_lags + model.w = w_r + model.rho = model.betas[-1] return model diff --git a/spreg/tests/test_error_sp_het.py b/spreg/tests/test_error_sp_het.py index 8b4e6e78..727c2951 100644 --- a/spreg/tests/test_error_sp_het.py +++ b/spreg/tests/test_error_sp_het.py @@ -5,219 +5,191 @@ from libpysal.common import RTOL import spreg - class TestBaseGMErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.X = np.hstack((np.ones(self.y.shape), self.X)) - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.X = np.hstack((np.ones(self.y.shape),self.X)) + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): reg = HET.BaseGM_Error_Het(self.y, self.X, self.w.sparse, step1c=True) - betas = np.array([[47.99626638], [0.71048989], [-0.55876126], [0.41178776]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([27.38122697]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([32.29765975]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.08577603]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 47.99626638], [ 0.71048989], [ -0.55876126], [ 0.41178776]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 27.38122697]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 32.29765975]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.08577603]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [1.31767529e02, -3.58368748e00, -1.65090647e00, 0.00000000e00], - [-3.58368748e00, 1.35513711e-01, 3.77539055e-02, 0.00000000e00], - [-1.65090647e00, 3.77539055e-02, 2.61042702e-02, 0.00000000e00], - [0.00000000e00, 0.00000000e00, 0.00000000e00, 2.82398517e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - xtx = np.array( - [ - [4.90000000e01, 7.04371999e02, 1.72131237e03], - [7.04371999e02, 1.16866734e04, 2.15575320e04], - [1.72131237e03, 2.15575320e04, 7.39058986e04], - ] - ) - np.testing.assert_allclose(reg.xtx, xtx, RTOL) - - + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 1.31767529e+02, -3.58368748e+00, -1.65090647e+00, + 0.00000000e+00], + [ -3.58368748e+00, 1.35513711e-01, 3.77539055e-02, + 0.00000000e+00], + [ -1.65090647e+00, 3.77539055e-02, 2.61042702e-02, + 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 2.82398517e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) + xtx = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04]]) + np.testing.assert_allclose(reg.xtx,xtx,RTOL) + class TestGMErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): reg = HET.GM_Error_Het(self.y, self.X, self.w, step1c=True) - betas = np.array([[47.99626638], [0.71048989], [-0.55876126], [0.41178776]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([27.38122697]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([32.29765975]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.08577603]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 47.99626638], [ 0.71048989], [ -0.55876126], [ 0.41178776]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 27.38122697]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 32.29765975]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.08577603]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [1.31767529e02, -3.58368748e00, -1.65090647e00, 0.00000000e00], - [-3.58368748e00, 1.35513711e-01, 3.77539055e-02, 0.00000000e00], - [-1.65090647e00, 3.77539055e-02, 2.61042702e-02, 0.00000000e00], - [0.00000000e00, 0.00000000e00, 0.00000000e00, 2.82398517e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 1.31767529e+02, -3.58368748e+00, -1.65090647e+00, + 0.00000000e+00], + [ -3.58368748e+00, 1.35513711e-01, 3.77539055e-02, + 0.00000000e+00], + [ -1.65090647e+00, 3.77539055e-02, 2.61042702e-02, + 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 2.82398517e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) pr2 = 0.34951013222581306 - np.testing.assert_allclose(reg.pr2, pr2) - stde = np.array([11.47900385, 0.36812187, 0.16156816, 0.16804717]) - np.testing.assert_allclose(reg.std_err, stde, RTOL) - z_stat = np.array( - [ - [4.18122226e00, 2.89946274e-05], - [1.93003988e00, 5.36018970e-02], - [-3.45836247e00, 5.43469673e-04], - [2.45042960e00, 1.42685863e-02], - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - xtx = np.array( - [ - [4.90000000e01, 7.04371999e02, 1.72131237e03], - [7.04371999e02, 1.16866734e04, 2.15575320e04], - [1.72131237e03, 2.15575320e04, 7.39058986e04], - ] - ) - np.testing.assert_allclose(reg.xtx, xtx, RTOL) - + np.testing.assert_allclose(reg.pr2,pr2) + stde = np.array([ 11.47900385, 0.36812187, 0.16156816, 0.16804717]) + np.testing.assert_allclose(reg.std_err,stde,RTOL) + z_stat = np.array([[ 4.18122226e+00, 2.89946274e-05], + [ 1.93003988e+00, 5.36018970e-02], + [ -3.45836247e+00, 5.43469673e-04], + [ 2.45042960e+00, 1.42685863e-02]]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + xtx = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04]]) + np.testing.assert_allclose(reg.xtx,xtx,RTOL) class TestBaseGMEndogErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) self.X = np.array(X).T - self.X = np.hstack((np.ones(self.y.shape), self.X)) + self.X = np.hstack((np.ones(self.y.shape),self.X)) yd = [] yd.append(db.by_col("CRIME")) self.yd = np.array(yd).T q = [] q.append(db.by_col("DISCBD")) self.q = np.array(q).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): - reg = HET.BaseGM_Endog_Error_Het( - self.y, self.X, self.yd, self.q, self.w.sparse, step1c=True - ) - betas = np.array([[55.39707924], [0.46563046], [-0.67038326], [0.41135023]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([26.51812895]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.46604707]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.94887405]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = HET.BaseGM_Endog_Error_Het(self.y, self.X, self.yd, self.q, self.w.sparse, step1c=True) + betas = np.array([[ 55.39707924], [ 0.46563046], [ -0.67038326], [ 0.41135023]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 26.51812895]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.46604707]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.94887405]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - yend = np.array([15.72598]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([5.03]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.z[0], z, RTOL) - h = np.array([1.0, 19.531, 5.03]) - np.testing.assert_allclose(reg.h[0], h, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + yend = np.array([ 15.72598]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 5.03]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.z[0],z,RTOL) + h = np.array([ 1. , 19.531, 5.03 ]) + np.testing.assert_allclose(reg.h[0],h,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [8.34637805e02, -2.16932259e01, -1.33327894e01, 1.65840848e00], - [-2.16932259e01, 5.97683070e-01, 3.39503523e-01, -3.90111107e-02], - [-1.33327894e01, 3.39503523e-01, 2.19008080e-01, -2.81929695e-02], - [1.65840848e00, -3.90111107e-02, -2.81929695e-02, 3.15686105e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - hth = np.array( - [ - [49.0, 704.371999, 139.75], - [704.371999, 11686.67338121, 2246.12800625], - [139.75, 2246.12800625, 498.5851], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - - + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 8.34637805e+02, -2.16932259e+01, -1.33327894e+01, + 1.65840848e+00], + [ -2.16932259e+01, 5.97683070e-01, 3.39503523e-01, + -3.90111107e-02], + [ -1.33327894e+01, 3.39503523e-01, 2.19008080e-01, + -2.81929695e-02], + [ 1.65840848e+00, -3.90111107e-02, -2.81929695e-02, + 3.15686105e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) + hth = np.array([[ 49. , 704.371999 , 139.75 ], + [ 704.371999 , 11686.67338121, 2246.12800625], + [ 139.75 , 2246.12800625, 498.5851 ]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) + class TestGMEndogErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) self.X = np.array(X).T @@ -227,364 +199,211 @@ def setUp(self): q = [] q.append(db.by_col("DISCBD")) self.q = np.array(q).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): - reg = HET.GM_Endog_Error_Het( - self.y, self.X, self.yd, self.q, self.w, step1c=True - ) - betas = np.array([[55.39707924], [0.46563046], [-0.67038326], [0.41135023]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([26.51812895]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([53.94887405]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = HET.GM_Endog_Error_Het(self.y, self.X, self.yd, self.q, self.w, step1c=True) + betas = np.array([[ 55.39707924], [ 0.46563046], [ -0.67038326], [ 0.41135023]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 26.51812895]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([ 53.94887405]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - yend = np.array([15.72598]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([5.03]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.z[0], z, RTOL) - h = np.array([1.0, 19.531, 5.03]) - np.testing.assert_allclose(reg.h[0], h, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + yend = np.array([ 15.72598]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 5.03]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.z[0],z,RTOL) + h = np.array([ 1. , 19.531, 5.03 ]) + np.testing.assert_allclose(reg.h[0],h,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [8.34637805e02, -2.16932259e01, -1.33327894e01, 1.65840848e00], - [-2.16932259e01, 5.97683070e-01, 3.39503523e-01, -3.90111107e-02], - [-1.33327894e01, 3.39503523e-01, 2.19008080e-01, -2.81929695e-02], - [1.65840848e00, -3.90111107e-02, -2.81929695e-02, 3.15686105e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 8.34637805e+02, -2.16932259e+01, -1.33327894e+01, + 1.65840848e+00], + [ -2.16932259e+01, 5.97683070e-01, 3.39503523e-01, + -3.90111107e-02], + [ -1.33327894e+01, 3.39503523e-01, 2.19008080e-01, + -2.81929695e-02], + [ 1.65840848e+00, -3.90111107e-02, -2.81929695e-02, + 3.15686105e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) pr2 = 0.34648011338954804 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) - std_err = np.array([28.89009873, 0.77309965, 0.46798299, 0.17767558]) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - z_stat = np.array( - [ - (1.9175109006819244, 0.055173057472126787), - (0.60229035155742305, 0.54698088217644414), - (-1.4324949211864271, 0.15200223057569454), - (2.3151759776869496, 0.020603303355572443), - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - hth = np.array( - [ - [49.0, 704.371999, 139.75], - [704.371999, 11686.67338121, 2246.12800625], - [139.75, 2246.12800625, 498.5851], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - - + np.testing.assert_allclose(reg.pr2,pr2,RTOL) + std_err = np.array([ 28.89009873, 0.77309965, 0.46798299, + 0.17767558]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + z_stat = np.array([(1.9175109006819244, 0.055173057472126787), (0.60229035155742305, 0.54698088217644414), (-1.4324949211864271, 0.15200223057569454), (2.3151759776869496, 0.020603303355572443)]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + hth = np.array([[ 49. , 704.371999 , 139.75 ], + [ 704.371999 , 11686.67338121, 2246.12800625], + [ 139.75 , 2246.12800625, 498.5851 ]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) + class TestBaseGMComboHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): # Only spatial lag yd2, q2 = spreg.utils.set_endog(self.y, self.X, self.w, None, None, 1, True) - self.X = np.hstack((np.ones(self.y.shape), self.X)) - reg = HET.BaseGM_Combo_Het( - self.y, self.X, yend=yd2, q=q2, w=self.w.sparse, step1c=True - ) - betas = np.array( - [[57.7778574], [0.73034922], [-0.59257362], [-0.2230231], [0.56636724]] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([25.65156033]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.87664403]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([54.81544267]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + self.X = np.hstack((np.ones(self.y.shape),self.X)) + reg = HET.BaseGM_Combo_Het(self.y, self.X, yend=yd2, q=q2, w=self.w.sparse, step1c=True) + betas = np.array([[ 57.7778574 ], [ 0.73034922], [ -0.59257362], [ -0.2230231 ], [ 0.56636724]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 25.65156033]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.87664403]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 54.81544267]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 4 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - yend = np.array([35.4585005]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([18.594, 24.7142675]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598, 35.4585005]) - np.testing.assert_allclose(reg.z[0], z, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + yend = np.array([ 35.4585005]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 18.594 , 24.7142675]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598 , 35.4585005]) + np.testing.assert_allclose(reg.z[0],z,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy, RTOL) - vm = np.array( - [ - [ - 4.86218274e02, - -2.77268729e00, - -1.59987770e00, - -1.01969471e01, - 2.74302006e00, - ], - [ - -2.77268729e00, - 1.04680972e-01, - 2.51172238e-02, - 1.95136385e-03, - 3.70052723e-03, - ], - [ - -1.59987770e00, - 2.51172238e-02, - 2.15655720e-02, - 7.65868344e-03, - -7.30173070e-03, - ], - [ - -1.01969471e01, - 1.95136385e-03, - 7.65868344e-03, - 2.78273684e-01, - -6.89402590e-02, - ], - [ - 2.74302006e00, - 3.70052723e-03, - -7.30173070e-03, - -6.89402590e-02, - 7.12034037e-02, - ], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - hth = np.array( - [ - [ - 4.90000000e01, - 7.04371999e02, - 1.72131237e03, - 7.24743592e02, - 1.70735413e03, - ], - [ - 7.04371999e02, - 1.16866734e04, - 2.15575320e04, - 1.10925200e04, - 2.23848036e04, - ], - [ - 1.72131237e03, - 2.15575320e04, - 7.39058986e04, - 2.34796298e04, - 6.70145378e04, - ], - [ - 7.24743592e02, - 1.10925200e04, - 2.34796298e04, - 1.16146226e04, - 2.30304624e04, - ], - [ - 1.70735413e03, - 2.23848036e04, - 6.70145378e04, - 2.30304624e04, - 6.69879858e04, - ], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - + np.testing.assert_allclose(reg.std_y,stdy,RTOL) + vm = np.array([[ 4.86218274e+02, -2.77268729e+00, -1.59987770e+00, + -1.01969471e+01, 2.74302006e+00], + [ -2.77268729e+00, 1.04680972e-01, 2.51172238e-02, + 1.95136385e-03, 3.70052723e-03], + [ -1.59987770e+00, 2.51172238e-02, 2.15655720e-02, + 7.65868344e-03, -7.30173070e-03], + [ -1.01969471e+01, 1.95136385e-03, 7.65868344e-03, + 2.78273684e-01, -6.89402590e-02], + [ 2.74302006e+00, 3.70052723e-03, -7.30173070e-03, + -6.89402590e-02, 7.12034037e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL*10) + hth = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03, + 7.24743592e+02, 1.70735413e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04, + 1.10925200e+04, 2.23848036e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04, + 2.34796298e+04, 6.70145378e+04], + [ 7.24743592e+02, 1.10925200e+04, 2.34796298e+04, + 1.16146226e+04, 2.30304624e+04], + [ 1.70735413e+03, 2.23848036e+04, 6.70145378e+04, + 2.30304624e+04, 6.69879858e+04]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) class TestGMComboHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): # Only spatial lag reg = HET.GM_Combo_Het(self.y, self.X, w=self.w, step1c=True) - betas = np.array( - [[57.7778574], [0.73034922], [-0.59257362], [-0.2230231], [0.56636724]] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([25.65156033]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.87664403]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - ep = np.array([28.30648145]) - np.testing.assert_allclose(reg.e_pred[0], ep, RTOL) - pe = np.array([52.16052155]) - np.testing.assert_allclose(reg.predy_e[0], pe, RTOL) - predy = np.array([54.81544267]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 57.7778574 ], [ 0.73034922], [ -0.59257362], [ -0.2230231 ], [ 0.56636724]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 25.65156033]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.87664403]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + ep = np.array([ 28.30648145]) + np.testing.assert_allclose(reg.e_pred[0],ep,RTOL) + pe = np.array([ 52.16052155]) + np.testing.assert_allclose(reg.predy_e[0],pe,RTOL) + predy = np.array([ 54.81544267]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 4 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0], x, RTOL) - yend = np.array([35.4585005]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([18.594, 24.7142675]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598, 35.4585005]) - np.testing.assert_allclose(reg.z[0], z, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0],x,RTOL) + yend = np.array([ 35.4585005]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 18.594 , 24.7142675]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598 , 35.4585005]) + np.testing.assert_allclose(reg.z[0],z,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [ - 4.86218274e02, - -2.77268729e00, - -1.59987770e00, - -1.01969471e01, - 2.74302006e00, - ], - [ - -2.77268729e00, - 1.04680972e-01, - 2.51172238e-02, - 1.95136385e-03, - 3.70052723e-03, - ], - [ - -1.59987770e00, - 2.51172238e-02, - 2.15655720e-02, - 7.65868344e-03, - -7.30173070e-03, - ], - [ - -1.01969471e01, - 1.95136385e-03, - 7.65868344e-03, - 2.78273684e-01, - -6.89402590e-02, - ], - [ - 2.74302006e00, - 3.70052723e-03, - -7.30173070e-03, - -6.89402590e-02, - 7.12034037e-02, - ], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 4.86218274e+02, -2.77268729e+00, -1.59987770e+00, + -1.01969471e+01, 2.74302006e+00], + [ -2.77268729e+00, 1.04680972e-01, 2.51172238e-02, + 1.95136385e-03, 3.70052723e-03], + [ -1.59987770e+00, 2.51172238e-02, 2.15655720e-02, + 7.65868344e-03, -7.30173070e-03], + [ -1.01969471e+01, 1.95136385e-03, 7.65868344e-03, + 2.78273684e-01, -6.89402590e-02], + [ 2.74302006e+00, 3.70052723e-03, -7.30173070e-03, + -6.89402590e-02, 7.12034037e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL*10) pr2 = 0.3001582877472412 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) + np.testing.assert_allclose(reg.pr2,pr2,RTOL) pr2_e = 0.35613102283621967 - np.testing.assert_allclose(reg.pr2_e, pr2_e, RTOL) - std_err = np.array( - [22.05035768, 0.32354439, 0.14685221, 0.52751653, 0.26683966] - ) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - z_stat = np.array( - [ - (2.6202684885795335, 0.00878605635338265), - (2.2573385444145524, 0.023986928627746887), - (-4.0351698589183433, 5.456281036278686e-05), - (-0.42277935292121521, 0.67245625315942159), - (2.1225002455741895, 0.033795752094112265), - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - hth = np.array( - [ - [ - 4.90000000e01, - 7.04371999e02, - 1.72131237e03, - 7.24743592e02, - 1.70735413e03, - ], - [ - 7.04371999e02, - 1.16866734e04, - 2.15575320e04, - 1.10925200e04, - 2.23848036e04, - ], - [ - 1.72131237e03, - 2.15575320e04, - 7.39058986e04, - 2.34796298e04, - 6.70145378e04, - ], - [ - 7.24743592e02, - 1.10925200e04, - 2.34796298e04, - 1.16146226e04, - 2.30304624e04, - ], - [ - 1.70735413e03, - 2.23848036e04, - 6.70145378e04, - 2.30304624e04, - 6.69879858e04, - ], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - + np.testing.assert_allclose(reg.pr2_e,pr2_e,RTOL) + std_err = np.array([ 22.05035768, 0.32354439, 0.14685221, 0.52751653, 0.26683966]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + z_stat = np.array([(2.6202684885795335, 0.00878605635338265), (2.2573385444145524, 0.023986928627746887), (-4.0351698589183433, 5.456281036278686e-05), (-0.42277935292121521, 0.67245625315942159), (2.1225002455741895, 0.033795752094112265)]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + hth = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03, + 7.24743592e+02, 1.70735413e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04, + 1.10925200e+04, 2.23848036e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04, + 2.34796298e+04, 6.70145378e+04], + [ 7.24743592e+02, 1.10925200e+04, 2.34796298e+04, + 1.16146226e+04, 2.30304624e+04], + [ 1.70735413e+03, 2.23848036e+04, 6.70145378e+04, + 2.30304624e+04, 6.69879858e+04]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/spreg/tests/test_error_sp_het_regimes.py b/spreg/tests/test_error_sp_het_regimes.py index d9070a7e..8606fe8b 100644 --- a/spreg/tests/test_error_sp_het_regimes.py +++ b/spreg/tests/test_error_sp_het_regimes.py @@ -5,13 +5,12 @@ from spreg.error_sp_het import GM_Error_Het, GM_Endog_Error_Het, GM_Combo_Het from libpysal.common import RTOL - class TestGM_Error_Het_Regimes(unittest.TestCase): def setUp(self): - # Columbus: - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + #Columbus: + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("CRIME")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("HOVAL")) X.append(db.by_col("INC")) @@ -25,474 +24,284 @@ def setUp(self): q = [] q.append(db.by_col("DISCBD")) self.q = np.array(q).T - self.w = libpysal.weights.Queen.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" - self.r_var = "NSA" + self.w = libpysal.weights.Queen.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' + self.r_var = 'NSA' self.regimes = db.by_col(self.r_var) - # Artficial: + #Artficial: n = 256 - self.n2 = n / 2 - self.x_a1 = np.random.uniform(-10, 10, (n, 1)) - self.x_a2 = np.random.uniform(1, 5, (n, 1)) - self.q_a = self.x_a2 + np.random.normal(0, 1, (n, 1)) - self.x_a = np.hstack((self.x_a1, self.x_a2)) - self.y_a = np.dot( - np.hstack((np.ones((n, 1)), self.x_a)), np.array([[1], [0.5], [2]]) - ) + np.random.normal(0, 1, (n, 1)) + self.n2 = n/2 + self.x_a1 = np.random.uniform(-10,10,(n,1)) + self.x_a2 = np.random.uniform(1,5,(n,1)) + self.q_a = self.x_a2 + np.random.normal(0,1,(n,1)) + self.x_a = np.hstack((self.x_a1,self.x_a2)) + self.y_a = np.dot(np.hstack((np.ones((n,1)),self.x_a)),np.array([[1],[0.5],[2]])) + np.random.normal(0,1,(n,1)) latt = int(np.sqrt(n)) - self.w_a = libpysal.weights.util.lat2W(latt, latt) - self.w_a.transform = "r" - self.regi_a = [0] * (n // 2) + [1] * (n // 2) - self.w_a1 = libpysal.weights.util.lat2W(latt // 2, latt) - self.w_a1.transform = "r" - + self.w_a = libpysal.weights.util.lat2W(latt,latt) + self.w_a.transform='r' + self.regi_a = [0]*(n//2) + [1]*(n//2) + self.w_a1 = libpysal.weights.util.lat2W(latt//2,latt) + self.w_a1.transform='r' + def test_model(self): reg = SP.GM_Error_Het_Regimes(self.y, self.X, self.regimes, self.w) - betas = np.array( - [ - [62.95986466], - [-0.15660795], - [-1.49054832], - [60.98577615], - [-0.3358993], - [-0.82129289], - [0.54662719], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) + betas = np.array([[ 62.95986466], + [ -0.15660795], + [ -1.49054832], + [ 60.98577615], + [ -0.3358993 ], + [ -0.82129289], + [ 0.54662719]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) u = np.array([-2.19031456]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([17.91629456]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([ 17.91629456]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n, RTOL) + np.testing.assert_allclose(reg.n,n,RTOL) k = 6 - np.testing.assert_allclose(reg.k, k, RTOL) - y = np.array([15.72598]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([[0.0, 0.0, 0.0, 1.0, 80.467003, 19.531]]) - np.testing.assert_allclose(reg.x[0].toarray(), x, RTOL) - e = np.array([2.77847355]) - np.testing.assert_allclose(reg.e_filtered[0], e, RTOL) + np.testing.assert_allclose(reg.k,k,RTOL) + y = np.array([ 15.72598]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([[ 0. , 0. , 0. , 1. , 80.467003, 19.531 ]]) + np.testing.assert_allclose(reg.x[0].toarray(),x,RTOL) + e = np.array([ 2.77847355]) + np.testing.assert_allclose(reg.e_filtered[0],e,RTOL) my = 35.128823897959187 - np.testing.assert_allclose(reg.mean_y, my, RTOL) + np.testing.assert_allclose(reg.mean_y,my, RTOL) sy = 16.732092091229699 - np.testing.assert_allclose(reg.std_y, sy, RTOL) - vm = np.array( - [ - 3.86154100e01, - -2.51553730e-01, - -8.20138673e-01, - 1.71714184e00, - -1.94929113e-02, - 1.23118051e-01, - 0.00000000e00, - ] - ) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) + np.testing.assert_allclose(reg.std_y,sy, RTOL) + vm = np.array([ 3.86154100e+01, -2.51553730e-01, -8.20138673e-01, + 1.71714184e+00, -1.94929113e-02, 1.23118051e-01, + 0.00000000e+00]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL*10) pr2 = 0.5515791216043385 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) - std_err = np.array( - [ - 6.21412987, - 0.15340022, - 0.44060473, - 7.6032169, - 0.19353719, - 0.73621596, - 0.13968272, - ] - ) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - chow_r = np.array( - [ - [0.04190799, 0.83779526], - [0.5736724, 0.44880328], - [0.62498575, 0.42920056], - ] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) + np.testing.assert_allclose(reg.pr2,pr2, RTOL) + std_err = np.array([ 6.21412987, 0.15340022, 0.44060473, 7.6032169 , 0.19353719, + 0.73621596, 0.13968272]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + chow_r = np.array([[ 0.04190799, 0.83779526], + [ 0.5736724 , 0.44880328], + [ 0.62498575, 0.42920056]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) chow_j = 0.72341901308525713 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) + np.testing.assert_allclose(reg.chow.joint[0],chow_j, RTOL) def test_model_regi_error(self): - # Columbus: - reg = SP.GM_Error_Het_Regimes( - self.y, self.X, self.regimes, self.w, regime_err_sep=True - ) - betas = np.array( - [ - [60.74090229], - [-0.17492294], - [-1.33383387], - [0.68303064], - [66.30374279], - [-0.31841139], - [-1.27502813], - [0.11515312], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - vm = np.array([44.9411672, -0.34343354, -0.39946055, 0.0, 0.0, 0.0, 0.0, 0.0]) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) + #Columbus: + reg = SP.GM_Error_Het_Regimes(self.y, self.X, self.regimes, self.w, regime_err_sep=True) + betas = np.array([[ 60.74090229], + [ -0.17492294], + [ -1.33383387], + [ 0.68303064], + [ 66.30374279], + [ -0.31841139], + [ -1.27502813], + [ 0.11515312]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + vm = np.array([ 44.9411672 , -0.34343354, -0.39946055, 0. , + 0. , 0. , 0. , 0. ]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL) u = np.array([-0.05357818]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([15.77955818]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) - e = np.array([0.70542044]) - np.testing.assert_allclose(reg.e_filtered[0], e, RTOL) - chow_r = np.array( - [ - [3.11061225e-01, 5.77029704e-01], - [3.39747489e-01, 5.59975012e-01], - [3.86371771e-03, 9.50436364e-01], - [4.02884201e00, 4.47286322e-02], - ] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([ 15.77955818]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) + e = np.array([ 0.70542044]) + np.testing.assert_allclose(reg.e_filtered[0],e,RTOL) + chow_r = np.array([[ 3.11061225e-01, 5.77029704e-01], + [ 3.39747489e-01, 5.59975012e-01], + [ 3.86371771e-03, 9.50436364e-01], + [ 4.02884201e+00, 4.47286322e-02]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) chow_j = 4.7467070503995412 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) - # Artficial: - model = SP.GM_Error_Het_Regimes( - self.y_a, self.x_a, self.regi_a, w=self.w_a, regime_err_sep=True - ) - model1 = GM_Error_Het( - self.y_a[0 : int(self.n2)].reshape(int(self.n2), 1), - self.x_a[0 : int(self.n2)], - w=self.w_a1, - ) - model2 = GM_Error_Het( - self.y_a[int(self.n2) :].reshape(int(self.n2), 1), - self.x_a[int(self.n2) :], - w=self.w_a1, - ) + np.testing.assert_allclose(reg.chow.joint[0],chow_j, RTOL) + #Artficial: + model = SP.GM_Error_Het_Regimes(self.y_a, self.x_a, self.regi_a, w=self.w_a, regime_err_sep=True) + model1 = GM_Error_Het(self.y_a[0:int(self.n2)].reshape(int(self.n2),1), self.x_a[0:int(self.n2)], w=self.w_a1) + model2 = GM_Error_Het(self.y_a[int(self.n2):].reshape(int(self.n2),1), self.x_a[int(self.n2):], w=self.w_a1) tbetas = np.vstack((model1.betas, model2.betas)) - np.testing.assert_allclose(model.betas, tbetas, RTOL) - vm = np.hstack((model1.vm.diagonal(), model2.vm.diagonal())) + np.testing.assert_allclose(model.betas,tbetas, RTOL) + vm = np.hstack((model1.vm.diagonal(),model2.vm.diagonal())) np.testing.assert_allclose(model.vm.diagonal(), vm, RTOL) def test_model_endog(self): - reg = SP.GM_Endog_Error_Het_Regimes( - self.y, self.X2, self.yd, self.q, self.regimes, self.w - ) - betas = np.array( - [ - [77.26679984], - [4.45992905], - [78.59534391], - [0.41432319], - [-3.20196286], - [-1.13672283], - [0.2174965], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([20.50716917]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - e = np.array([25.13517175]) - np.testing.assert_allclose(reg.e_filtered[0], e, RTOL) + reg = SP.GM_Endog_Error_Het_Regimes(self.y, self.X2, self.yd, self.q, self.regimes, self.w) + betas = np.array([[ 77.26679984], + [ 4.45992905], + [ 78.59534391], + [ 0.41432319], + [ -3.20196286], + [ -1.13672283], + [ 0.2174965 ]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 20.50716917]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + e = np.array([ 25.13517175]) + np.testing.assert_allclose(reg.e_filtered[0],e,RTOL) predy = np.array([-4.78118917]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n, RTOL) + np.testing.assert_allclose(reg.n,n, RTOL) k = 6 - np.testing.assert_allclose(reg.k, k, RTOL) - y = np.array([15.72598]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([[0.0, 0.0, 1.0, 19.531]]) - np.testing.assert_allclose(reg.x[0].toarray(), x, RTOL) - yend = np.array([[0.0, 80.467003]]) - np.testing.assert_allclose(reg.yend[0].toarray(), yend, RTOL) - z = np.array([[0.0, 0.0, 1.0, 19.531, 0.0, 80.467003]]) - np.testing.assert_allclose(reg.z[0].toarray(), z, RTOL) + np.testing.assert_allclose(reg.k,k, RTOL) + y = np.array([ 15.72598]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([[ 0. , 0. , 1. , 19.531]]) + np.testing.assert_allclose(reg.x[0].toarray(),x,RTOL) + yend = np.array([[ 0. , 80.467003]]) + np.testing.assert_allclose(reg.yend[0].toarray(),yend,RTOL) + z = np.array([[ 0. , 0. , 1. , 19.531 , 0. , + 80.467003]]) + np.testing.assert_allclose(reg.z[0].toarray(),z,RTOL) my = 35.128823897959187 - np.testing.assert_allclose(reg.mean_y, my, RTOL) + np.testing.assert_allclose(reg.mean_y,my, RTOL) sy = 16.732092091229699 - np.testing.assert_allclose(reg.std_y, sy, RTOL) - vm = np.array( - [ - 509.66122149, - 150.5845341, - 9.64413821, - 5.54782831, - -80.95846045, - -2.25308524, - -3.2045214, - ] - ) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) + np.testing.assert_allclose(reg.std_y,sy, RTOL) + vm = np.array([ 509.66122149, 150.5845341 , 9.64413821, 5.54782831, + -80.95846045, -2.25308524, -3.2045214 ]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL) pr2 = 0.19776512679331681 - np.testing.assert_allclose(reg.pr2, pr2) - std_err = np.array( - [ - 22.57567765, - 11.34616946, - 17.43881791, - 1.30953812, - 5.4830829, - 0.74634612, - 0.29973079, - ] - ) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - chow_r = np.array( - [[0.0022216, 0.96240654], [0.13127347, 0.7171153], [0.14367307, 0.70465645]] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) + np.testing.assert_allclose(reg.pr2,pr2) + std_err = np.array([ 22.57567765, 11.34616946, 17.43881791, 1.30953812, + 5.4830829 , 0.74634612, 0.29973079]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + chow_r = np.array([[ 0.0022216 , 0.96240654], + [ 0.13127347, 0.7171153 ], + [ 0.14367307, 0.70465645]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) chow_j = 1.2329971019087163 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) + np.testing.assert_allclose(reg.chow.joint[0],chow_j, RTOL) def test_model_endog_regi_error(self): - # Columbus: - reg = SP.GM_Endog_Error_Het_Regimes( - self.y, self.X2, self.yd, self.q, self.regimes, self.w, regime_err_sep=True - ) - betas = np.array( - [ - [7.92747424e01], - [5.78086230e00], - [-3.83173581e00], - [2.23210962e-01], - [8.26255251e01], - [5.48294187e-01], - [-1.28432891e00], - [3.57661629e-02], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - vm = np.array( - [ - 7.55988579e02, - 2.53659722e02, - -1.34288316e02, - -2.66141766e-01, - 0.00000000e00, - 0.00000000e00, - 0.00000000e00, - 0.00000000e00, - ] - ) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) - u = np.array([25.73781918]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([-10.01183918]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) - e = np.array([26.5449135]) - np.testing.assert_allclose(reg.e_filtered[0], e, RTOL) - chow_r = np.array( - [ - [0.00998573, 0.92040097], - [0.12660165, 0.72198192], - [0.12737281, 0.72117171], - [0.43507956, 0.50950696], - ] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) - chow_j = 1.3756768204399892 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) - # Artficial: - model = SP.GM_Endog_Error_Het_Regimes( - self.y_a, - self.x_a1, - yend=self.x_a2, - q=self.q_a, - regimes=self.regi_a, - w=self.w_a, - regime_err_sep=True, - ) - model1 = GM_Endog_Error_Het( - self.y_a[0 : int(self.n2)].reshape(int(self.n2), 1), - self.x_a1[0 : int(self.n2)], - yend=self.x_a2[0 : int(self.n2)], - q=self.q_a[0 : int(self.n2)], - w=self.w_a1, - ) - model2 = GM_Endog_Error_Het( - self.y_a[int(self.n2) :].reshape(int(self.n2), 1), - self.x_a1[int(self.n2) :], - yend=self.x_a2[int(self.n2) :], - q=self.q_a[int(self.n2) :], - w=self.w_a1, - ) + #Columbus: + reg = SP.GM_Endog_Error_Het_Regimes(self.y, self.X2, self.yd, self.q, self.regimes, self.w, regime_err_sep=True) + betas = np.array([[70.45311952], + [ 4.3685181 ], + [-0.9 ], + [ 0.89261347], + [78.43187245], + [ 0.95437565], + [-0.9 ], + [ 0.73629337]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + vm = np.array([ 1.210078e+03, 1.559293e+02, -7.540641e+01, 1.141481e+00, + 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL) + u = np.array([-8.925501]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([24.651481]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) + e = np.array([20.195355]) + np.testing.assert_allclose(reg.e_filtered[0],e,RTOL) + chow_r = np.array([[0.041109, 0.839328], + [0.102719, 0.748591], + [0. , 1. ], + [0.311214, 0.576936]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) + chow_j = 2.621305 + np.testing.assert_allclose(reg.chow.joint[0],chow_j, RTOL) + #Artficial: + model = SP.GM_Endog_Error_Het_Regimes(self.y_a, self.x_a1, yend=self.x_a2, q=self.q_a, regimes=self.regi_a, w=self.w_a, regime_err_sep=True) + model1 = GM_Endog_Error_Het(self.y_a[0:int(self.n2)].reshape(int(self.n2),1), self.x_a1[0:int(self.n2)], yend=self.x_a2[0:int(self.n2)], q=self.q_a[0:int(self.n2)], w=self.w_a1) + model2 = GM_Endog_Error_Het(self.y_a[int(self.n2):].reshape(int(self.n2),1), self.x_a1[int(self.n2):], yend=self.x_a2[int(self.n2):], q=self.q_a[int(self.n2):], w=self.w_a1) tbetas = np.vstack((model1.betas, model2.betas)) - np.testing.assert_allclose(model.betas, tbetas, RTOL) - vm = np.hstack((model1.vm.diagonal(), model2.vm.diagonal())) + np.testing.assert_allclose(model.betas,tbetas, RTOL) + vm = np.hstack((model1.vm.diagonal(),model2.vm.diagonal())) np.testing.assert_allclose(model.vm.diagonal(), vm, RTOL) def test_model_combo(self): - reg = SP.GM_Combo_Het_Regimes( - self.y, self.X2, self.regimes, self.yd, self.q, w=self.w - ) - betas = np.array( - [ - [3.69372678e01], - [-8.29474998e-01], - [3.08667517e01], - [-7.23753444e-01], - [-3.01900940e-01], - [-2.21328949e-01], - [6.41902155e-01], - [-2.45714919e-02], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([0.94039246]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - e_filtered = np.array([0.8737864]) - np.testing.assert_allclose(reg.e_filtered[0], e_filtered, RTOL) - predy_e = np.array([18.68732105]) - np.testing.assert_allclose(reg.predy_e[0], predy_e, RTOL) - predy = np.array([14.78558754]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = SP.GM_Combo_Het_Regimes(self.y, self.X2, self.regimes, self.yd, self.q, w=self.w) + betas = np.array([[ 3.69372678e+01], + [ -8.29474998e-01], + [ 3.08667517e+01], + [ -7.23753444e-01], + [ -3.01900940e-01], + [ -2.21328949e-01], + [ 6.41902155e-01], + [ -2.45714919e-02]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 0.94039246]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + e_filtered = np.array([ 0.8737864]) + np.testing.assert_allclose(reg.e_filtered[0],e_filtered,RTOL) + predy_e = np.array([ 18.68732105]) + np.testing.assert_allclose(reg.predy_e[0],predy_e,RTOL) + predy = np.array([ 14.78558754]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n, RTOL) + np.testing.assert_allclose(reg.n,n, RTOL) k = 7 - np.testing.assert_allclose(reg.k, k, RTOL) - y = np.array([15.72598]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([[0.0, 0.0, 1.0, 19.531]]) - np.testing.assert_allclose(reg.x[0].toarray(), x, RTOL) - yend = np.array([[0.0, 80.467003, 24.7142675]]) - np.testing.assert_allclose(reg.yend[0].toarray(), yend, RTOL) - z = np.array([[0.0, 0.0, 1.0, 19.531, 0.0, 80.467003, 24.7142675]]) - np.testing.assert_allclose(reg.z[0].toarray(), z, RTOL) + np.testing.assert_allclose(reg.k,k, RTOL) + y = np.array([ 15.72598]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([[ 0. , 0. , 1. , 19.531]]) + np.testing.assert_allclose(reg.x[0].toarray(),x,RTOL) + yend = np.array([[ 0. , 80.467003 , 24.7142675]]) + np.testing.assert_allclose(reg.yend[0].toarray(),yend,RTOL) + z = np.array([[ 0. , 0. , 1. , 19.531 , 0. , + 80.467003 , 24.7142675]]) + np.testing.assert_allclose(reg.z[0].toarray(),z,RTOL) my = 35.128823897959187 - np.testing.assert_allclose(reg.mean_y, my, RTOL) + np.testing.assert_allclose(reg.mean_y,my, RTOL) sy = 16.732092091229699 - np.testing.assert_allclose(reg.std_y, sy, RTOL) - vm = np.array( - [ - 71.26851365, - -0.58278032, - 50.53169815, - -0.74561147, - -0.79510274, - -0.10823496, - -0.98141395, - 1.16575965, - ] - ) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) + np.testing.assert_allclose(reg.std_y,sy, RTOL) + vm = np.array([ 71.26851365, -0.58278032, 50.53169815, -0.74561147, + -0.79510274, -0.10823496, -0.98141395, 1.16575965]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL) pr2 = 0.6504148883602958 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) + np.testing.assert_allclose(reg.pr2,pr2,RTOL) pr2_e = 0.527136896994038 - np.testing.assert_allclose(reg.pr2_e, pr2_e, RTOL) - std_err = np.array( - [ - 8.44206809, - 0.72363219, - 9.85790968, - 0.77218082, - 0.34084146, - 0.21752916, - 0.14371614, - 0.39226478, - ] - ) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - chow_r = np.array( - [ - [0.54688708, 0.45959243], - [0.01035136, 0.91896175], - [0.03981108, 0.84185042], - ] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) + np.testing.assert_allclose(reg.pr2_e,pr2_e,RTOL) + std_err = np.array([ 8.44206809, 0.72363219, 9.85790968, 0.77218082, 0.34084146, + 0.21752916, 0.14371614, 0.39226478]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + chow_r = np.array([[ 0.54688708, 0.45959243], + [ 0.01035136, 0.91896175], + [ 0.03981108, 0.84185042]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) chow_j = 0.78070369988354349 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) + np.testing.assert_allclose(reg.chow.joint[0],chow_j,RTOL) def test_model_combo_regi_error(self): - # Columbus: - reg = SP.GM_Combo_Het_Regimes( - self.y, - self.X2, - self.regimes, - self.yd, - self.q, - w=self.w, - regime_lag_sep=True, - regime_err_sep=True, - ) - betas = np.array( - [ - [42.01151458], - [-0.13917151], - [-0.65300184], - [0.54737064], - [0.2629229], - [34.21569751], - [-0.15236089], - [-0.49175217], - [0.65733173], - [-0.07713581], - ] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - vm = np.array( - [ - 77.49519689, - 0.57226879, - -1.18856422, - -1.28088712, - 0.866752, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - ] - ) - np.testing.assert_allclose(reg.vm[0], vm, RTOL) - u = np.array([7.81039418]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([7.91558582]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) - e = np.array([7.22996911]) - np.testing.assert_allclose(reg.e_filtered[0], e, RTOL) - chow_r = np.array( - [ - [1.90869079e-01, 6.62194273e-01], - [4.56118982e-05, 9.94611401e-01], - [3.12104263e-02, 8.59771748e-01], - [1.56368204e-01, 6.92522476e-01], - [7.52928732e-01, 3.85550558e-01], - ] - ) - np.testing.assert_allclose(reg.chow.regi, chow_r, RTOL) + #Columbus: + reg = SP.GM_Combo_Het_Regimes(self.y, self.X2, self.regimes, self.yd, self.q, w=self.w, regime_lag_sep=True, regime_err_sep=True) + betas = np.array([[ 42.01151458], + [ -0.13917151], + [ -0.65300184], + [ 0.54737064], + [ 0.2629229 ], + [ 34.21569751], + [ -0.15236089], + [ -0.49175217], + [ 0.65733173], + [ -0.07713581]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + vm = np.array([ 77.49519689, 0.57226879, -1.18856422, -1.28088712, + 0.866752 , 0. , 0. , 0. , + 0. , 0. ]) + np.testing.assert_allclose(reg.vm[0],vm,RTOL) + u = np.array([ 7.81039418]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([ 7.91558582]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) + e = np.array([ 7.22996911]) + np.testing.assert_allclose(reg.e_filtered[0],e,RTOL) + chow_r = np.array([[ 1.90869079e-01, 6.62194273e-01], + [ 4.56118982e-05, 9.94611401e-01], + [ 3.12104263e-02, 8.59771748e-01], + [ 1.56368204e-01, 6.92522476e-01], + [ 7.52928732e-01, 3.85550558e-01]]) + np.testing.assert_allclose(reg.chow.regi,chow_r,RTOL) chow_j = 1.1316136604755913 - np.testing.assert_allclose(reg.chow.joint[0], chow_j, RTOL) - # Artficial: - model = SP.GM_Combo_Het_Regimes( - self.y_a, - self.x_a1, - yend=self.x_a2, - q=self.q_a, - regimes=self.regi_a, - w=self.w_a, - regime_err_sep=True, - regime_lag_sep=True, - ) - model1 = GM_Combo_Het( - self.y_a[0 : int(self.n2)].reshape(int(self.n2), 1), - self.x_a1[0 : int(self.n2)], - yend=self.x_a2[0 : int(self.n2)], - q=self.q_a[0 : int(self.n2)], - w=self.w_a1, - ) - model2 = GM_Combo_Het( - self.y_a[int(self.n2) :].reshape(int(self.n2), 1), - self.x_a1[int(self.n2) :], - yend=self.x_a2[int(self.n2) :], - q=self.q_a[int(self.n2) :], - w=self.w_a1, - ) + np.testing.assert_allclose(reg.chow.joint[0],chow_j,RTOL) + #Artficial: + model = SP.GM_Combo_Het_Regimes(self.y_a, self.x_a1, yend=self.x_a2, q=self.q_a, regimes=self.regi_a, w=self.w_a, regime_err_sep=True, regime_lag_sep=True) + model1 = GM_Combo_Het(self.y_a[0:int(self.n2)].reshape(int(self.n2),1), self.x_a1[0:int(self.n2)], yend=self.x_a2[0:int(self.n2)], q=self.q_a[0:int(self.n2)], w=self.w_a1) + model2 = GM_Combo_Het(self.y_a[int(self.n2):].reshape(int(self.n2),1), self.x_a1[int(self.n2):], yend=self.x_a2[int(self.n2):], q=self.q_a[int(self.n2):], w=self.w_a1) tbetas = np.vstack((model1.betas, model2.betas)) - np.testing.assert_allclose(model.betas, tbetas, RTOL) - vm = np.hstack((model1.vm.diagonal(), model2.vm.diagonal())) - # was this supposed to get tested? - + np.testing.assert_allclose(model.betas,tbetas,RTOL) + vm = np.hstack((model1.vm.diagonal(),model2.vm.diagonal())) + #was this supposed to get tested? -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/spreg/tests/test_error_sp_het_sparse.py b/spreg/tests/test_error_sp_het_sparse.py index 16b30328..2890d454 100644 --- a/spreg/tests/test_error_sp_het_sparse.py +++ b/spreg/tests/test_error_sp_het_sparse.py @@ -6,150 +6,131 @@ from libpysal.common import RTOL import spreg - class TestBaseGMErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.X = np.hstack((np.ones(self.y.shape), self.X)) + self.X = np.hstack((np.ones(self.y.shape),self.X)) self.X = sparse.csr_matrix(self.X) - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): reg = HET.BaseGM_Error_Het(self.y, self.X, self.w.sparse, step1c=True) - betas = np.array([[47.99626638], [0.71048989], [-0.55876126], [0.41178776]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([27.38122697]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([32.29765975]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.08577603]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 47.99626638], [ 0.71048989], [ -0.55876126], [ 0.41178776]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 27.38122697]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 32.29765975]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.08577603]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [1.31767529e02, -3.58368748e00, -1.65090647e00, 0.00000000e00], - [-3.58368748e00, 1.35513711e-01, 3.77539055e-02, 0.00000000e00], - [-1.65090647e00, 3.77539055e-02, 2.61042702e-02, 0.00000000e00], - [0.00000000e00, 0.00000000e00, 0.00000000e00, 2.82398517e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - xtx = np.array( - [ - [4.90000000e01, 7.04371999e02, 1.72131237e03], - [7.04371999e02, 1.16866734e04, 2.15575320e04], - [1.72131237e03, 2.15575320e04, 7.39058986e04], - ] - ) - np.testing.assert_allclose(reg.xtx, xtx, RTOL) - - + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 1.31767529e+02, -3.58368748e+00, -1.65090647e+00, + 0.00000000e+00], + [ -3.58368748e+00, 1.35513711e-01, 3.77539055e-02, + 0.00000000e+00], + [ -1.65090647e+00, 3.77539055e-02, 2.61042702e-02, + 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 2.82398517e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) + xtx = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04]]) + np.testing.assert_allclose(reg.xtx,xtx,RTOL) + class TestGMErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T self.X = sparse.csr_matrix(self.X) - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): reg = HET.GM_Error_Het(self.y, self.X, self.w, step1c=True) - betas = np.array([[47.99626638], [0.71048989], [-0.55876126], [0.41178776]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([27.38122697]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([32.29765975]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.08577603]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 47.99626638], [ 0.71048989], [ -0.55876126], [ 0.41178776]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 27.38122697]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 32.29765975]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.08577603]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [1.31767529e02, -3.58368748e00, -1.65090647e00, 0.00000000e00], - [-3.58368748e00, 1.35513711e-01, 3.77539055e-02, 0.00000000e00], - [-1.65090647e00, 3.77539055e-02, 2.61042702e-02, 0.00000000e00], - [0.00000000e00, 0.00000000e00, 0.00000000e00, 2.82398517e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 1.31767529e+02, -3.58368748e+00, -1.65090647e+00, + 0.00000000e+00], + [ -3.58368748e+00, 1.35513711e-01, 3.77539055e-02, + 0.00000000e+00], + [ -1.65090647e+00, 3.77539055e-02, 2.61042702e-02, + 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, + 2.82398517e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) pr2 = 0.34951013222581306 - np.testing.assert_allclose(reg.pr2, pr2) - stde = np.array([11.47900385, 0.36812187, 0.16156816, 0.16804717]) - np.testing.assert_allclose(reg.std_err, stde, RTOL) - z_stat = np.array( - [ - [4.18122226e00, 2.89946274e-05], - [1.93003988e00, 5.36018970e-02], - [-3.45836247e00, 5.43469673e-04], - [2.45042960e00, 1.42685863e-02], - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - xtx = np.array( - [ - [4.90000000e01, 7.04371999e02, 1.72131237e03], - [7.04371999e02, 1.16866734e04, 2.15575320e04], - [1.72131237e03, 2.15575320e04, 7.39058986e04], - ] - ) - np.testing.assert_allclose(reg.xtx, xtx, RTOL) - + np.testing.assert_allclose(reg.pr2,pr2) + stde = np.array([ 11.47900385, 0.36812187, 0.16156816, 0.16804717]) + np.testing.assert_allclose(reg.std_err,stde,RTOL) + z_stat = np.array([[ 4.18122226e+00, 2.89946274e-05], + [ 1.93003988e+00, 5.36018970e-02], + [ -3.45836247e+00, 5.43469673e-04], + [ 2.45042960e+00, 1.42685863e-02]]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + xtx = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04]]) + np.testing.assert_allclose(reg.xtx,xtx,RTOL) class TestBaseGMEndogErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) self.X = np.array(X).T - self.X = np.hstack((np.ones(self.y.shape), self.X)) + self.X = np.hstack((np.ones(self.y.shape),self.X)) self.X = sparse.csr_matrix(self.X) yd = [] yd.append(db.by_col("CRIME")) @@ -157,71 +138,62 @@ def setUp(self): q = [] q.append(db.by_col("DISCBD")) self.q = np.array(q).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): - reg = HET.BaseGM_Endog_Error_Het( - self.y, self.X, self.yd, self.q, self.w.sparse, step1c=True - ) - betas = np.array([[55.39707924], [0.46563046], [-0.67038326], [0.41135023]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([26.51812895]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.46604707]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([53.94887405]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = HET.BaseGM_Endog_Error_Het(self.y, self.X, self.yd, self.q, self.w.sparse, step1c=True) + betas = np.array([[ 55.39707924], [ 0.46563046], [ -0.67038326], [ 0.41135023]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 26.51812895]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.46604707]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 53.94887405]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - yend = np.array([15.72598]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([5.03]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.z[0].toarray()[0], z, RTOL) - h = np.array([1.0, 19.531, 5.03]) - np.testing.assert_allclose(reg.h[0].toarray()[0], h, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + yend = np.array([ 15.72598]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 5.03]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.z[0].toarray()[0],z,RTOL) + h = np.array([ 1. , 19.531, 5.03 ]) + np.testing.assert_allclose(reg.h[0].toarray()[0],h,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [8.34637805e02, -2.16932259e01, -1.33327894e01, 1.65840848e00], - [-2.16932259e01, 5.97683070e-01, 3.39503523e-01, -3.90111107e-02], - [-1.33327894e01, 3.39503523e-01, 2.19008080e-01, -2.81929695e-02], - [1.65840848e00, -3.90111107e-02, -2.81929695e-02, 3.15686105e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - hth = np.array( - [ - [49.0, 704.371999, 139.75], - [704.371999, 11686.67338121, 2246.12800625], - [139.75, 2246.12800625, 498.5851], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - - + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 8.34637805e+02, -2.16932259e+01, -1.33327894e+01, + 1.65840848e+00], + [ -2.16932259e+01, 5.97683070e-01, 3.39503523e-01, + -3.90111107e-02], + [ -1.33327894e+01, 3.39503523e-01, 2.19008080e-01, + -2.81929695e-02], + [ 1.65840848e+00, -3.90111107e-02, -2.81929695e-02, + 3.15686105e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) + hth = np.array([[ 49. , 704.371999 , 139.75 ], + [ 704.371999 , 11686.67338121, 2246.12800625], + [ 139.75 , 2246.12800625, 498.5851 ]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) + class TestGMEndogErrorHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) self.X = np.array(X).T @@ -232,366 +204,213 @@ def setUp(self): q = [] q.append(db.by_col("DISCBD")) self.q = np.array(q).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): - reg = HET.GM_Endog_Error_Het( - self.y, self.X, self.yd, self.q, self.w, step1c=True - ) - betas = np.array([[55.39707924], [0.46563046], [-0.67038326], [0.41135023]]) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([26.51812895]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - predy = np.array([53.94887405]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = HET.GM_Endog_Error_Het(self.y, self.X, self.yd, self.q, self.w, step1c=True) + betas = np.array([[ 55.39707924], [ 0.46563046], [ -0.67038326], [ 0.41135023]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 26.51812895]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + predy = np.array([ 53.94887405]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 3 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - yend = np.array([15.72598]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([5.03]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.z[0].toarray()[0], z, RTOL) - h = np.array([1.0, 19.531, 5.03]) - np.testing.assert_allclose(reg.h[0].toarray()[0], h, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + yend = np.array([ 15.72598]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 5.03]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.z[0].toarray()[0],z,RTOL) + h = np.array([ 1. , 19.531, 5.03 ]) + np.testing.assert_allclose(reg.h[0].toarray()[0],h,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [8.34637805e02, -2.16932259e01, -1.33327894e01, 1.65840848e00], - [-2.16932259e01, 5.97683070e-01, 3.39503523e-01, -3.90111107e-02], - [-1.33327894e01, 3.39503523e-01, 2.19008080e-01, -2.81929695e-02], - [1.65840848e00, -3.90111107e-02, -2.81929695e-02, 3.15686105e-02], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 8.34637805e+02, -2.16932259e+01, -1.33327894e+01, + 1.65840848e+00], + [ -2.16932259e+01, 5.97683070e-01, 3.39503523e-01, + -3.90111107e-02], + [ -1.33327894e+01, 3.39503523e-01, 2.19008080e-01, + -2.81929695e-02], + [ 1.65840848e+00, -3.90111107e-02, -2.81929695e-02, + 3.15686105e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL) pr2 = 0.34648011338954804 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) - std_err = np.array([28.89009873, 0.77309965, 0.46798299, 0.17767558]) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - z_stat = np.array( - [ - (1.9175109006819244, 0.055173057472126787), - (0.60229035155742305, 0.54698088217644414), - (-1.4324949211864271, 0.15200223057569454), - (2.3151759776869496, 0.020603303355572443), - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - hth = np.array( - [ - [49.0, 704.371999, 139.75], - [704.371999, 11686.67338121, 2246.12800625], - [139.75, 2246.12800625, 498.5851], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - - + np.testing.assert_allclose(reg.pr2,pr2,RTOL) + std_err = np.array([ 28.89009873, 0.77309965, 0.46798299, + 0.17767558]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + z_stat = np.array([(1.9175109006819244, 0.055173057472126787), (0.60229035155742305, 0.54698088217644414), (-1.4324949211864271, 0.15200223057569454), (2.3151759776869496, 0.020603303355572443)]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + hth = np.array([[ 49. , 704.371999 , 139.75 ], + [ 704.371999 , 11686.67338121, 2246.12800625], + [ 139.75 , 2246.12800625, 498.5851 ]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) + class TestBaseGMComboHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): # Only spatial lag yd2, q2 = spreg.utils.set_endog(self.y, self.X, self.w, None, None, 1, True) - self.X = np.hstack((np.ones(self.y.shape), self.X)) + self.X = np.hstack((np.ones(self.y.shape),self.X)) self.X = sparse.csr_matrix(self.X) - reg = HET.BaseGM_Combo_Het( - self.y, self.X, yend=yd2, q=q2, w=self.w.sparse, step1c=True - ) - betas = np.array( - [[57.7778574], [0.73034922], [-0.59257362], [-0.2230231], [0.56636724]] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([25.65156033]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.87664403]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - predy = np.array([54.81544267]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + reg = HET.BaseGM_Combo_Het(self.y, self.X, yend=yd2, q=q2, w=self.w.sparse, step1c=True) + betas = np.array([[ 57.7778574 ], [ 0.73034922], [ -0.59257362], [ -0.2230231 ], [ 0.56636724]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 25.65156033]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.87664403]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + predy = np.array([ 54.81544267]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 4 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - yend = np.array([35.4585005]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([18.594, 24.7142675]) - np.testing.assert_allclose(reg.q[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598, 35.4585005]) - np.testing.assert_allclose(reg.z[0].toarray()[0], z, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + yend = np.array([ 35.4585005]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 18.594 , 24.7142675]) + np.testing.assert_allclose(reg.q[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598 , 35.4585005]) + np.testing.assert_allclose(reg.z[0].toarray()[0],z,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy, RTOL) - vm = np.array( - [ - [ - 4.86218274e02, - -2.77268729e00, - -1.59987770e00, - -1.01969471e01, - 2.74302006e00, - ], - [ - -2.77268729e00, - 1.04680972e-01, - 2.51172238e-02, - 1.95136385e-03, - 3.70052723e-03, - ], - [ - -1.59987770e00, - 2.51172238e-02, - 2.15655720e-02, - 7.65868344e-03, - -7.30173070e-03, - ], - [ - -1.01969471e01, - 1.95136385e-03, - 7.65868344e-03, - 2.78273684e-01, - -6.89402590e-02, - ], - [ - 2.74302006e00, - 3.70052723e-03, - -7.30173070e-03, - -6.89402590e-02, - 7.12034037e-02, - ], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) - hth = np.array( - [ - [ - 4.90000000e01, - 7.04371999e02, - 1.72131237e03, - 7.24743592e02, - 1.70735413e03, - ], - [ - 7.04371999e02, - 1.16866734e04, - 2.15575320e04, - 1.10925200e04, - 2.23848036e04, - ], - [ - 1.72131237e03, - 2.15575320e04, - 7.39058986e04, - 2.34796298e04, - 6.70145378e04, - ], - [ - 7.24743592e02, - 1.10925200e04, - 2.34796298e04, - 1.16146226e04, - 2.30304624e04, - ], - [ - 1.70735413e03, - 2.23848036e04, - 6.70145378e04, - 2.30304624e04, - 6.69879858e04, - ], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - + np.testing.assert_allclose(reg.std_y,stdy,RTOL) + vm = np.array([[ 4.86218274e+02, -2.77268729e+00, -1.59987770e+00, + -1.01969471e+01, 2.74302006e+00], + [ -2.77268729e+00, 1.04680972e-01, 2.51172238e-02, + 1.95136385e-03, 3.70052723e-03], + [ -1.59987770e+00, 2.51172238e-02, 2.15655720e-02, + 7.65868344e-03, -7.30173070e-03], + [ -1.01969471e+01, 1.95136385e-03, 7.65868344e-03, + 2.78273684e-01, -6.89402590e-02], + [ 2.74302006e+00, 3.70052723e-03, -7.30173070e-03, + -6.89402590e-02, 7.12034037e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL*10) + hth = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03, + 7.24743592e+02, 1.70735413e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04, + 1.10925200e+04, 2.23848036e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04, + 2.34796298e+04, 6.70145378e+04], + [ 7.24743592e+02, 1.10925200e+04, 2.34796298e+04, + 1.16146226e+04, 2.30304624e+04], + [ 1.70735413e+03, 2.23848036e+04, 6.70145378e+04, + 2.30304624e+04, 6.69879858e+04]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) class TestGMComboHet(unittest.TestCase): def setUp(self): - db = libpysal.io.open(libpysal.examples.get_path("columbus.dbf"), "r") + db=libpysal.io.open(libpysal.examples.get_path("columbus.dbf"),"r") y = np.array(db.by_col("HOVAL")) - self.y = np.reshape(y, (49, 1)) + self.y = np.reshape(y, (49,1)) X = [] X.append(db.by_col("INC")) X.append(db.by_col("CRIME")) self.X = np.array(X).T self.X = sparse.csr_matrix(self.X) - self.w = libpysal.weights.Rook.from_shapefile( - libpysal.examples.get_path("columbus.shp") - ) - self.w.transform = "r" + self.w = libpysal.weights.Rook.from_shapefile(libpysal.examples.get_path("columbus.shp")) + self.w.transform = 'r' def test_model(self): # Only spatial lag reg = HET.GM_Combo_Het(self.y, self.X, w=self.w, step1c=True) - betas = np.array( - [[57.7778574], [0.73034922], [-0.59257362], [-0.2230231], [0.56636724]] - ) - np.testing.assert_allclose(reg.betas, betas, RTOL) - u = np.array([25.65156033]) - np.testing.assert_allclose(reg.u[0], u, RTOL) - ef = np.array([31.87664403]) - np.testing.assert_allclose(reg.e_filtered[0], ef, RTOL) - ep = np.array([28.30648145]) - np.testing.assert_allclose(reg.e_pred[0], ep, RTOL) - pe = np.array([52.16052155]) - np.testing.assert_allclose(reg.predy_e[0], pe, RTOL) - predy = np.array([54.81544267]) - np.testing.assert_allclose(reg.predy[0], predy, RTOL) + betas = np.array([[ 57.7778574 ], [ 0.73034922], [ -0.59257362], [ -0.2230231 ], [ 0.56636724]]) + np.testing.assert_allclose(reg.betas,betas,RTOL) + u = np.array([ 25.65156033]) + np.testing.assert_allclose(reg.u[0],u,RTOL) + ef = np.array([ 31.87664403]) + np.testing.assert_allclose(reg.e_filtered[0],ef,RTOL) + ep = np.array([ 28.30648145]) + np.testing.assert_allclose(reg.e_pred[0],ep,RTOL) + pe = np.array([ 52.16052155]) + np.testing.assert_allclose(reg.predy_e[0],pe,RTOL) + predy = np.array([ 54.81544267]) + np.testing.assert_allclose(reg.predy[0],predy,RTOL) n = 49 - np.testing.assert_allclose(reg.n, n) + np.testing.assert_allclose(reg.n,n) k = 4 - np.testing.assert_allclose(reg.k, k) - y = np.array([80.467003]) - np.testing.assert_allclose(reg.y[0], y, RTOL) - x = np.array([1.0, 19.531, 15.72598]) - np.testing.assert_allclose(reg.x[0].toarray()[0], x, RTOL) - yend = np.array([35.4585005]) - np.testing.assert_allclose(reg.yend[0], yend, RTOL) - q = np.array([18.594, 24.7142675]) - np.testing.assert_allclose(reg.q[0].toarray()[0], q, RTOL) - z = np.array([1.0, 19.531, 15.72598, 35.4585005]) - np.testing.assert_allclose(reg.z[0].toarray()[0], z, RTOL) - i_s = "Maximum number of iterations reached." - np.testing.assert_string_equal(reg.iter_stop, i_s) + np.testing.assert_allclose(reg.k,k) + y = np.array([ 80.467003]) + np.testing.assert_allclose(reg.y[0],y,RTOL) + x = np.array([ 1. , 19.531 , 15.72598]) + np.testing.assert_allclose(reg.x[0].toarray()[0],x,RTOL) + yend = np.array([ 35.4585005]) + np.testing.assert_allclose(reg.yend[0],yend,RTOL) + q = np.array([ 18.594 , 24.7142675]) + np.testing.assert_allclose(reg.q[0].toarray()[0],q,RTOL) + z = np.array([ 1. , 19.531 , 15.72598 , 35.4585005]) + np.testing.assert_allclose(reg.z[0].toarray()[0],z,RTOL) + i_s = 'Maximum number of iterations reached.' + np.testing.assert_string_equal(reg.iter_stop,i_s) its = 1 - np.testing.assert_allclose(reg.iteration, its, RTOL) + np.testing.assert_allclose(reg.iteration,its,RTOL) my = 38.436224469387746 - np.testing.assert_allclose(reg.mean_y, my) + np.testing.assert_allclose(reg.mean_y,my) stdy = 18.466069465206047 - np.testing.assert_allclose(reg.std_y, stdy) - vm = np.array( - [ - [ - 4.86218274e02, - -2.77268729e00, - -1.59987770e00, - -1.01969471e01, - 2.74302006e00, - ], - [ - -2.77268729e00, - 1.04680972e-01, - 2.51172238e-02, - 1.95136385e-03, - 3.70052723e-03, - ], - [ - -1.59987770e00, - 2.51172238e-02, - 2.15655720e-02, - 7.65868344e-03, - -7.30173070e-03, - ], - [ - -1.01969471e01, - 1.95136385e-03, - 7.65868344e-03, - 2.78273684e-01, - -6.89402590e-02, - ], - [ - 2.74302006e00, - 3.70052723e-03, - -7.30173070e-03, - -6.89402590e-02, - 7.12034037e-02, - ], - ] - ) - np.testing.assert_allclose(reg.vm, vm, RTOL) + np.testing.assert_allclose(reg.std_y,stdy) + vm = np.array([[ 4.86218274e+02, -2.77268729e+00, -1.59987770e+00, + -1.01969471e+01, 2.74302006e+00], + [ -2.77268729e+00, 1.04680972e-01, 2.51172238e-02, + 1.95136385e-03, 3.70052723e-03], + [ -1.59987770e+00, 2.51172238e-02, 2.15655720e-02, + 7.65868344e-03, -7.30173070e-03], + [ -1.01969471e+01, 1.95136385e-03, 7.65868344e-03, + 2.78273684e-01, -6.89402590e-02], + [ 2.74302006e+00, 3.70052723e-03, -7.30173070e-03, + -6.89402590e-02, 7.12034037e-02]]) + np.testing.assert_allclose(reg.vm,vm,RTOL*10) pr2 = 0.3001582877472412 - np.testing.assert_allclose(reg.pr2, pr2, RTOL) + np.testing.assert_allclose(reg.pr2,pr2,RTOL) pr2_e = 0.35613102283621967 - np.testing.assert_allclose(reg.pr2_e, pr2_e, RTOL) - std_err = np.array( - [22.05035768, 0.32354439, 0.14685221, 0.52751653, 0.26683966] - ) - np.testing.assert_allclose(reg.std_err, std_err, RTOL) - z_stat = np.array( - [ - (2.6202684885795335, 0.00878605635338265), - (2.2573385444145524, 0.023986928627746887), - (-4.0351698589183433, 5.456281036278686e-05), - (-0.42277935292121521, 0.67245625315942159), - (2.1225002455741895, 0.033795752094112265), - ] - ) - np.testing.assert_allclose(reg.z_stat, z_stat, RTOL) - hth = np.array( - [ - [ - 4.90000000e01, - 7.04371999e02, - 1.72131237e03, - 7.24743592e02, - 1.70735413e03, - ], - [ - 7.04371999e02, - 1.16866734e04, - 2.15575320e04, - 1.10925200e04, - 2.23848036e04, - ], - [ - 1.72131237e03, - 2.15575320e04, - 7.39058986e04, - 2.34796298e04, - 6.70145378e04, - ], - [ - 7.24743592e02, - 1.10925200e04, - 2.34796298e04, - 1.16146226e04, - 2.30304624e04, - ], - [ - 1.70735413e03, - 2.23848036e04, - 6.70145378e04, - 2.30304624e04, - 6.69879858e04, - ], - ] - ) - np.testing.assert_allclose(reg.hth, hth, RTOL) - + np.testing.assert_allclose(reg.pr2_e,pr2_e,RTOL) + std_err = np.array([ 22.05035768, 0.32354439, 0.14685221, 0.52751653, 0.26683966]) + np.testing.assert_allclose(reg.std_err,std_err,RTOL) + z_stat = np.array([(2.6202684885795335, 0.00878605635338265), (2.2573385444145524, 0.023986928627746887), (-4.0351698589183433, 5.456281036278686e-05), (-0.42277935292121521, 0.67245625315942159), (2.1225002455741895, 0.033795752094112265)]) + np.testing.assert_allclose(reg.z_stat,z_stat,RTOL) + hth = np.array([[ 4.90000000e+01, 7.04371999e+02, 1.72131237e+03, + 7.24743592e+02, 1.70735413e+03], + [ 7.04371999e+02, 1.16866734e+04, 2.15575320e+04, + 1.10925200e+04, 2.23848036e+04], + [ 1.72131237e+03, 2.15575320e+04, 7.39058986e+04, + 2.34796298e+04, 6.70145378e+04], + [ 7.24743592e+02, 1.10925200e+04, 2.34796298e+04, + 1.16146226e+04, 2.30304624e+04], + [ 1.70735413e+03, 2.23848036e+04, 6.70145378e+04, + 2.30304624e+04, 6.69879858e+04]]) + np.testing.assert_allclose(reg.hth,hth,RTOL) -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() diff --git a/spreg/tests/test_sp_panels.py b/spreg/tests/test_sp_panels.py index b940c5c1..4710d1e8 100755 --- a/spreg/tests/test_sp_panels.py +++ b/spreg/tests/test_sp_panels.py @@ -3,192 +3,87 @@ import libpysal from libpysal.common import RTOL from spreg.sp_panels import * - ATOL = 1e-12 class Test_GM_KKP(unittest.TestCase): def setUp(self): - nat = libpysal.examples.load_example("NCOVR") - self.db = libpysal.io.open(nat.get_path("NAT.dbf"), "r") - self.w = libpysal.weights.Queen.from_shapefile( - libpysal.examples.get_path("NAT.shp") - ) - self.w.transform = "r" - self.y_var0 = ["HR70", "HR80", "HR90"] - self.x_var0 = ["RD70", "RD80", "RD90", "PS70", "PS80", "PS90"] + nat = libpysal.examples.load_example('NCOVR') + self.db = libpysal.io.open(nat.get_path("NAT.dbf"),'r') + self.w = libpysal.weights.Queen.from_shapefile(libpysal.examples.get_path("NAT.shp")) + self.w.transform = 'r' + self.y_var0 = ['HR70','HR80','HR90'] + self.x_var0 = ['RD70','RD80','RD90','PS70','PS80','PS90'] self.y = np.array([self.db.by_col(name) for name in self.y_var0]).T self.x = np.array([self.db.by_col(name) for name in self.x_var0]).T - def test_wide_ident(self): - reg = GM_KKP( - self.y, - self.x, - self.w, - full_weights=False, - name_y=self.y_var0, - name_x=self.x_var0, - ) - np.testing.assert_allclose( - reg.betas, - np.array( - [ - [6.49221562], - [3.62445753], - [1.31187779], - [0.41777589], - [22.81908224], - [39.90993228], - ] - ), - RTOL, - ) - np.testing.assert_allclose( - reg.vm, - np.array( - [ - [1.26948117e-02, -1.98160325e-06, 7.38157674e-05], - [-1.98160325e-06, 7.69961725e-03, 1.13099329e-03], - [7.38157674e-05, 1.13099329e-03, 7.26783636e-03], - ] - ), - RTOL, - ) - np.testing.assert_equal( - reg.name_x, ["CONSTANT", "RD", "PS", "lambda", " sigma2_v", "sigma2_1"] - ) - np.testing.assert_equal(reg.name_y, "HR") - def test_wide_full(self): - reg = GM_KKP(self.y, self.x, self.w, full_weights=True) + def test_wide_ident(self): + reg = GM_KKP(self.y,self.x,self.w,full_weights=False,name_y=self.y_var0, name_x=self.x_var0) + np.testing.assert_allclose(reg.betas,np.array([[ 6.49221562], + [ 3.62445753], + [ 1.31187779], + [ 0.41777589], + [22.81908224], + [39.90993228]]),RTOL) + np.testing.assert_allclose(reg.vm,np.array([[ 1.26948117e-02, -1.98160325e-06, 7.38157674e-05], + [-1.98160325e-06, 7.69961725e-03, 1.13099329e-03], + [ 7.38157674e-05, 1.13099329e-03, 7.26783636e-03]]),RTOL*10) + np.testing.assert_equal(reg.name_x, ['CONSTANT', 'RD', 'PS', 'lambda', ' sigma2_v', 'sigma2_1']) + np.testing.assert_equal(reg.name_y, 'HR') + + def test_wide_full(self): + reg = GM_KKP(self.y,self.x,self.w,full_weights=True) - np.testing.assert_allclose( - reg.betas, - np.array( - [ - [6.49193589], - [3.55740165], - [1.29462748], - [0.4263399], - [22.47241979], - [45.82593532], - ] - ), - RTOL, - ) - np.testing.assert_allclose( - reg.vm, - np.array( - [ - [1.45113773e-02, -2.14882672e-06, 8.54997693e-05], - [-2.14882672e-06, 8.41929187e-03, 1.24553497e-03], - [8.54997693e-05, 1.24553497e-03, 8.12448812e-03], - ] - ), - RTOL, - ) + np.testing.assert_allclose(reg.betas,np.array([[ 6.49193589], + [ 3.55740165], + [ 1.29462748], + [ 0.4263399 ], + [22.47241979], + [45.82593532]]),RTOL) + np.testing.assert_allclose(reg.vm,np.array([[ 1.45113773e-02, -2.14882672e-06, 8.54997693e-05], + [-2.14882672e-06, 8.41929187e-03, 1.24553497e-03], + [ 8.54997693e-05, 1.24553497e-03, 8.12448812e-03]]),RTOL) - def test_long_ident(self): - bigy = self.y.reshape((self.y.size, 1), order="F") - bigx = self.x[:, 0:3].reshape((self.x.shape[0] * 3, 1), order="F") - bigx = np.hstack( - (bigx, self.x[:, 3:6].reshape((self.x.shape[0] * 3, 1), order="F")) - ) - reg = GM_KKP( - bigy, bigx, self.w, full_weights=False, name_y=["HR"], name_x=["RD", "PS"] - ) + def test_long_ident(self): + bigy = self.y.reshape((self.y.size,1),order="F") + bigx = self.x[:,0:3].reshape((self.x.shape[0]*3,1),order='F') + bigx = np.hstack((bigx,self.x[:,3:6].reshape((self.x.shape[0]*3,1),order='F'))) + reg = GM_KKP(bigy,bigx,self.w,full_weights=False,name_y=['HR'], name_x=['RD','PS']) - np.testing.assert_allclose( - reg.betas, - np.array( - [ - [6.49221562], - [3.62445753], - [1.31187779], - [0.41777589], - [22.81908224], - [39.90993228], - ] - ), - RTOL, - ) - np.testing.assert_allclose( - reg.vm, - np.array( - [ - [1.26948117e-02, -1.98160325e-06, 7.38157674e-05], - [-1.98160325e-06, 7.69961725e-03, 1.13099329e-03], - [7.38157674e-05, 1.13099329e-03, 7.26783636e-03], - ] - ), - RTOL, - ) - np.testing.assert_equal( - reg.name_x, ["CONSTANT", "RD", "PS", "lambda", " sigma2_v", "sigma2_1"] - ) - np.testing.assert_equal(reg.name_y, "HR") + np.testing.assert_allclose(reg.betas,np.array([[ 6.49221562], + [ 3.62445753], + [ 1.31187779], + [ 0.41777589], + [22.81908224], + [39.90993228]]),RTOL) + np.testing.assert_allclose(reg.vm,np.array([[ 1.26948117e-02, -1.98160325e-06, 7.38157674e-05], + [-1.98160325e-06, 7.69961725e-03, 1.13099329e-03], + [ 7.38157674e-05, 1.13099329e-03, 7.26783636e-03]]),RTOL*10) + np.testing.assert_equal(reg.name_x, ['CONSTANT', 'RD', 'PS', 'lambda', ' sigma2_v', 'sigma2_1']) + np.testing.assert_equal(reg.name_y, 'HR') def test_regimes(self): regimes = self.db.by_col("SOUTH") - reg = GM_KKP( - self.y, - self.x, - self.w, - full_weights=False, - regimes=regimes, - name_y=self.y_var0, - name_x=self.x_var0, - ) - np.testing.assert_allclose( - reg.betas, - np.array( - [ - [5.25856482], - [3.19249165], - [1.0056967], - [7.94560642], - [3.13931041], - [1.53700634], - [0.35979407], - [22.5650005], - [39.71516708], - ] - ), - RTOL, - ) - np.testing.assert_allclose( - np.sqrt(reg.vm.diagonal()), - np.array([0.158986, 0.157543, 0.104128, 0.165254, 0.117737, 0.136666]), - RTOL, - ) - np.testing.assert_equal( - reg.name_x, - [ - "0_CONSTANT", - "0_RD", - "0_PS", - "1_CONSTANT", - "1_RD", - "1_PS", - "lambda", - " sigma2_v", - "sigma2_1", - ], - ) - np.testing.assert_equal(reg.name_y, "HR") - np.testing.assert_allclose( - reg.chow.regi, - np.array( - [ - [1.420430e02, 9.516507e-33], - [7.311490e-02, 7.868543e-01], - [9.652492e00, 1.890949e-03], - ] - ), - RTOL, - ) - np.testing.assert_allclose(reg.chow.joint[0], 158.7225, RTOL) + reg = GM_KKP(self.y,self.x,self.w,full_weights=False,regimes=regimes, + name_y=self.y_var0, name_x=self.x_var0) + np.testing.assert_allclose(reg.betas,np.array([[ 5.25856482], + [ 3.19249165], + [ 1.0056967 ], + [ 7.94560642], + [ 3.13931041], + [ 1.53700634], + [ 0.35979407], + [22.5650005 ], + [39.71516708]]),RTOL) + np.testing.assert_allclose(np.sqrt(reg.vm.diagonal()),np.array([0.158986, 0.157543, 0.104128, 0.165254, 0.117737, 0.136666]),RTOL) + np.testing.assert_equal(reg.name_x, ['0_CONSTANT', '0_RD', '0_PS', '1_CONSTANT', '1_RD', '1_PS', 'lambda', ' sigma2_v', 'sigma2_1']) + np.testing.assert_equal(reg.name_y, 'HR') + np.testing.assert_allclose(reg.chow.regi,np.array([[1.420430e+02, 9.516507e-33], + [7.311490e-02, 7.868543e-01], + [9.652492e+00, 1.890949e-03]]),RTOL*10) + np.testing.assert_allclose(reg.chow.joint[0],158.7225,RTOL) - -if __name__ == "__main__": +if __name__ == '__main__': unittest.main() + diff --git a/spreg/utils.py b/spreg/utils.py index 19911fb0..ccd74926 100755 --- a/spreg/utils.py +++ b/spreg/utils.py @@ -322,7 +322,7 @@ def _moments2eqs(A1, s, u): return [G, g] -def optim_moments(moments_in, vcX=np.array([0]), all_par=False, start=None): +def optim_moments(moments_in, vcX=np.array([0]), all_par=False, start=None, hard_bound=False): """ Optimization of moments ... @@ -341,7 +341,10 @@ def optim_moments(moments_in, vcX=np.array([0]), all_par=False, start=None): solution or just the 1st. Default is 1st only. start : list List with initial values for the optimization - + hard_bound : boolean + If true, raises an exception if the estimated spatial + autoregressive parameter is outside the maximum/minimum bounds. + Returns ------- x, f, d : tuple @@ -386,6 +389,10 @@ def optim_moments(moments_in, vcX=np.array([0]), all_par=False, start=None): bounds = [(-0.99, 0.99), (0.0, None), (0.0, None)] lambdaX = op.fmin_l_bfgs_b(optim_par, start, approx_grad=True, bounds=bounds) + if hard_bound: + if abs(lambdaX[0][0]) >= 0.99: + raise Exception("Spatial parameter was outside the bounds of -0.99 and 0.99") + if all_par: return lambdaX[0] return lambdaX[0][0]