def test_representation():
# Test an invalid number of states
def zero_kstates():
mod = Representation(1, 0)
assert_raises(ValueError, zero_kstates)
# Test an invalid endogenous array
def empty_endog():
endog = np.zeros((0,0))
mod = Representation(endog, k_states=2)
assert_raises(ValueError, empty_endog)
# Test a Fortran-ordered endogenous array (which will be assumed to be in
# wide format: k_endog x nobs)
nobs = 10
k_endog = 2
endog = np.asfortranarray(np.arange(nobs*k_endog).reshape(k_endog,nobs)*1.)
mod = Representation(endog, k_states=2)
assert_equal(mod.nobs, nobs)
assert_equal(mod.k_endog, k_endog)
# Test a C-ordered endogenous array (which will be assumed to be in
# tall format: nobs x k_endog)
nobs = 10
k_endog = 2
endog = np.arange(nobs*k_endog).reshape(nobs,k_endog)*1.
mod = Representation(endog, k_states=2)
assert_equal(mod.nobs, nobs)
assert_equal(mod.k_endog, k_endog)
# Test getting the statespace representation
assert_equal(mod._statespace, None)
mod._initialize_representation()
assert(mod._statespace is not None)
def test_initialization():
# Test Kalman filter initialization
mod = Representation(1, k_states=2)
# Test invalid state initialization
assert_raises(RuntimeError, lambda: mod._initialize_state())
# Test valid initialization
initial_state = np.zeros(2,) + 1.5
initial_state_cov = np.eye(2) * 3.
mod.initialize_known(initial_state, initial_state_cov)
assert_equal(mod.initialization.constant.sum(), 3)
assert_equal(mod.initialization.stationary_cov.diagonal().sum(), 6)
# Test invalid initial_state
initial_state = np.zeros(10,)
with pytest.raises(ValueError):
mod.initialize_known(initial_state, initial_state_cov)
initial_state = np.zeros((10, 10))
with pytest.raises(ValueError):
mod.initialize_known(initial_state, initial_state_cov)
# Test invalid initial_state_cov
initial_state = np.zeros(2,) + 1.5
initial_state_cov = np.eye(3)
with pytest.raises(ValueError):
mod.initialize_known(initial_state, initial_state_cov)
def test_initialization():
# Test Kalman filter initialization
mod = Representation(1, k_states=2)
# Test invalid state initialization
assert_raises(RuntimeError, lambda: mod._initialize_state())
# Test valid initialization
initial_state = np.zeros(2, ) + 1.5
initial_state_cov = np.eye(2) * 3.
mod.initialize_known(initial_state, initial_state_cov)
assert_equal(mod.initialization.constant.sum(), 3)
assert_equal(mod.initialization.stationary_cov.diagonal().sum(), 6)
# Test invalid initial_state
initial_state = np.zeros(10, )
assert_raises(
ValueError,
lambda: mod.initialize_known(initial_state, initial_state_cov))
initial_state = np.zeros((10, 10))
assert_raises(
ValueError,
lambda: mod.initialize_known(initial_state, initial_state_cov))
# Test invalid initial_state_cov
initial_state = np.zeros(2, ) + 1.5
initial_state_cov = np.eye(3)
assert_raises(
ValueError,
lambda: mod.initialize_known(initial_state, initial_state_cov))
def test_representation_pickle():
nobs = 10
k_endog = 2
endog = np.asfortranarray(np.arange(nobs * k_endog).reshape(k_endog, nobs) * 1.)
mod = Representation(endog, k_states=2)
pkl_mod = cPickle.loads(cPickle.dumps(mod))
assert_equal(mod.nobs, pkl_mod.nobs)
assert_equal(mod.k_endog, pkl_mod.k_endog)
mod._initialize_representation()
pkl_mod._initialize_representation()
assert_equal(mod.design, pkl_mod.design)
assert_equal(mod.obs_intercept, pkl_mod.obs_intercept)
assert_equal(mod.initial_variance, pkl_mod.initial_variance)
def test_representation_pickle():
nobs = 10
k_endog = 2
endog = np.asfortranarray(np.arange(nobs * k_endog).reshape(k_endog, nobs) * 1.)
mod = Representation(endog, k_states=2)
pkl_mod = cPickle.loads(cPickle.dumps(mod))
assert_equal(mod.nobs, pkl_mod.nobs)
assert_equal(mod.k_endog, pkl_mod.k_endog)
mod._initialize_representation()
pkl_mod._initialize_representation()
assert_equal(mod.design, pkl_mod.design)
assert_equal(mod.obs_intercept, pkl_mod.obs_intercept)
assert_equal(mod.initial_variance, pkl_mod.initial_variance)
def test_init_matrices_time_invariant():
# Test setting state space system matrices in __init__, with time-invariant
# matrices
k_endog = 2
k_states = 3
k_posdef = 1
endog = np.zeros((10, 2))
obs_intercept = np.arange(k_endog) * 1.0
design = np.reshape(
np.arange(k_endog * k_states) * 1.0, (k_endog, k_states))
obs_cov = np.reshape(np.arange(k_endog**2) * 1.0, (k_endog, k_endog))
state_intercept = np.arange(k_states) * 1.0
transition = np.reshape(np.arange(k_states**2) * 1.0, (k_states, k_states))
selection = np.reshape(
np.arange(k_states * k_posdef) * 1.0, (k_states, k_posdef))
state_cov = np.reshape(np.arange(k_posdef**2) * 1.0, (k_posdef, k_posdef))
mod = Representation(endog, k_states=k_states, k_posdef=k_posdef,
obs_intercept=obs_intercept, design=design,
obs_cov=obs_cov, state_intercept=state_intercept,
transition=transition, selection=selection,
state_cov=state_cov)
assert_allclose(mod['obs_intercept'], obs_intercept)
assert_allclose(mod['design'], design)
assert_allclose(mod['obs_cov'], obs_cov)
assert_allclose(mod['state_intercept'], state_intercept)
assert_allclose(mod['transition'], transition)
assert_allclose(mod['selection'], selection)
assert_allclose(mod['state_cov'], state_cov)
def test_representation():
# Test an invalid number of states
def zero_kstates():
mod = Representation(1, 0)
assert_raises(ValueError, zero_kstates)
# Test an invalid endogenous array
def empty_endog():
endog = np.zeros((0,0))
mod = Representation(endog, k_states=2)
assert_raises(ValueError, empty_endog)
# Test a Fortran-ordered endogenous array (which will be assumed to be in
# wide format: k_endog x nobs)
nobs = 10
k_endog = 2
endog = np.asfortranarray(np.arange(nobs*k_endog).reshape(k_endog,nobs)*1.)
mod = Representation(endog, k_states=2)
assert_equal(mod.nobs, nobs)
assert_equal(mod.k_endog, k_endog)
# Test a C-ordered endogenous array (which will be assumed to be in
# tall format: nobs x k_endog)
nobs = 10
k_endog = 2
endog = np.arange(nobs*k_endog).reshape(nobs,k_endog)*1.
mod = Representation(endog, k_states=2)
assert_equal(mod.nobs, nobs)
assert_equal(mod.k_endog, k_endog)
# Test getting the statespace representation
assert_equal(mod._statespace, None)
mod._initialize_representation()
assert(mod._statespace is not None)
def test_initialization():
mod = Representation(1, k_states=2)
# Test invalid state initialization
assert_raises(RuntimeError, lambda: mod._initialize_state())
# Test valid initialization
initial_state = np.zeros(2,) + 1.5
initial_state_cov = np.eye(2) * 3.
mod.initialize_known(initial_state, initial_state_cov)
assert_equal(mod._initial_state.sum(), 3)
assert_equal(mod._initial_state_cov.diagonal().sum(), 6)
# Test invalid initial_state
initial_state = np.zeros(10,)
assert_raises(ValueError, lambda: mod.initialize_known(initial_state, initial_state_cov))
initial_state = np.zeros((10,10))
assert_raises(ValueError, lambda: mod.initialize_known(initial_state, initial_state_cov))
# Test invalid initial_state_cov
initial_state = np.zeros(2,) + 1.5
initial_state_cov = np.eye(3)
assert_raises(ValueError, lambda: mod.initialize_known(initial_state, initial_state_cov))
def test_bind():
# Test binding endogenous data to Kalman filter
mod = Representation(2, k_states=2)
# Test invalid endogenous array (it must be ndarray)
assert_raises(ValueError, lambda: mod.bind([1, 2, 3, 4]))
# Test valid (nobs x 1) endogenous array
mod.bind(np.arange(10).reshape((5, 2)) * 1.)
assert_equal(mod.nobs, 5)
# Test valid (k_endog x 0) endogenous array
mod.bind(np.zeros((0, 2), dtype=np.float64))
# Test invalid (3-dim) endogenous array
assert_raises(ValueError,
lambda: mod.bind(np.arange(12).reshape(2, 2, 3) * 1.))
# Test valid F-contiguous
mod.bind(np.asfortranarray(np.arange(10).reshape(2, 5)))
assert_equal(mod.nobs, 5)
# Test valid C-contiguous
mod.bind(np.arange(10).reshape(5, 2))
assert_equal(mod.nobs, 5)
# Test invalid F-contiguous
assert_raises(
ValueError,
lambda: mod.bind(np.asfortranarray(np.arange(10).reshape(5, 2))))
# Test invalid C-contiguous
assert_raises(ValueError, lambda: mod.bind(np.arange(10).reshape(2, 5)))
def empty_endog():
endog = np.zeros((0, 0))
mod = Representation(endog, k_states=2)
def zero_kstates():
mod = Representation(1, 0)
def test_bind():
mod = Representation(1, k_states=2)
# Test invalid endogenous array (it must be ndarray)
assert_raises(ValueError, lambda: mod.bind([1,2,3,4]))
# Test valid (nobs x 1) endogenous array
mod.bind(np.arange(10)*1.)
assert_equal(mod.nobs, 10)
# Test valid (k_endog x 0) endogenous array
mod.bind(np.zeros(0,dtype=np.float64))
# Test invalid (3-dim) endogenous array
assert_raises(ValueError, lambda: mod.bind(np.arange(12).reshape(2,2,3)*1.))
# Test valid F-contiguous
mod.bind(np.asfortranarray(np.arange(10).reshape(1,10)))
assert_equal(mod.nobs, 10)
# Test valid C-contiguous
mod.bind(np.arange(10).reshape(10,1))
assert_equal(mod.nobs, 10)
# Test invalid F-contiguous
assert_raises(ValueError, lambda: mod.bind(np.asfortranarray(np.arange(10).reshape(10,1))))
# Test invalid C-contiguous
assert_raises(ValueError, lambda: mod.bind(np.arange(10).reshape(1,10)))
def test_bind():
# Test binding endogenous data to Kalman filter
mod = Representation(2, k_states=2)
# Test invalid endogenous array (it must be ndarray)
assert_raises(ValueError, lambda: mod.bind([1,2,3,4]))
# Test valid (nobs x 1) endogenous array
mod.bind(np.arange(10).reshape((5,2))*1.)
assert_equal(mod.nobs, 5)
# Test valid (k_endog x 0) endogenous array
mod.bind(np.zeros((0,2),dtype=np.float64))
# Test invalid (3-dim) endogenous array
assert_raises(ValueError, lambda: mod.bind(np.arange(12).reshape(2,2,3)*1.))
# Test valid F-contiguous
mod.bind(np.asfortranarray(np.arange(10).reshape(2,5)))
assert_equal(mod.nobs, 5)
# Test valid C-contiguous
mod.bind(np.arange(10).reshape(5,2))
assert_equal(mod.nobs, 5)
# Test invalid F-contiguous
assert_raises(ValueError, lambda: mod.bind(np.asfortranarray(np.arange(10).reshape(5,2))))
# Test invalid C-contiguous
assert_raises(ValueError, lambda: mod.bind(np.arange(10).reshape(2,5)))
if NumpyVersion(np.__version__) < '0.10.0':
mod = Representation(1, k_states=2)
# Test valid F-contiguous
mod.bind(np.asfortranarray(np.arange(10).reshape(1,10)))
assert_equal(mod.nobs, 10)
# Test valid C-contiguous
mod.bind(np.arange(10).reshape(10,1))
assert_equal(mod.nobs, 10)
# Test invalid F-contiguous
assert_raises(ValueError, lambda: mod.bind(np.asfortranarray(np.arange(10).reshape(10,1))))
# Test invalid C-contiguous
assert_raises(ValueError, lambda: mod.bind(np.arange(10).reshape(1,10)))
