def test_dummy_sparse(self):
        data = self.data
        self.grouping.dummy_sparse()
        expected = categorical(data.index.get_level_values(0).values,
                               drop=True)
        np.testing.assert_equal(self.grouping._dummies.toarray(), expected)

        if len(self.grouping.group_names) > 1:
            self.grouping.dummy_sparse(level=1)
            expected = categorical(data.index.get_level_values(1).values,
                    drop=True)
            np.testing.assert_equal(self.grouping._dummies.toarray(),
                                    expected)

def test_issue302():
    arr = np.rec.fromrecords([[10, 12], [11, 13]], names=['group', 'whatever'])
    actual = tools.categorical(arr, col=['group'])
    expected = np.rec.array([(10, 12, 1.0, 0.0), (11, 13, 0.0, 1.0)],
        dtype=[('group', int), ('whatever', int), ('group_10', float),
               ('group_11', float)])
    assert_array_equal(actual, expected)

def test_rec_issue302():
    arr = np.rec.fromrecords([[10], [11]], names="group")
    actual = tools.categorical(arr)
    expected = np.rec.array(
        [(10, 1.0, 0.0), (11, 0.0, 1.0)], dtype=[("group", int), ("group_10", float), ("group_11", float)]
    )
    assert_array_equal(actual, expected)

def test_const_indicator():
    np.random.seed(12345)
    X = np.random.randint(0, 3, size=30)
    X = categorical(X, drop=True)
    y = np.dot(X, [1., 2., 3.]) + np.random.normal(size=30)
    modc = OLS(y, add_constant(X[:,1:], prepend=True)).fit()
    mod = OLS(y, X, hasconst=True).fit()
    assert_almost_equal(modc.rsquared, mod.rsquared, 12)

def test_issue302():
    arr = np.rec.fromrecords([[10, 12], [11, 13]], names=["group", "whatever"])
    actual = tools.categorical(arr, col=["group"])
    expected = np.rec.array(
        [(10, 12, 1.0, 0.0), (11, 13, 0.0, 1.0)],
        dtype=[("group", int), ("whatever", int), ("group_10", float), ("group_11", float)],
    )
    assert_array_equal(actual, expected)

def test_fvalue_const_only():
    np.random.seed(12345)
    x = np.random.randint(0, 3, size=30)
    x = categorical(x, drop=True)
    x[:, 0] = 1
    y = np.dot(x, [1., 2., 3.]) + np.random.normal(size=30)
    res = OLS(y, x, hasconst=True).fit(cov_type='HC1')
    assert not np.isnan(res.fvalue)

def test_const_indicator():
    np.random.seed(12345)
    X = np.random.randint(0, 3, size=30)
    X = categorical(X, drop=True)
    y = np.dot(X, [1., 2., 3.]) + np.random.normal(size=30)
    resc = OLS(y, add_constant(X[:, 1:], prepend=True)).fit()
    res = OLS(y, X, hasconst=True).fit()
    assert_almost_equal(resc.rsquared, res.rsquared, 12)
    assert res.model.data.k_constant == 1
    assert resc.model.data.k_constant == 1

 def test_array2d_drop(self):
     des = np.column_stack((self.des, self.instr, self.des))
     des = tools.categorical(des, col=2, drop=True)
     assert_array_equal(des[:, -5:], self.dummy)
     assert_equal(des.shape[1], 9)

 def test_structarray1d_drop(self):
     instr = self.structdes["str_instr"].view(dtype=[("var1", "a10")])
     dum = tools.categorical(instr, drop=True)
     test_dum = np.column_stack(([dum[_] for _ in dum.dtype.names]))
     assert_array_equal(test_dum, self.dummy)
     assert_equal(len(dum.dtype.names), 5)

 def test_structarray2d_drop(self):
     des = tools.categorical(self.structdes, col="str_instr", drop=True)
     test_des = np.column_stack(([des[_] for _ in des.dtype.names[-5:]]))
     assert_array_equal(test_des, self.dummy)
     assert_equal(len(des.dtype.names), 8)

 def test_structarray2dint(self):
     des = tools.categorical(self.structdes, col=3)
     test_des = np.column_stack(([des[_] for _ in des.dtype.names[-5:]]))
     assert_array_equal(test_des, self.dummy)
     assert_equal(len(des.dtype.names), 9)

 def test_recarray1d(self):
     instr = self.structdes["str_instr"].view(np.recarray)
     dum = tools.categorical(instr)
     test_dum = np.column_stack(([dum[_] for _ in dum.dtype.names[-5:]]))
     assert_array_equal(test_dum, self.dummy)
     assert_equal(len(dum.dtype.names), 6)

 def test_recarray2d(self):
     des = tools.categorical(self.recdes, col="str_instr")
     # better way to do this?
     test_des = np.column_stack(([des[_] for _ in des.dtype.names[-5:]]))
     assert_array_equal(test_des, self.dummy)
     assert_equal(len(des.dtype.names), 9)

 def test_array1d_drop(self):
     des = tools.categorical(self.string_var, drop=True)
     assert_array_equal(des, self.dummy)
     assert_equal(des.shape[1], 5)

 def test_structarray1d(self):
     instr = self.structdes["instrument"].view(dtype=[("var1", "f4")])
     dum = tools.categorical(instr)
     test_dum = np.column_stack(([dum[_] for _ in dum.dtype.names[-5:]]))
     assert_array_equal(test_dum, self.dummy)
     assert_equal(len(dum.dtype.names), 6)

 def test_arraylike2d_drop(self):
     des = tools.categorical(self.structdes.tolist(), col=2, drop=True)
     test_des = des[:,-5:]
     assert_array_equal(test_des, self.dummy)
     assert_equal(des.shape[1], 8)

 def test_array1d(self):
     des = tools.categorical(self.instr)
     assert_array_equal(des[:, -5:], self.dummy)
     assert_equal(des.shape[1], 6)

 def test_arraylike1d_drop(self):
     instr = self.structdes['instrument'].tolist()
     dum = tools.categorical(instr, drop=True)
     assert_array_equal(dum, self.dummy)
     assert_equal(dum.shape[1], 5)

 def test_array2d(self):
     des1 = np.column_stack((self.des, self.instr, self.des))
     des = tools.categorical(des1, col=2)
     assert_array_equal(des[:,-5:], self.dummy)
     assert_equal(des.shape[1],10)

 def test_recarray1d_drop(self):
     instr = self.structdes["instrument"].view(np.recarray)
     dum = tools.categorical(instr, drop=True)
     test_dum = np.column_stack(([dum[_] for _ in dum.dtype.names]))
     assert_array_equal(test_dum, self.dummy)
     assert_equal(len(dum.dtype.names), 5)