← Back to branch summary

~pythonxy/pythonxy-upstream/python-pandas

« back to all changes in this revision

Viewing changes to pandas/core/tests/test_datamatrix.py

  • Committer: Wes McKinney
  • Date: 2009-08-05 03:30:16 UTC
  • Revision ID: git-v1:c6b236db73ff81007909be6406f0e484edc4a9eb
first commit with cleaned up code

git-svn-id: http://pandas.googlecode.com/svn/trunk@5 d5231056-7de3-11de-ac95-d976489f1ece

Show diffs side-by-side

added added

removed removed

Lines of Context:
pandas/core/tests/test_datamatrix.py
 
1
from pandas.core.daterange import DateRange
 
2
from pandas.core.datetools import bday
 
3
from pandas.core.index import Index, NULL_INDEX
 
4
from pandas.core.matrix import DataMatrix
 
5
from pandas.core.series import Series
 
6
from pandas.lib.tseries import map_indices
 
7
from copy import deepcopy
 
8
from datetime import datetime
 
9
from numpy import isnan, array, NaN, alltrue
 
10
from numpy import random
 
11
from random import choice
 
12
import numpy as np
 
13
import pickle
 
14
import string
 
15
import unittest
 
16
 
 
17
def rands(n):
 
18
    return ''.join([choice(string.letters + string.digits) for i in range(n)])
 
19
def equalContents(arr1, arr2):
 
20
    """Checks if the set of unique elements of arr1 and arr2 are equivalent.
 
21
    """
 
22
    return frozenset(arr1) == frozenset(arr2)
 
23
 
 
24
#-------------------------------------------------------------------------------
 
25
# DataMatrix test cases
 
26
 
 
27
class TestDataMatrix(unittest.TestCase):
 
28
    def setUp(self):
 
29
        index1 = DateRange(datetime(2008,4,22), periods=50)
 
30
        index2 = DateRange(datetime(2008,4,29), periods=50)
 
31
        index3 = DateRange(datetime(2008,4,28), periods=50)
 
32
        ts1 = Series(random.random(50), index=index1)
 
33
        ts2 = Series(random.random(50), index=index2)
 
34
        ts3 = Series(random.random(50), index=index3)
 
35
        ts4 = Series(random.random(50), index=index1)
 
36
        data = {'col1' : ts1,'col2' : ts2,'col3' : ts3, 'col4' : ts4}
 
37
        self.frame = DataMatrix(data=data, index=index3)
 
38
        self.ts1 = ts1
 
39
        self.ts2 = ts2
 
40
        self.ts3 = ts3
 
41
        self.ts4 = ts4
 
42
 
 
43
    def testReindex(self):
 
44
        newFrame = self.frame.reindex(self.ts1.index)
 
45
        for col in newFrame.cols():
 
46
            for idx, val in newFrame[col].iteritems():
 
47
                if idx in self.frame.index:
 
48
                    if isnan(val):
 
49
                        self.assert_(isnan(self.frame[col][idx]))
 
50
                    else:
 
51
                        self.assertEqual(val, self.frame[col][idx])
 
52
                else:
 
53
                    self.assert_(isnan(val))
 
54
        for col, series in newFrame.iteritems():
 
55
            self.assert_(equalContents(series.index, newFrame.index))    
 
56
        emptyFrame = self.frame.reindex(Index([]))
 
57
        self.assert_(len(emptyFrame.index) == 0)
 
58
 
 
59
        nonContigFrame = self.frame.reindex(self.ts1.index[::2])
 
60
        for col in nonContigFrame.cols():
 
61
            for idx, val in nonContigFrame[col].iteritems():
 
62
                if idx in self.frame.index:
 
63
                    if isnan(val):
 
64
                        self.assert_(isnan(self.frame[col][idx]))
 
65
                    else:
 
66
                        self.assertEqual(val, self.frame[col][idx])
 
67
                else:
 
68
                    self.assert_(isnan(val))
 
69
        for col, series in nonContigFrame.iteritems():
 
70
            self.assert_(equalContents(series.index, nonContigFrame.index))    
 
71
 
 
72
    def testShift(self):
 
73
        shiftedFrame = self.frame.shift(5)
 
74
        for i, idx in enumerate(shiftedFrame.index):
 
75
            self.assert_(idx-5*bday == self.frame.index[i])
 
76
        series = shiftedFrame['col1']
 
77
        for i, idx in enumerate(series.index):
 
78
            self.assert_(idx-5*bday == self.frame.index[i])        
 
79
 
 
80
    def testOperators(self):
 
81
        garbage = random.random(4)
 
82
        colSeries = Series(garbage, index=array(self.frame.cols()))
 
83
        idSum = self.frame + self.frame
 
84
        seriesSum = self.frame + colSeries
 
85
        for col, series in idSum.iteritems():
 
86
            for idx, val in series.iteritems():
 
87
                origVal = self.frame[col][idx] * 2
 
88
                if not isnan(val):
 
89
                    self.assertEqual(val, origVal)
 
90
                else:
 
91
                    self.assert_(isnan(origVal))
 
92
        for col, series in seriesSum.iteritems():
 
93
            for idx, val in series.iteritems():
 
94
                origVal = self.frame[col][idx] + colSeries[col]
 
95
                if not isnan(val):
 
96
                    self.assertEqual(val, origVal)
 
97
                else:
 
98
                    self.assert_(isnan(origVal))
 
99
 
 
100
    def testSlice(self):
 
101
        """Slicing NOT intended for production code"""
 
102
        slice = self.frame[:20]
 
103
        self.assertEqual(20, len(slice.index))
 
104
        for col, series in slice.iteritems():
 
105
            self.assertEqual(20, len(series.index))
 
106
            self.assert_(equalContents(series.index, slice.index))
 
107
 
 
108
    def testGetItem(self):
 
109
        for key, value in self.frame._series.iteritems():
 
110
            self.assert_(self.frame[key] is not None)
 
111
        self.assert_('random' not in self.frame)
 
112
        
 
113
#    def testGetRow(self):
 
114
#        rowFrame = self.frame.getRow(self.frame.index[5])
 
115
#        idx = rowFrame.index[0]
 
116
#        self.assertEquals(idx, self.frame.index[5])
 
117
#        for key, values in rowFrame.iteritems():
 
118
#            self.assertEquals(self.frame[key][idx], values[0])
 
119
#            self.assertEquals(self.frame[key][idx], values[idx])
 
120
        
 
121
    def testStack(self):
 
122
        frameSlice = self.frame.getTS(fromDate=self.frame.index[0], nPeriods=5)
 
123
        stacked = frameSlice.stack()
 
124
        for idx, value in stacked.iteritems():
 
125
            date, col = idx.split(';')
 
126
            date = datetime.fromordinal(int(date))
 
127
            if isnan(value):
 
128
                self.assert_(isnan(frameSlice[col][date]))
 
129
            else:
 
130
                self.assertEquals(value, frameSlice[col][date])
 
131
        
 
132
        unstacked = stacked.unstack().T
 
133
        
 
134
        for i, idx in enumerate(unstacked.index):
 
135
            self.assertEquals(idx, frameSlice.index[i])
 
136
        for col, series in unstacked.iteritems():
 
137
            for idx, value in series.iteritems():
 
138
                if isnan(value):
 
139
                    self.assert_(isnan(frameSlice[col][idx]))
 
140
                else:                
 
141
                    self.assertEquals(value, frameSlice[col][idx])
 
142
 
 
143
    def testSetItem(self):
 
144
        # not sure what else to do here
 
145
        series = self.frame['col1']
 
146
        self.frame['col5'] = series
 
147
        self.assert_('col5' in self.frame)
 
148
 
 
149
    def testStatistics(self):
 
150
        sumFrame = self.frame.apply(np.sum)
 
151
        for col, series in self.frame.iteritems():
 
152
            val = sumFrame[col]
 
153
            if isnan(val):
 
154
                print self.frame[col]
 
155
            self.assertEqual(val, series.sum())
 
156
        
 
157
    def testDelItem(self):
 
158
        del self.frame['col1']
 
159
        self.assert_('col1' not in self.frame)
 
160
        self.assert_('col1' not in self.frame._series)
 
161
 
 
162
    def testGetXS(self):
 
163
        idx = self.frame.index[5]
 
164
        xs = self.frame.getXS(idx)
 
165
        for item, value in xs.iteritems():
 
166
            if isnan(value):
 
167
                self.assert_(isnan(self.frame[item][idx]))
 
168
            else:
 
169
                self.assertEqual(value, self.frame[item][idx])
 
170
 
 
171
    def testGetTS(self):
 
172
        frame = self.frame
 
173
        tsFrame = frame.getTS(fromDate=frame.index[5], nPeriods=5)
 
174
        for i, idx in enumerate(tsFrame.index):
 
175
            self.assertEqual(idx, frame.index[5+i])
 
176
            for col, series in tsFrame.iteritems():
 
177
                self.assertEqual(idx, series.index[i])
 
178
        for col, series in frame.iteritems():
 
179
            for idx, value in series.iteritems():
 
180
                if isnan(value):
 
181
                    self.assert_(isnan(frame[col][idx]))
 
182
                else:
 
183
                    self.assertEqual(value, frame[col][idx])
 
184
 
 
185
    def testTranspose(self):
 
186
        frame = self.frame
 
187
        dft = frame.T
 
188
        for idx, series in dft.iteritems():
 
189
            for col, value in series.iteritems():
 
190
                if isnan(value):
 
191
                    self.assert_(isnan(frame[col][idx]))
 
192
                else:
 
193
                    self.assertEqual(value, frame[col][idx])
 
194
 
 
195
    def testAsMatrix(self):
 
196
        frame = self.frame
 
197
        mat = frame.asMatrix()
 
198
        smallerCols = ['col3', 'col1']
 
199
        smallerMat = frame.asMatrix(smallerCols)
 
200
        frameCols = frame.cols()
 
201
        for i, row in enumerate(mat):
 
202
            for j, value in enumerate(row):
 
203
                col = frameCols[j]
 
204
                if isnan(value):
 
205
                    self.assert_(isnan(frame[col][i]))
 
206
                else:
 
207
                    self.assertEqual(value, frame[col][i])
 
208
        
 
209
    def testDeepcopy(self):
 
210
        cp = deepcopy(self.frame)
 
211
        series = cp['col1']
 
212
        series[:] = 10
 
213
        for idx, value in series.iteritems():
 
214
            self.assertNotEqual(self.frame['col1'][idx], value)
 
215
 
 
216
    def testFilterItems(self):
 
217
        pass
 
218
    
 
219
    def testGroupBy(self):
 
220
        
 
221
        pass
 
222
 
 
223
    def testApply(self):
 
224
        pass    
 
225
 
 
226
    def testSort(self):
 
227
        pass    
 
228
 
 
229
    def testToCSV(self):
 
230
        pass
 
231
 
 
232
    def testPickle(self):
 
233
        pass
 
234
 
 
235
    def testToDictList(self):
 
236
        pass
 
237
    
 
238
    def testDictToDataFrame(self):
 
239
        pass
 
240
 
 
241
    def testDataFrameToDict(self):
 
242
        pass
 
243
 
 
244
    def testFromDict(self):
 
245
        newFrame = DataMatrix.fromDict(col1=self.ts1, col2 = self.ts2)
 
246
        for idx in newFrame.index:
 
247
            if idx in self.ts1.index:
 
248
                self.assertEqual(newFrame['col1'][idx], self.ts1[idx])
 
249
            if idx in self.ts2.index:
 
250
                self.assertEqual(newFrame['col2'][idx], self.ts2[idx])
 
251
            
 
252
    
 
253
    def testPreserveReferences(self):        
 
254
        pass
 
255
    
 
256
    def testCleanNaN(self):
 
257
        pass
 
258
 
 
259
if __name__ == '__main__':
 
260
    unittest.main()