"""
GWR is tested against results from GWR4
"""

import os
from libpysal import io
import numpy as np
import unittest
import pickle as pk
from types import SimpleNamespace
from ..gwr import GWR, MGWR, MGWRResults
from ..sel_bw import Sel_BW
from ..diagnostics import get_AICc, get_AIC, get_BIC, get_CV
from spglm.family import Gaussian, Poisson, Binomial

class TestGWRGaussian(unittest.TestCase):
    def setUp(self):
        data_path = os.path.join(os.path.dirname(__file__),'georgia/GData_utm.csv')
        data = io.open(data_path)
        self.coords = list(zip(data.by_col('X'), data.by_col('Y')))
        self.y = np.array(data.by_col('PctBach')).reshape((-1,1))
        rural  = np.array(data.by_col('PctRural')).reshape((-1,1))
        pov = np.array(data.by_col('PctPov')).reshape((-1,1)) 
        black = np.array(data.by_col('PctBlack')).reshape((-1,1))
        fb = np.array(data.by_col('PctFB')).reshape((-1,1))
        self.X = np.hstack([rural, pov, black])
        self.mgwr_X = np.hstack([fb, black, rural])
        self.BS_F = io.open(os.path.join(os.path.dirname(__file__),'georgia/georgia_BS_F_listwise.csv'))
        self.BS_NN = io.open(os.path.join(os.path.dirname(__file__),'georgia/georgia_BS_NN_listwise.csv'))
        self.GS_F = io.open(os.path.join(os.path.dirname(__file__),'georgia/georgia_GS_F_listwise.csv'))
        self.GS_NN = io.open(os.path.join(os.path.dirname(__file__),'georgia/georgia_GS_NN_listwise.csv'))
        MGWR_path = os.path.join(os.path.dirname(__file__),'mgwr_example.p')
        self.MGWR = pk.load(open(MGWR_path, 'rb'))

    def test_BS_F(self):
        est_Int = self.BS_F.by_col(' est_Intercept')
        se_Int = self.BS_F.by_col(' se_Intercept')
        t_Int = self.BS_F.by_col(' t_Intercept')
        est_rural = self.BS_F.by_col(' est_PctRural')
        se_rural = self.BS_F.by_col(' se_PctRural')
        t_rural = self.BS_F.by_col(' t_PctRural')
        est_pov = self.BS_F.by_col(' est_PctPov')
        se_pov = self.BS_F.by_col(' se_PctPov')
        t_pov = self.BS_F.by_col(' t_PctPov')
        est_black = self.BS_F.by_col(' est_PctBlack')
        se_black = self.BS_F.by_col(' se_PctBlack')
        t_black = self.BS_F.by_col(' t_PctBlack')
        yhat = self.BS_F.by_col(' yhat')
        res = np.array(self.BS_F.by_col(' residual'))
        std_res = np.array(self.BS_F.by_col(' std_residual')).reshape((-1,1))
        localR2 = np.array(self.BS_F.by_col(' localR2')).reshape((-1,1))
        inf = np.array(self.BS_F.by_col(' influence')).reshape((-1,1))
        cooksD = np.array(self.BS_F.by_col(' CooksD')).reshape((-1,1))

        model = GWR(self.coords, self.y, self.X, bw=209267.689, fixed=True,
                sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        CV = get_CV(rslt)

        self.assertAlmostEquals(np.floor(AICc), 894.0)
        self.assertAlmostEquals(np.floor(AIC), 890.0)
        self.assertAlmostEquals(np.floor(BIC), 944.0)
        self.assertAlmostEquals(np.round(CV,2), 18.25)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-04)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-04)
        np.testing.assert_allclose(est_rural, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_rural, rslt.bse[:,1], rtol=1e-04)
        np.testing.assert_allclose(t_rural, rslt.tvalues[:,1], rtol=1e-04)
        np.testing.assert_allclose(est_pov, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_pov, rslt.bse[:,2], rtol=1e-04)
        np.testing.assert_allclose(t_pov, rslt.tvalues[:,2], rtol=1e-04)
        np.testing.assert_allclose(est_black, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_black, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_black, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(res, rslt.resid_response, rtol=1e-04)
        np.testing.assert_allclose(std_res, rslt.std_res, rtol=1e-04)
        np.testing.assert_allclose(localR2, rslt.localR2, rtol=1e-05)
        np.testing.assert_allclose(inf, rslt.influ, rtol=1e-04)
        np.testing.assert_allclose(cooksD, rslt.cooksD, rtol=1e-00)

    def test_BS_NN(self):
        est_Int = self.BS_NN.by_col(' est_Intercept')
        se_Int = self.BS_NN.by_col(' se_Intercept')
        t_Int = self.BS_NN.by_col(' t_Intercept')
        est_rural = self.BS_NN.by_col(' est_PctRural')
        se_rural = self.BS_NN.by_col(' se_PctRural')
        t_rural = self.BS_NN.by_col(' t_PctRural')
        est_pov = self.BS_NN.by_col(' est_PctPov')
        se_pov = self.BS_NN.by_col(' se_PctPov')
        t_pov = self.BS_NN.by_col(' t_PctPov')
        est_black = self.BS_NN.by_col(' est_PctBlack')
        se_black = self.BS_NN.by_col(' se_PctBlack')
        t_black = self.BS_NN.by_col(' t_PctBlack')
        yhat = self.BS_NN.by_col(' yhat')
        res = np.array(self.BS_NN.by_col(' residual'))
        std_res = np.array(self.BS_NN.by_col(' std_residual')).reshape((-1,1))
        localR2 = np.array(self.BS_NN.by_col(' localR2')).reshape((-1,1))
        inf = np.array(self.BS_NN.by_col(' influence')).reshape((-1,1))
        cooksD = np.array(self.BS_NN.by_col(' CooksD')).reshape((-1,1))
        local_corr = os.path.join(os.path.dirname(__file__),'local_corr.csv')
        corr1 = np.array(io.open(local_corr))
        local_vif = os.path.join(os.path.dirname(__file__),'local_vif.csv')
        vif1 = np.array(io.open(local_vif))
        local_cn = os.path.join(os.path.dirname(__file__),'local_cn.csv')
        cn1 = np.array(io.open(local_cn))
        local_vdp = os.path.join(os.path.dirname(__file__),'local_vdp.csv')
        vdp1 = np.array(io.open(local_vdp), dtype=np.float64)
        spat_var_p_vals = [0. , 0.0 , 0.5, 0.2]

        model = GWR(self.coords, self.y, self.X, bw=90.000, fixed=False,
                sigma2_v1=False)
        rslt = model.fit()
        

        adj_alpha = rslt.adj_alpha
        alpha = 0.01017489
        critical_t = rslt.critical_tval(alpha)
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        CV = get_CV(rslt)
        
        corr2, vif2, cn2, vdp2 = rslt.local_collinearity()

        R2 = rslt.R2

        
        np.testing.assert_allclose(adj_alpha, np.array([ 0.02034978,  0.01017489,
            0.0002035 ]), rtol=1e-04)
        self.assertAlmostEquals(critical_t, 2.6011011542649394)
        self.assertAlmostEquals(np.around(R2, 4), 0.5924)
        self.assertAlmostEquals(np.floor(AICc), 896.0)
        self.assertAlmostEquals(np.floor(AIC), 892.0)
        self.assertAlmostEquals(np.floor(BIC), 941.0)
        self.assertAlmostEquals(np.around(CV, 2), 19.19)
        np.testing.assert_allclose(corr1, corr2, rtol=1e-04)
        np.testing.assert_allclose(vif1, vif2, rtol=1e-04)
        np.testing.assert_allclose(cn1, cn2, rtol=1e-04)
        np.testing.assert_allclose(vdp1, vdp2, rtol=1e-04)

        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-04)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-04)
        np.testing.assert_allclose(est_rural, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_rural, rslt.bse[:,1], rtol=1e-04)
        np.testing.assert_allclose(t_rural, rslt.tvalues[:,1], rtol=1e-04)
        np.testing.assert_allclose(est_pov, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_pov, rslt.bse[:,2], rtol=1e-04)
        np.testing.assert_allclose(t_pov, rslt.tvalues[:,2], rtol=1e-04)
        np.testing.assert_allclose(est_black, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_black, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_black, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(res, rslt.resid_response, rtol=1e-04)
        np.testing.assert_allclose(std_res, rslt.std_res, rtol=1e-04)
        np.testing.assert_allclose(localR2, rslt.localR2, rtol=1e-05)
        np.testing.assert_allclose(inf, rslt.influ, rtol=1e-04)
        np.testing.assert_allclose(cooksD, rslt.cooksD, rtol=1e-00)

        sel = Sel_BW(self.coords, self.y, self.X)
        bw = sel.search()
        model = GWR(self.coords, self.y, self.X, bw)
        result = model.fit()

        p_vals = result.spatial_variability(sel, 10)
        np.testing.assert_allclose(spat_var_p_vals, p_vals, rtol=1e-04)


    def test_GS_F(self):
        est_Int = self.GS_F.by_col(' est_Intercept')
        se_Int = self.GS_F.by_col(' se_Intercept')
        t_Int = self.GS_F.by_col(' t_Intercept')
        est_rural = self.GS_F.by_col(' est_PctRural')
        se_rural = self.GS_F.by_col(' se_PctRural')
        t_rural = self.GS_F.by_col(' t_PctRural')
        est_pov = self.GS_F.by_col(' est_PctPov')
        se_pov = self.GS_F.by_col(' se_PctPov')
        t_pov = self.GS_F.by_col(' t_PctPov')
        est_black = self.GS_F.by_col(' est_PctBlack')
        se_black = self.GS_F.by_col(' se_PctBlack')
        t_black = self.GS_F.by_col(' t_PctBlack')
        yhat = self.GS_F.by_col(' yhat')
        res = np.array(self.GS_F.by_col(' residual'))
        std_res = np.array(self.GS_F.by_col(' std_residual')).reshape((-1,1))
        localR2 = np.array(self.GS_F.by_col(' localR2')).reshape((-1,1))
        inf = np.array(self.GS_F.by_col(' influence')).reshape((-1,1))
        cooksD = np.array(self.GS_F.by_col(' CooksD')).reshape((-1,1))
        
        model = GWR(self.coords, self.y, self.X, bw=87308.298,
                kernel='gaussian', fixed=True, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        CV = get_CV(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 895.0)
        self.assertAlmostEquals(np.floor(AIC), 890.0)
        self.assertAlmostEquals(np.floor(BIC), 943.0)
        self.assertAlmostEquals(np.around(CV, 2), 18.21)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-04)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-04)
        np.testing.assert_allclose(est_rural, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_rural, rslt.bse[:,1], rtol=1e-04)
        np.testing.assert_allclose(t_rural, rslt.tvalues[:,1], rtol=1e-04)
        np.testing.assert_allclose(est_pov, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_pov, rslt.bse[:,2], rtol=1e-04)
        np.testing.assert_allclose(t_pov, rslt.tvalues[:,2], rtol=1e-04)
        np.testing.assert_allclose(est_black, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_black, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_black, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(res, rslt.resid_response, rtol=1e-04)
        np.testing.assert_allclose(std_res, rslt.std_res, rtol=1e-04)
        np.testing.assert_allclose(localR2, rslt.localR2, rtol=1e-05)
        np.testing.assert_allclose(inf, rslt.influ, rtol=1e-04)
        np.testing.assert_allclose(cooksD, rslt.cooksD, rtol=1e-00)
        
    def test_GS_NN(self):
        est_Int = self.GS_NN.by_col(' est_Intercept')
        se_Int = self.GS_NN.by_col(' se_Intercept')
        t_Int = self.GS_NN.by_col(' t_Intercept')
        est_rural = self.GS_NN.by_col(' est_PctRural')
        se_rural = self.GS_NN.by_col(' se_PctRural')
        t_rural = self.GS_NN.by_col(' t_PctRural')
        est_pov = self.GS_NN.by_col(' est_PctPov')
        se_pov = self.GS_NN.by_col(' se_PctPov')
        t_pov = self.GS_NN.by_col(' t_PctPov')
        est_black = self.GS_NN.by_col(' est_PctBlack')
        se_black = self.GS_NN.by_col(' se_PctBlack')
        t_black = self.GS_NN.by_col(' t_PctBlack')
        yhat = self.GS_NN.by_col(' yhat')
        res = np.array(self.GS_NN.by_col(' residual'))
        std_res = np.array(self.GS_NN.by_col(' std_residual')).reshape((-1,1))
        localR2 = np.array(self.GS_NN.by_col(' localR2')).reshape((-1,1))
        inf = np.array(self.GS_NN.by_col(' influence')).reshape((-1,1))
        cooksD = np.array(self.GS_NN.by_col(' CooksD')).reshape((-1,1))

        model = GWR(self.coords, self.y, self.X, bw=49.000,
                kernel='gaussian', fixed=False, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        CV = get_CV(rslt)
        
        self.assertAlmostEquals(np.floor(AICc),  896.0)
        self.assertAlmostEquals(np.floor(AIC), 894.0)
        self.assertAlmostEquals(np.floor(BIC), 922.0)
        self.assertAlmostEquals(np.around(CV, 2), 17.91)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-04)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-04)
        np.testing.assert_allclose(est_rural, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_rural, rslt.bse[:,1], rtol=1e-04)
        np.testing.assert_allclose(t_rural, rslt.tvalues[:,1], rtol=1e-04)
        np.testing.assert_allclose(est_pov, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_pov, rslt.bse[:,2], rtol=1e-04)
        np.testing.assert_allclose(t_pov, rslt.tvalues[:,2], rtol=1e-04)
        np.testing.assert_allclose(est_black, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_black, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_black, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(res, rslt.resid_response, rtol=1e-04)
        np.testing.assert_allclose(std_res, rslt.std_res, rtol=1e-04)
        np.testing.assert_allclose(localR2, rslt.localR2, rtol=1e-05)
        np.testing.assert_allclose(inf, rslt.influ, rtol=1e-04)
        np.testing.assert_allclose(cooksD, rslt.cooksD, rtol=1e-00)
    
    def test_MGWR(self):
        std_y = (self.y - self.y.mean()) / self.y.std()
        std_X = (self.mgwr_X - self.mgwr_X.mean(axis=0)) / self.mgwr_X.std(axis=0)
        selector = Sel_BW(self.coords, std_y, std_X, multi=True,
                constant=True)
        selector.search(multi_bw_min=[2], multi_bw_max=[159])
        model = MGWR(self.coords, std_y, std_X, selector=selector,
                constant=True)
        rslt = model.fit()

        np.testing.assert_allclose(rslt.predy, self.MGWR.predy, atol=1e-07)
        np.testing.assert_allclose(rslt.params, self.MGWR.params, atol=1e-07)
        np.testing.assert_allclose(rslt.bse, self.MGWR.bse, atol=1e-07)
        np.testing.assert_allclose(rslt.tvalues, self.MGWR.tvalues, atol=1e-07)
        np.testing.assert_allclose(rslt.resid_response, self.MGWR.resid_response,
                atol=1e-04, rtol=1e-04)
        np.testing.assert_almost_equal(rslt.resid_ss, self.MGWR.resid_ss)
        np.testing.assert_almost_equal(rslt.aicc, self.MGWR.aicc)
        np.testing.assert_almost_equal(rslt.ENP, self.MGWR.ENP)
        np.testing.assert_allclose(rslt.ENP_j, self.MGWR.ENP_j)
        np.testing.assert_allclose(rslt.adj_alpha_j, self.MGWR.adj_alpha_j)
        np.testing.assert_allclose(rslt.critical_tval(),
                                   self.MGWR.critical_tval)
        np.testing.assert_allclose(rslt.filter_tvals(), 
                                   self.MGWR.filter_tvals)
        np.testing.assert_allclose(rslt.local_collinearity()[0],
                                   self.MGWR.local_collinearity)
    
    def test_Prediction(self):
        coords =np.array(self.coords)
        index = np.arange(len(self.y))
        test = index[-10:]

        X_test = self.X[test]
        coords_test = list(coords[test])


        model = GWR(self.coords, self.y, self.X, 93, family=Gaussian(),
                fixed=False, kernel='bisquare', sigma2_v1=False)
        results = model.predict(coords_test, X_test)
        
        params = np.array([22.77198, -0.10254,    -0.215093,   -0.01405,
            19.10531,    -0.094177,   -0.232529,   0.071913,
            19.743421,   -0.080447,   -0.30893,    0.083206,
            17.505759,   -0.078919,   -0.187955,   0.051719,
            27.747402,   -0.165335,   -0.208553,   0.004067,
            26.210627,   -0.138398,   -0.360514,   0.072199,
            18.034833,   -0.077047,   -0.260556,   0.084319,
            28.452802,   -0.163408,   -0.14097,    -0.063076,
            22.353095,   -0.103046,   -0.226654,   0.002992,
            18.220508,   -0.074034,   -0.309812,   0.108636]).reshape((10,4))
        np.testing.assert_allclose(params, results.params, rtol=1e-03)

        bse = np.array([2.080166,    0.021462,    0.102954,    0.049627,
            2.536355,    0.022111,    0.123857,    0.051917,
            1.967813,    0.019716,    0.102562,    0.054918,
            2.463219,    0.021745,    0.110297,    0.044189,
            1.556056,    0.019513,    0.12764,     0.040315,
            1.664108,    0.020114,    0.131208,    0.041613,
            2.5835,      0.021481,    0.113158,    0.047243,
            1.709483,    0.019752,    0.116944,    0.043636,
            1.958233,    0.020947,    0.09974,     0.049821,
            2.276849,    0.020122,    0.107867,    0.047842]).reshape((10,4))
        np.testing.assert_allclose(bse, results.bse, rtol=1e-03)

        tvalues = np.array([10.947193,   -4.777659,   -2.089223,   -0.283103,
            7.532584,    -4.259179,   -1.877395,   1.385161,
            10.033179,   -4.080362,   -3.012133,   1.515096,
            7.106862,    -3.629311,   -1.704079,   1.17042,
            17.831878,   -8.473156,   -1.633924,   0.100891,
            15.750552,   -6.880725,   -2.74765,    1.734978,
            6.980774,    -3.586757,   -2.302575,   1.784818,
            16.644095,   -8.273001,   -1.205451,   -1.445501,
            11.414933,   -4.919384,   -2.272458,   0.060064,
            8.00251, -3.679274,   -2.872176,   2.270738]).reshape((10,4))
        np.testing.assert_allclose(tvalues, results.tvalues, rtol=1e-03)

        localR2 = np.array([[ 0.53068693],
                            [ 0.59582647],
                            [ 0.59700925],
                            [ 0.45769954],
                            [ 0.54634509],
                            [ 0.5494828 ],
                            [ 0.55159604],
                            [ 0.55634237],
                            [ 0.53903842],
                            [ 0.55884954]])
        np.testing.assert_allclose(localR2, results.localR2, rtol=1e-05)

        predictions = np.array([[ 10.51695514],
                                [  9.93321992],
                                [  8.92473026],
                                [  5.47350219],
                                [  8.61756585],
                                [ 12.8141851 ],
                                [  5.55619405],
                                [ 12.63004172],
                                [  8.70638418],
                                [  8.17582599]])
        np.testing.assert_allclose(predictions, results.predictions, rtol=1e-05)



    def test_BS_NN_longlat(self):
        GA_longlat = os.path.join(os.path.dirname(__file__),'ga_bs_nn_longlat_listwise.csv')
        self.BS_NN_longlat = io.open(GA_longlat)
        
        coords_longlat = list(zip(self.BS_NN_longlat.by_col(' x_coord'), self.BS_NN_longlat.by_col(' y_coord')))
        est_Int = self.BS_NN_longlat.by_col(' est_Intercept')
        se_Int = self.BS_NN_longlat.by_col(' se_Intercept')
        t_Int = self.BS_NN_longlat.by_col(' t_Intercept')
        est_rural = self.BS_NN_longlat.by_col(' est_PctRural')
        se_rural = self.BS_NN_longlat.by_col(' se_PctRural')
        t_rural = self.BS_NN_longlat.by_col(' t_PctRural')
        est_pov = self.BS_NN_longlat.by_col(' est_PctPov')
        se_pov = self.BS_NN_longlat.by_col(' se_PctPov')
        t_pov = self.BS_NN_longlat.by_col(' t_PctPov')
        est_black = self.BS_NN_longlat.by_col(' est_PctBlack')
        se_black = self.BS_NN_longlat.by_col(' se_PctBlack')
        t_black = self.BS_NN_longlat.by_col(' t_PctBlack')
        yhat = self.BS_NN_longlat.by_col(' yhat')
        res = np.array(self.BS_NN_longlat.by_col(' residual'))
        std_res = np.array(self.BS_NN_longlat.by_col(' std_residual')).reshape((-1,1))
        localR2 = np.array(self.BS_NN_longlat.by_col(' localR2')).reshape((-1,1))
        inf = np.array(self.BS_NN_longlat.by_col(' influence')).reshape((-1,1))
        cooksD = np.array(self.BS_NN_longlat.by_col(' CooksD')).reshape((-1,1))
        
        model = GWR(coords_longlat, self.y, self.X, bw=90.000, fixed=False,
                spherical=True, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        CV = get_CV(rslt)
        
        R2 = rslt.R2
        
        self.assertAlmostEquals(np.around(R2, 4), 0.5921)
        self.assertAlmostEquals(np.floor(AICc), 896.0)
        self.assertAlmostEquals(np.floor(AIC), 892.0)
        self.assertAlmostEquals(np.floor(BIC), 941.0)
        self.assertAlmostEquals(np.around(CV, 2), 19.11)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-04)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-04)
        np.testing.assert_allclose(est_rural, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_rural, rslt.bse[:,1], rtol=1e-04)
        np.testing.assert_allclose(t_rural, rslt.tvalues[:,1], rtol=1e-04)
        np.testing.assert_allclose(est_pov, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_pov, rslt.bse[:,2], rtol=1e-04)
        np.testing.assert_allclose(t_pov, rslt.tvalues[:,2], rtol=1e-04)
        np.testing.assert_allclose(est_black, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_black, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_black, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(res, rslt.resid_response, rtol=1e-04)
        np.testing.assert_allclose(std_res, rslt.std_res, rtol=1e-04)
        np.testing.assert_allclose(localR2, rslt.localR2, rtol=1e-05)
        np.testing.assert_allclose(inf, rslt.influ, rtol=1e-04)
        np.testing.assert_allclose(cooksD, rslt.cooksD, rtol=1e-00)


class TestGWRPoisson(unittest.TestCase):
    def setUp(self):
        data_path = os.path.join(os.path.dirname(__file__),'tokyo/Tokyomortality.csv')
        data = io.open(data_path, mode='Ur')
        self.coords = list(zip(data.by_col('X_CENTROID'), data.by_col('Y_CENTROID')))
        self.y = np.array(data.by_col('db2564')).reshape((-1,1))
        self.off = np.array(data.by_col('eb2564')).reshape((-1,1))
        OCC  = np.array(data.by_col('OCC_TEC')).reshape((-1,1))
        OWN = np.array(data.by_col('OWNH')).reshape((-1,1)) 
        POP = np.array(data.by_col('POP65')).reshape((-1,1))
        UNEMP = np.array(data.by_col('UNEMP')).reshape((-1,1))
        self.X = np.hstack([OCC,OWN,POP,UNEMP])
        self.BS_F = io.open(os.path.join(os.path.dirname(__file__),'tokyo/tokyo_BS_F_listwise.csv'))
        self.BS_NN = io.open(os.path.join(os.path.dirname(__file__),'tokyo/tokyo_BS_NN_listwise.csv'))
        self.GS_F = io.open(os.path.join(os.path.dirname(__file__),'tokyo/tokyo_GS_F_listwise.csv'))
        self.GS_NN = io.open(os.path.join(os.path.dirname(__file__),'tokyo/tokyo_GS_NN_listwise.csv'))
        self.BS_NN_OFF = io.open(os.path.join(os.path.dirname(__file__),'tokyo/tokyo_BS_NN_OFF_listwise.csv'))

    def test_BS_F(self):
        est_Int = self.BS_F.by_col(' est_Intercept')
        se_Int = self.BS_F.by_col(' se_Intercept')
        t_Int = self.BS_F.by_col(' t_Intercept')
        est_OCC = self.BS_F.by_col(' est_OCC_TEC')
        se_OCC = self.BS_F.by_col(' se_OCC_TEC')
        t_OCC = self.BS_F.by_col(' t_OCC_TEC')
        est_OWN = self.BS_F.by_col(' est_OWNH')
        se_OWN = self.BS_F.by_col(' se_OWNH')
        t_OWN = self.BS_F.by_col(' t_OWNH')
        est_POP = self.BS_F.by_col(' est_POP65')
        se_POP = self.BS_F.by_col(' se_POP65')
        t_POP = self.BS_F.by_col(' t_POP65')
        est_UNEMP = self.BS_F.by_col(' est_UNEMP')
        se_UNEMP = self.BS_F.by_col(' se_UNEMP')
        t_UNEMP = self.BS_F.by_col(' t_UNEMP')
        yhat = self.BS_F.by_col(' yhat')
        pdev = np.array(self.BS_F.by_col(' localpdev')).reshape((-1,1))
        
        model = GWR(self.coords, self.y, self.X, bw=26029.625, family=Poisson(), 
                kernel='bisquare', fixed=True, sigma2_v1=False)
        rslt = model.fit()

        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 13294.0)
        self.assertAlmostEquals(np.floor(AIC), 13247.0)
        self.assertAlmostEquals(np.floor(BIC), 13485.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-05)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-03)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-03)
        np.testing.assert_allclose(est_OCC, rslt.params[:,1], rtol=1e-04)
        np.testing.assert_allclose(se_OCC, rslt.bse[:,1], rtol=1e-02)
        np.testing.assert_allclose(t_OCC, rslt.tvalues[:,1], rtol=1e-02)
        np.testing.assert_allclose(est_OWN, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_OWN, rslt.bse[:,2], rtol=1e-03)
        np.testing.assert_allclose(t_OWN, rslt.tvalues[:,2], rtol=1e-03)
        np.testing.assert_allclose(est_POP, rslt.params[:,3], rtol=1e-04)
        np.testing.assert_allclose(se_POP, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_POP, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(est_UNEMP, rslt.params[:,4], rtol=1e-04)
        np.testing.assert_allclose(se_UNEMP, rslt.bse[:,4], rtol=1e-02)
        np.testing.assert_allclose(t_UNEMP, rslt.tvalues[:,4], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-05)
        np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)


    def test_BS_NN(self):
        est_Int = self.BS_NN.by_col(' est_Intercept')
        se_Int = self.BS_NN.by_col(' se_Intercept')
        t_Int = self.BS_NN.by_col(' t_Intercept')
        est_OCC = self.BS_NN.by_col(' est_OCC_TEC')
        se_OCC = self.BS_NN.by_col(' se_OCC_TEC')
        t_OCC = self.BS_NN.by_col(' t_OCC_TEC')
        est_OWN = self.BS_NN.by_col(' est_OWNH')
        se_OWN = self.BS_NN.by_col(' se_OWNH')
        t_OWN = self.BS_NN.by_col(' t_OWNH')
        est_POP = self.BS_NN.by_col(' est_POP65')
        se_POP = self.BS_NN.by_col(' se_POP65')
        t_POP = self.BS_NN.by_col(' t_POP65')
        est_UNEMP = self.BS_NN.by_col(' est_UNEMP')
        se_UNEMP = self.BS_NN.by_col(' se_UNEMP')
        t_UNEMP = self.BS_NN.by_col(' t_UNEMP')
        yhat = self.BS_NN.by_col(' yhat')
        pdev = np.array(self.BS_NN.by_col(' localpdev')).reshape((-1,1))

        model = GWR(self.coords, self.y, self.X, bw=50, family=Poisson(), 
                kernel='bisquare', fixed=False, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 13285)
        self.assertAlmostEquals(np.floor(AIC), 13259.0)
        self.assertAlmostEquals(np.floor(BIC), 13442.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-02)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-02)
        np.testing.assert_allclose(est_OCC, rslt.params[:,1], rtol=1e-03)
        np.testing.assert_allclose(se_OCC, rslt.bse[:,1], rtol=1e-02)
        np.testing.assert_allclose(t_OCC, rslt.tvalues[:,1], rtol=1e-02)
        np.testing.assert_allclose(est_OWN, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_OWN, rslt.bse[:,2], rtol=1e-02)
        np.testing.assert_allclose(t_OWN, rslt.tvalues[:,2], rtol=1e-02)
        np.testing.assert_allclose(est_POP, rslt.params[:,3], rtol=1e-03)
        np.testing.assert_allclose(se_POP, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_POP, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(est_UNEMP, rslt.params[:,4], rtol=1e-04)
        np.testing.assert_allclose(se_UNEMP, rslt.bse[:,4], rtol=1e-02)
        np.testing.assert_allclose(t_UNEMP, rslt.tvalues[:,4], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-04)
        np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)
    
    def test_BS_NN_Offset(self):
        est_Int = self.BS_NN_OFF.by_col(' est_Intercept')
        se_Int = self.BS_NN_OFF.by_col(' se_Intercept')
        t_Int = self.BS_NN_OFF.by_col(' t_Intercept')
        est_OCC = self.BS_NN_OFF.by_col(' est_OCC_TEC')
        se_OCC = self.BS_NN_OFF.by_col(' se_OCC_TEC')
        t_OCC = self.BS_NN_OFF.by_col(' t_OCC_TEC')
        est_OWN = self.BS_NN_OFF.by_col(' est_OWNH')
        se_OWN = self.BS_NN_OFF.by_col(' se_OWNH')
        t_OWN = self.BS_NN_OFF.by_col(' t_OWNH')
        est_POP = self.BS_NN_OFF.by_col(' est_POP65')
        se_POP = self.BS_NN_OFF.by_col(' se_POP65')
        t_POP = self.BS_NN_OFF.by_col(' t_POP65')
        est_UNEMP = self.BS_NN_OFF.by_col(' est_UNEMP')
        se_UNEMP = self.BS_NN_OFF.by_col(' se_UNEMP')
        t_UNEMP = self.BS_NN_OFF.by_col(' t_UNEMP')
        yhat = self.BS_NN_OFF.by_col(' yhat')
        pdev = np.array(self.BS_NN_OFF.by_col(' localpdev')).reshape((-1,1))

        model = GWR(self.coords, self.y, self.X, bw=100, offset=self.off, family=Poisson(), 
                kernel='bisquare', fixed=False, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 367.0)
        self.assertAlmostEquals(np.floor(AIC), 361.0)
        self.assertAlmostEquals(np.floor(BIC), 451.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-02,
                atol=1e-02)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-02, atol=1e-02)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-01,
                atol=1e-02)
        np.testing.assert_allclose(est_OCC, rslt.params[:,1], rtol=1e-03,
                atol=1e-02)
        np.testing.assert_allclose(se_OCC, rslt.bse[:,1], rtol=1e-02, atol=1e-02)
        np.testing.assert_allclose(t_OCC, rslt.tvalues[:,1], rtol=1e-01,
                atol=1e-02)
        np.testing.assert_allclose(est_OWN, rslt.params[:,2], rtol=1e-04,
                atol=1e-02)
        np.testing.assert_allclose(se_OWN, rslt.bse[:,2], rtol=1e-02, atol=1e-02)
        np.testing.assert_allclose(t_OWN, rslt.tvalues[:,2], rtol=1e-01,
                atol=1e-02)
        np.testing.assert_allclose(est_POP, rslt.params[:,3], rtol=1e-03,
                atol=1e-02)
        np.testing.assert_allclose(se_POP, rslt.bse[:,3], rtol=1e-02, atol=1e-02)
        np.testing.assert_allclose(t_POP, rslt.tvalues[:,3], rtol=1e-01,
                atol=1e-02)
        np.testing.assert_allclose(est_UNEMP, rslt.params[:,4], rtol=1e-04,
                atol=1e-02)
        np.testing.assert_allclose(se_UNEMP, rslt.bse[:,4], rtol=1e-02,
                atol=1e-02)
        np.testing.assert_allclose(t_UNEMP, rslt.tvalues[:,4], rtol=1e-01,
                atol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-03, atol=1e-02)
        np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-04, atol=1e-02)

    def test_GS_F(self):
        est_Int = self.GS_F.by_col(' est_Intercept')
        se_Int = self.GS_F.by_col(' se_Intercept')
        t_Int = self.GS_F.by_col(' t_Intercept')
        est_OCC = self.GS_F.by_col(' est_OCC_TEC')
        se_OCC = self.GS_F.by_col(' se_OCC_TEC')
        t_OCC = self.GS_F.by_col(' t_OCC_TEC')
        est_OWN = self.GS_F.by_col(' est_OWNH')
        se_OWN = self.GS_F.by_col(' se_OWNH')
        t_OWN = self.GS_F.by_col(' t_OWNH')
        est_POP = self.GS_F.by_col(' est_POP65')
        se_POP = self.GS_F.by_col(' se_POP65')
        t_POP = self.GS_F.by_col(' t_POP65')
        est_UNEMP = self.GS_F.by_col(' est_UNEMP')
        se_UNEMP = self.GS_F.by_col(' se_UNEMP')
        t_UNEMP = self.GS_F.by_col(' t_UNEMP')
        yhat = self.GS_F.by_col(' yhat')
        pdev = np.array(self.GS_F.by_col(' localpdev')).reshape((-1,1))
        
        model = GWR(self.coords, self.y, self.X, bw=8764.474, family=Poisson(), 
                kernel='gaussian', fixed=True, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 11283.0)
        self.assertAlmostEquals(np.floor(AIC), 11211.0)
        self.assertAlmostEquals(np.floor(BIC), 11497.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-03)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-02)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-02)
        np.testing.assert_allclose(est_OCC, rslt.params[:,1], rtol=1e-03)
        np.testing.assert_allclose(se_OCC, rslt.bse[:,1], rtol=1e-02)
        np.testing.assert_allclose(t_OCC, rslt.tvalues[:,1], rtol=1e-02)
        np.testing.assert_allclose(est_OWN, rslt.params[:,2], rtol=1e-03)
        np.testing.assert_allclose(se_OWN, rslt.bse[:,2], rtol=1e-02)
        np.testing.assert_allclose(t_OWN, rslt.tvalues[:,2], rtol=1e-02)
        np.testing.assert_allclose(est_POP, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_POP, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_POP, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(est_UNEMP, rslt.params[:,4], rtol=1e-02)
        np.testing.assert_allclose(se_UNEMP, rslt.bse[:,4], rtol=1e-02)
        np.testing.assert_allclose(t_UNEMP, rslt.tvalues[:,4], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-04)
        np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)

    def test_GS_NN(self):
        est_Int = self.GS_NN.by_col(' est_Intercept')
        se_Int = self.GS_NN.by_col(' se_Intercept')
        t_Int = self.GS_NN.by_col(' t_Intercept')
        est_OCC = self.GS_NN.by_col(' est_OCC_TEC')
        se_OCC = self.GS_NN.by_col(' se_OCC_TEC')
        t_OCC = self.GS_NN.by_col(' t_OCC_TEC')
        est_OWN = self.GS_NN.by_col(' est_OWNH')
        se_OWN = self.GS_NN.by_col(' se_OWNH')
        t_OWN = self.GS_NN.by_col(' t_OWNH')
        est_POP = self.GS_NN.by_col(' est_POP65')
        se_POP = self.GS_NN.by_col(' se_POP65')
        t_POP = self.GS_NN.by_col(' t_POP65')
        est_UNEMP = self.GS_NN.by_col(' est_UNEMP')
        se_UNEMP = self.GS_NN.by_col(' se_UNEMP')
        t_UNEMP = self.GS_NN.by_col(' t_UNEMP')
        yhat = self.GS_NN.by_col(' yhat')
        pdev = np.array(self.GS_NN.by_col(' localpdev')).reshape((-1,1))
        
        model = GWR(self.coords, self.y, self.X, bw=50, family=Poisson(), 
                kernel='gaussian', fixed=False, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 21070.0)
        self.assertAlmostEquals(np.floor(AIC), 21069.0)
        self.assertAlmostEquals(np.floor(BIC), 21111.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-04)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-02)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-02)
        np.testing.assert_allclose(est_OCC, rslt.params[:,1], rtol=1e-03)
        np.testing.assert_allclose(se_OCC, rslt.bse[:,1], rtol=1e-02)
        np.testing.assert_allclose(t_OCC, rslt.tvalues[:,1], rtol=1e-02)
        np.testing.assert_allclose(est_OWN, rslt.params[:,2], rtol=1e-04)
        np.testing.assert_allclose(se_OWN, rslt.bse[:,2], rtol=1e-02)
        np.testing.assert_allclose(t_OWN, rslt.tvalues[:,2], rtol=1e-02)
        np.testing.assert_allclose(est_POP, rslt.params[:,3], rtol=1e-02)
        np.testing.assert_allclose(se_POP, rslt.bse[:,3], rtol=1e-02)
        np.testing.assert_allclose(t_POP, rslt.tvalues[:,3], rtol=1e-02)
        np.testing.assert_allclose(est_UNEMP, rslt.params[:,4], rtol=1e-02)
        np.testing.assert_allclose(se_UNEMP, rslt.bse[:,4], rtol=1e-02)
        np.testing.assert_allclose(t_UNEMP, rslt.tvalues[:,4], rtol=1e-02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-04)
        np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)

class TestGWRBinomial(unittest.TestCase):
    def setUp(self):
        data_path = os.path.join(os.path.dirname(__file__),'clearwater/landslides.csv')
        data = io.open(data_path)
        self.coords = list(zip(data.by_col('X'), data.by_col('Y')))
        self.y = np.array(data.by_col('Landslid')).reshape((-1,1))
        ELEV  = np.array(data.by_col('Elev')).reshape((-1,1))
        SLOPE = np.array(data.by_col('Slope')).reshape((-1,1)) 
        SIN = np.array(data.by_col('SinAspct')).reshape((-1,1))
        COS = np.array(data.by_col('CosAspct')).reshape((-1,1))
        SOUTH = np.array(data.by_col('AbsSouth')).reshape((-1,1))
        DIST = np.array(data.by_col('DistStrm')).reshape((-1,1))
        self.X = np.hstack([ELEV, SLOPE, SIN, COS, SOUTH, DIST])
        self.BS_F = io.open(os.path.join(os.path.dirname(__file__),'clearwater/clearwater_BS_F_listwise.csv'))
        self.BS_NN = io.open(os.path.join(os.path.dirname(__file__),'clearwater/clearwater_BS_NN_listwise.csv'))
        self.GS_F = io.open(os.path.join(os.path.dirname(__file__),'clearwater/clearwater_GS_F_listwise.csv'))
        self.GS_NN = io.open(os.path.join(os.path.dirname(__file__),'clearwater/clearwater_GS_NN_listwise.csv'))

    def test_BS_F(self):
        est_Int = self.BS_F.by_col(' est_Intercept')
        se_Int = self.BS_F.by_col(' se_Intercept')
        t_Int = self.BS_F.by_col(' t_Intercept')
        est_elev = self.BS_F.by_col(' est_Elev')
        se_elev = self.BS_F.by_col(' se_Elev')
        t_elev = self.BS_F.by_col(' t_Elev')
        est_slope = self.BS_F.by_col(' est_Slope')
        se_slope = self.BS_F.by_col(' se_Slope')
        t_slope = self.BS_F.by_col(' t_Slope')
        est_sin = self.BS_F.by_col(' est_SinAspct')
        se_sin = self.BS_F.by_col(' se_SinAspct')
        t_sin = self.BS_F.by_col(' t_SinAspct')
        est_cos = self.BS_F.by_col(' est_CosAspct')
        se_cos = self.BS_F.by_col(' se_CosAspct')
        t_cos = self.BS_F.by_col(' t_CosAspct')
        est_south = self.BS_F.by_col(' est_AbsSouth')
        se_south = self.BS_F.by_col(' se_AbsSouth')
        t_south = self.BS_F.by_col(' t_AbsSouth')
        est_strm = self.BS_F.by_col(' est_DistStrm')
        se_strm = self.BS_F.by_col(' se_DistStrm')
        t_strm = self.BS_F.by_col(' t_DistStrm') 
        yhat = self.BS_F.by_col(' yhat')
        pdev = np.array(self.BS_F.by_col(' localpdev')).reshape((-1,1))

        model = GWR(self.coords, self.y, self.X, bw=19642.170, family=Binomial(), 
                kernel='bisquare', fixed=True, sigma2_v1=False)
        rslt = model.fit()

        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 275.0)
        self.assertAlmostEquals(np.floor(AIC), 271.0)
        self.assertAlmostEquals(np.floor(BIC), 349.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-00)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-00)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-00)
        np.testing.assert_allclose(est_elev, rslt.params[:,1], rtol=1e-00)
        np.testing.assert_allclose(se_elev, rslt.bse[:,1], rtol=1e-00)
        np.testing.assert_allclose(t_elev, rslt.tvalues[:,1], rtol=1e-00)
        np.testing.assert_allclose(est_slope, rslt.params[:,2], rtol=1e-00)
        np.testing.assert_allclose(se_slope, rslt.bse[:,2], rtol=1e-00)
        np.testing.assert_allclose(t_slope, rslt.tvalues[:,2], rtol=1e-00)
        np.testing.assert_allclose(est_sin, rslt.params[:,3], rtol=1e01)
        np.testing.assert_allclose(se_sin, rslt.bse[:,3], rtol=1e01)
        np.testing.assert_allclose(t_sin, rslt.tvalues[:,3], rtol=1e01)
        np.testing.assert_allclose(est_cos, rslt.params[:,4], rtol=1e01)
        np.testing.assert_allclose(se_cos, rslt.bse[:,4], rtol=1e01)
        np.testing.assert_allclose(t_cos, rslt.tvalues[:,4], rtol=1e01)
        np.testing.assert_allclose(est_south, rslt.params[:,5], rtol=1e01)
        np.testing.assert_allclose(se_south, rslt.bse[:,5], rtol=1e01)
        np.testing.assert_allclose(t_south, rslt.tvalues[:,5], rtol=1e01)
        np.testing.assert_allclose(est_strm, rslt.params[:,6], rtol=1e02)
        np.testing.assert_allclose(se_strm, rslt.bse[:,6], rtol=1e01)
        np.testing.assert_allclose(t_strm, rslt.tvalues[:,6], rtol=1e02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-01)
        #This test fails - likely due to compound rounding errors
        #Has been tested using statsmodels.family calculations and
        #code from Jing's python version, which both yield the same
        #np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)
    
    def test_BS_NN(self):
        est_Int = self.BS_NN.by_col(' est_Intercept')
        se_Int = self.BS_NN.by_col(' se_Intercept')
        t_Int = self.BS_NN.by_col(' t_Intercept')
        est_elev = self.BS_NN.by_col(' est_Elev')
        se_elev = self.BS_NN.by_col(' se_Elev')
        t_elev = self.BS_NN.by_col(' t_Elev')
        est_slope = self.BS_NN.by_col(' est_Slope')
        se_slope = self.BS_NN.by_col(' se_Slope')
        t_slope = self.BS_NN.by_col(' t_Slope')
        est_sin = self.BS_NN.by_col(' est_SinAspct')
        se_sin = self.BS_NN.by_col(' se_SinAspct')
        t_sin = self.BS_NN.by_col(' t_SinAspct')
        est_cos = self.BS_NN.by_col(' est_CosAspct')
        se_cos = self.BS_NN.by_col(' se_CosAspct')
        t_cos = self.BS_NN.by_col(' t_CosAspct')
        est_south = self.BS_NN.by_col(' est_AbsSouth')
        se_south = self.BS_NN.by_col(' se_AbsSouth')
        t_south = self.BS_NN.by_col(' t_AbsSouth')
        est_strm = self.BS_NN.by_col(' est_DistStrm')
        se_strm = self.BS_NN.by_col(' se_DistStrm')
        t_strm = self.BS_NN.by_col(' t_DistStrm') 
        yhat = self.BS_NN.by_col(' yhat')
        pdev = self.BS_NN.by_col(' localpdev')
        
        model = GWR(self.coords, self.y, self.X, bw=158, family=Binomial(), 
                kernel='bisquare', fixed=False, sigma2_v1=False)
        rslt = model.fit()

        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 277.0)
        self.assertAlmostEquals(np.floor(AIC), 271.0)
        self.assertAlmostEquals(np.floor(BIC), 358.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-00)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-00)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-00)
        np.testing.assert_allclose(est_elev, rslt.params[:,1], rtol=1e-00)
        np.testing.assert_allclose(se_elev, rslt.bse[:,1], rtol=1e-00)
        np.testing.assert_allclose(t_elev, rslt.tvalues[:,1], rtol=1e-00)
        np.testing.assert_allclose(est_slope, rslt.params[:,2], rtol=1e-00)
        np.testing.assert_allclose(se_slope, rslt.bse[:,2], rtol=1e-00)
        np.testing.assert_allclose(t_slope, rslt.tvalues[:,2], rtol=1e-00)
        np.testing.assert_allclose(est_sin, rslt.params[:,3], rtol=1e01)
        np.testing.assert_allclose(se_sin, rslt.bse[:,3], rtol=1e01)
        np.testing.assert_allclose(t_sin, rslt.tvalues[:,3], rtol=1e01)
        np.testing.assert_allclose(est_cos, rslt.params[:,4], rtol=1e01)
        np.testing.assert_allclose(se_cos, rslt.bse[:,4], rtol=1e01)
        np.testing.assert_allclose(t_cos, rslt.tvalues[:,4], rtol=1e01)
        np.testing.assert_allclose(est_south, rslt.params[:,5], rtol=1e01)
        np.testing.assert_allclose(se_south, rslt.bse[:,5], rtol=1e01)
        np.testing.assert_allclose(t_south, rslt.tvalues[:,5], rtol=1e01)
        np.testing.assert_allclose(est_strm, rslt.params[:,6], rtol=1e03)
        np.testing.assert_allclose(se_strm, rslt.bse[:,6], rtol=1e01)
        np.testing.assert_allclose(t_strm, rslt.tvalues[:,6], rtol=1e03)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-01)
        #This test fails - likely due to compound rounding errors
        #Has been tested using statsmodels.family calculations and
        #code from Jing's python version, which both yield the same
        #np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)

    def test_GS_F(self):
        est_Int = self.GS_F.by_col(' est_Intercept')
        se_Int = self.GS_F.by_col(' se_Intercept')
        t_Int = self.GS_F.by_col(' t_Intercept')
        est_elev = self.GS_F.by_col(' est_Elev')
        se_elev = self.GS_F.by_col(' se_Elev')
        t_elev = self.GS_F.by_col(' t_Elev')
        est_slope = self.GS_F.by_col(' est_Slope')
        se_slope = self.GS_F.by_col(' se_Slope')
        t_slope = self.GS_F.by_col(' t_Slope')
        est_sin = self.GS_F.by_col(' est_SinAspct')
        se_sin = self.GS_F.by_col(' se_SinAspct')
        t_sin = self.GS_F.by_col(' t_SinAspct')
        est_cos = self.GS_F.by_col(' est_CosAspct')
        se_cos = self.GS_F.by_col(' se_CosAspct')
        t_cos = self.GS_F.by_col(' t_CosAspct')
        est_south = self.GS_F.by_col(' est_AbsSouth')
        se_south = self.GS_F.by_col(' se_AbsSouth')
        t_south = self.GS_F.by_col(' t_AbsSouth')
        est_strm = self.GS_F.by_col(' est_DistStrm')
        se_strm = self.GS_F.by_col(' se_DistStrm')
        t_strm = self.GS_F.by_col(' t_DistStrm') 
        yhat = self.GS_F.by_col(' yhat')
        pdev = self.GS_F.by_col(' localpdev')

        model = GWR(self.coords, self.y, self.X, bw=8929.061, family=Binomial(), 
                kernel='gaussian', fixed=True, sigma2_v1=False)
        rslt = model.fit()
        
        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 276.0)
        self.assertAlmostEquals(np.floor(AIC), 272.0)
        self.assertAlmostEquals(np.floor(BIC), 341.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-00)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-00)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-00)
        np.testing.assert_allclose(est_elev, rslt.params[:,1], rtol=1e-00)
        np.testing.assert_allclose(se_elev, rslt.bse[:,1], rtol=1e-00)
        np.testing.assert_allclose(t_elev, rslt.tvalues[:,1], rtol=1e-00)
        np.testing.assert_allclose(est_slope, rslt.params[:,2], rtol=1e-00)
        np.testing.assert_allclose(se_slope, rslt.bse[:,2], rtol=1e-00)
        np.testing.assert_allclose(t_slope, rslt.tvalues[:,2], rtol=1e-00)
        np.testing.assert_allclose(est_sin, rslt.params[:,3], rtol=1e01)
        np.testing.assert_allclose(se_sin, rslt.bse[:,3], rtol=1e01)
        np.testing.assert_allclose(t_sin, rslt.tvalues[:,3], rtol=1e01)
        np.testing.assert_allclose(est_cos, rslt.params[:,4], rtol=1e01)
        np.testing.assert_allclose(se_cos, rslt.bse[:,4], rtol=1e01)
        np.testing.assert_allclose(t_cos, rslt.tvalues[:,4], rtol=1e01)
        np.testing.assert_allclose(est_south, rslt.params[:,5], rtol=1e01)
        np.testing.assert_allclose(se_south, rslt.bse[:,5], rtol=1e01)
        np.testing.assert_allclose(t_south, rslt.tvalues[:,5], rtol=1e01)
        np.testing.assert_allclose(est_strm, rslt.params[:,6], rtol=1e02)
        np.testing.assert_allclose(se_strm, rslt.bse[:,6], rtol=1e01)
        np.testing.assert_allclose(t_strm, rslt.tvalues[:,6], rtol=1e02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-01)
        #This test fails - likely due to compound rounding errors
        #Has been tested using statsmodels.family calculations and
        #code from Jing's python version, which both yield the same
        #np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)

    def test_GS_NN(self):
        est_Int = self.GS_NN.by_col(' est_Intercept')
        se_Int = self.GS_NN.by_col(' se_Intercept')
        t_Int = self.GS_NN.by_col(' t_Intercept')
        est_elev = self.GS_NN.by_col(' est_Elev')
        se_elev = self.GS_NN.by_col(' se_Elev')
        t_elev = self.GS_NN.by_col(' t_Elev')
        est_slope = self.GS_NN.by_col(' est_Slope')
        se_slope = self.GS_NN.by_col(' se_Slope')
        t_slope = self.GS_NN.by_col(' t_Slope')
        est_sin = self.GS_NN.by_col(' est_SinAspct')
        se_sin = self.GS_NN.by_col(' se_SinAspct')
        t_sin = self.GS_NN.by_col(' t_SinAspct')
        est_cos = self.GS_NN.by_col(' est_CosAspct')
        se_cos = self.GS_NN.by_col(' se_CosAspct')
        t_cos = self.GS_NN.by_col(' t_CosAspct')
        est_south = self.GS_NN.by_col(' est_AbsSouth')
        se_south = self.GS_NN.by_col(' se_AbsSouth')
        t_south = self.GS_NN.by_col(' t_AbsSouth')
        est_strm = self.GS_NN.by_col(' est_DistStrm')
        se_strm = self.GS_NN.by_col(' se_DistStrm')
        t_strm = self.GS_NN.by_col(' t_DistStrm') 
        yhat = self.GS_NN.by_col(' yhat')
        pdev = self.GS_NN.by_col(' localpdev')
        
        model = GWR(self.coords, self.y, self.X, bw=64, family=Binomial(), 
                kernel='gaussian', fixed=False, sigma2_v1=False)
        rslt = model.fit()

        AICc = get_AICc(rslt)
        AIC = get_AIC(rslt)
        BIC = get_BIC(rslt)
        
        self.assertAlmostEquals(np.floor(AICc), 276.0)
        self.assertAlmostEquals(np.floor(AIC), 273.0)
        self.assertAlmostEquals(np.floor(BIC), 331.0)
        np.testing.assert_allclose(est_Int, rslt.params[:,0], rtol=1e-00)
        np.testing.assert_allclose(se_Int, rslt.bse[:,0], rtol=1e-00)
        np.testing.assert_allclose(t_Int, rslt.tvalues[:,0], rtol=1e-00)
        np.testing.assert_allclose(est_elev, rslt.params[:,1], rtol=1e-00)
        np.testing.assert_allclose(se_elev, rslt.bse[:,1], rtol=1e-00)
        np.testing.assert_allclose(t_elev, rslt.tvalues[:,1], rtol=1e-00)
        np.testing.assert_allclose(est_slope, rslt.params[:,2], rtol=1e-00)
        np.testing.assert_allclose(se_slope, rslt.bse[:,2], rtol=1e-00)
        np.testing.assert_allclose(t_slope, rslt.tvalues[:,2], rtol=1e-00)
        np.testing.assert_allclose(est_sin, rslt.params[:,3], rtol=1e01)
        np.testing.assert_allclose(se_sin, rslt.bse[:,3], rtol=1e01)
        np.testing.assert_allclose(t_sin, rslt.tvalues[:,3], rtol=1e01)
        np.testing.assert_allclose(est_cos, rslt.params[:,4], rtol=1e01)
        np.testing.assert_allclose(se_cos, rslt.bse[:,4], rtol=1e01)
        np.testing.assert_allclose(t_cos, rslt.tvalues[:,4], rtol=1e01)
        np.testing.assert_allclose(est_south, rslt.params[:,5], rtol=1e01)
        np.testing.assert_allclose(se_south, rslt.bse[:,5], rtol=1e01)
        np.testing.assert_allclose(t_south, rslt.tvalues[:,5], rtol=1e01)
        np.testing.assert_allclose(est_strm, rslt.params[:,6], rtol=1e02)
        np.testing.assert_allclose(se_strm, rslt.bse[:,6], rtol=1e01)
        np.testing.assert_allclose(t_strm, rslt.tvalues[:,6], rtol=1e02)
        np.testing.assert_allclose(yhat, rslt.mu, rtol=1e-00)
        #This test fails - likely due to compound rounding errors
        #Has been tested using statsmodels.family calculations and
        #code from Jing's python version, which both yield the same
        #np.testing.assert_allclose(pdev, rslt.pDev, rtol=1e-05)

if __name__ == '__main__':
	unittest.main()
