← Back to branch summary

~ubuntu-branches/ubuntu/saucy/python-scipy/saucy

« back to all changes in this revision

Viewing changes to scipy/sandbox/timeseries/tests/test_timeseries.py

  • Committer: Bazaar Package Importer
  • Author(s): Ondrej Certik
  • Date: 2008-06-16 22:58:01 UTC
  • mfrom: (2.1.24 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080616225801-irdhrpcwiocfbcmt
Tags: 0.6.0-12
http://bugs.debian.org/489149
* The description updated to match the current SciPy (Closes: #489149).
* Standards-Version bumped to 3.8.0 (no action needed)
* Build-Depends: netcdf-dev changed to libnetcdf-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
scipy/sandbox/timeseries/tests/test_timeseries.py
 
1
# pylint: disable-msg=W0611, W0612, W0511,R0201
 
2
"""Tests suite for MaskedArray.
 
3
Adapted from the original test_ma by Pierre Gerard-Marchant
 
4
 
 
5
:author: Pierre Gerard-Marchant & Matt Knox
 
6
:contact: pierregm_at_uga_dot_edu & mattknox_ca_at_hotmail_dot_com
 
7
:version: $Id: test_timeseries.py 3206 2007-07-29 00:54:10Z pierregm $
 
8
"""
 
9
__author__ = "Pierre GF Gerard-Marchant & Matt Knox ($Author: pierregm $)"
 
10
__version__ = '1.0'
 
11
__revision__ = "$Revision: 3206 $"
 
12
__date__     = '$Date: 2007-07-28 17:54:10 -0700 (Sat, 28 Jul 2007) $'
 
13
 
 
14
import numpy as N
 
15
from numpy import bool_, complex_, float_, int_, object_
 
16
import numpy.core.fromnumeric  as fromnumeric
 
17
import numpy.core.numeric as numeric
 
18
from numpy.testing import NumpyTest, NumpyTestCase
 
19
from numpy.testing.utils import build_err_msg
 
20
 
 
21
import maskedarray
 
22
import maskedarray as MA
 
23
from maskedarray import masked_array, masked, nomask
 
24
 
 
25
import maskedarray.testutils
 
26
from maskedarray.testutils import assert_equal, assert_array_equal
 
27
 
 
28
from timeseries import tseries
 
29
from timeseries import Date, date_array_fromlist, date_array_fromrange, date_array, thisday
 
30
from timeseries import time_series, TimeSeries, adjust_endpoints, \
 
31
    mask_period, align_series, align_with, fill_missing_dates, tsmasked, \
 
32
    concatenate_series, stack, split
 
33
 
 
34
class test_creation(NumpyTestCase):
 
35
    "Base test class for MaskedArrays."
 
36
    def __init__(self, *args, **kwds):
 
37
        NumpyTestCase.__init__(self, *args, **kwds)
 
38
        dlist = ['2007-01-%02i' % i for i in range(1,16)]
 
39
        dates = date_array_fromlist(dlist)
 
40
        data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3)
 
41
        self.d = (dlist, dates, data)
 
42
 
 
43
    def test_fromlist (self):
 
44
        "Base data definition."
 
45
        (dlist, dates, data) = self.d
 
46
        series = time_series(data, dlist)
 
47
        assert(isinstance(series, TimeSeries))
 
48
        assert_equal(series._mask, [1,0,0,0,0]*3)
 
49
        assert_equal(series._series, data)
 
50
        assert_equal(series._dates, date_array_fromlist(dlist))
 
51
        assert_equal(series.freqstr, 'D')
 
52
 
 
53
    def test_fromrange (self):
 
54
        "Base data definition."
 
55
        (dlist, dates, data) = self.d
 
56
        series = time_series(data, start_date=dates[0], length=15)
 
57
        assert(isinstance(series, TimeSeries))
 
58
        assert_equal(series._mask, [1,0,0,0,0]*3)
 
59
        assert_equal(series._series, data)
 
60
        assert_equal(series._dates, dates)
 
61
        assert_equal(series.freqstr, 'D')
 
62
 
 
63
    def test_fromseries (self):
 
64
        "Base data definition."
 
65
        (dlist, dates, data) = self.d
 
66
        series = time_series(data, dlist)
 
67
        dates = dates+15
 
68
        series = time_series(series, dates)
 
69
        assert(isinstance(series, TimeSeries))
 
70
        assert_equal(series._mask, [1,0,0,0,0]*3)
 
71
        assert_equal(series._series, data)
 
72
        assert_equal(series._dates, dates)
 
73
        assert_equal(series.freqstr, 'D')
 
74
 
 
75
 
 
76
    def test_fromdatearray(self):
 
77
        "Tests the creation of a series from a datearray"
 
78
        _, dates, _ = self.d
 
79
        data = dates
 
80
        #
 
81
        series = time_series(data, dates)
 
82
        assert(isinstance(series, TimeSeries))
 
83
        assert_equal(series._dates, dates)
 
84
        assert_equal(series._data, data)
 
85
        assert_equal(series.freqstr, 'D')
 
86
        #
 
87
        series[5] = MA.masked
 
88
        # ensure that series can be represented by a string after masking a value
 
89
        # (there was a bug before that prevented this from working when using a
 
90
        # DateArray for the data)
 
91
        strrep = str(series)
 
92
 
 
93
 
 
94
    def test_datafromlist(self):
 
95
        "Check the creation of a time series from a list of data."
 
96
        (_, dates, _) = self.d
 
97
        data = list(range(15))
 
98
        series = time_series(data, dates)
 
99
        assert_equal(series._data.size, 15)
 
100
        
 
101
    def test_unsorted(self):
 
102
        "Tests that the data are properly sorted along the dates."
 
103
        dlist = ['2007-01-%02i' % i for i in (3,2,1)]
 
104
        data = [10,20,30]
 
105
        series = time_series(data,dlist)
 
106
        assert_equal(series._data,[30,20,10])
 
107
        #
 
108
        series = TimeSeries(data, dlist)
 
109
        assert_equal(series._data,[30,20,10])
 
110
        #
 
111
        series = TimeSeries(data, dlist, mask=[1,0,0])
 
112
        assert_equal(series._mask,[0,0,1])
 
113
        #
 
114
        data = masked_array([10,20,30],mask=[1,0,0])
 
115
        series = TimeSeries(data, dlist)
 
116
        assert_equal(series._mask,[0,0,1])
 
117
#...............................................................................
 
118
 
 
119
class test_arithmetics(NumpyTestCase):
 
120
    "Some basic arithmetic tests"
 
121
    def __init__(self, *args, **kwds):
 
122
        NumpyTestCase.__init__(self, *args, **kwds)
 
123
        dlist = ['2007-01-%02i' % i for i in range(1,16)]
 
124
        dates = date_array_fromlist(dlist)
 
125
        data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3)
 
126
        self.d = (time_series(data, dlist), data)
 
127
 
 
128
    def test_intfloat(self):
 
129
        "Test arithmetic timeseries/integers"
 
130
        (series, data) =self.d
 
131
        #
 
132
        nseries = series+1
 
133
        assert(isinstance(nseries, TimeSeries))
 
134
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
135
        assert_equal(nseries._series, data+1)
 
136
        assert_equal(nseries._dates, series._dates)
 
137
        #
 
138
        nseries = series-1
 
139
        assert(isinstance(nseries, TimeSeries))
 
140
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
141
        assert_equal(nseries._series, data-1)
 
142
        assert_equal(nseries._dates, series._dates)
 
143
        #
 
144
        nseries = series*1
 
145
        assert(isinstance(nseries, TimeSeries))
 
146
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
147
        assert_equal(nseries._series, data*1)
 
148
        assert_equal(nseries._dates, series._dates)
 
149
        #
 
150
        nseries = series/1.
 
151
        assert(isinstance(nseries, TimeSeries))
 
152
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
153
        assert_equal(nseries._series, data/1.)
 
154
        assert_equal(nseries._dates, series._dates)
 
155
 
 
156
    def test_intfloat_inplace(self):
 
157
        "Test int/float arithmetics in place."
 
158
        (series, data) =self.d
 
159
        nseries = series.astype(float_)
 
160
        idini = id(nseries)
 
161
        data = data.astype(float_)
 
162
        #
 
163
        nseries += 1.
 
164
        assert(isinstance(nseries, TimeSeries))
 
165
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
166
        assert_equal(nseries._series, data+1.)
 
167
        assert_equal(nseries._dates, series._dates)
 
168
        assert_equal(id(nseries),idini)
 
169
        #
 
170
        nseries -= 1.
 
171
        assert(isinstance(nseries, TimeSeries))
 
172
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
173
        assert_equal(nseries._series, data)
 
174
        assert_equal(nseries._dates, series._dates)
 
175
        assert_equal(id(nseries),idini)
 
176
        #
 
177
        nseries *= 2.
 
178
        assert(isinstance(nseries, TimeSeries))
 
179
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
180
        assert_equal(nseries._series, data*2.)
 
181
        assert_equal(nseries._dates, series._dates)
 
182
        assert_equal(id(nseries),idini)
 
183
        #
 
184
        nseries /= 2.
 
185
        assert(isinstance(nseries, TimeSeries))
 
186
        assert_equal(nseries._mask, [1,0,0,0,0]*3)
 
187
        assert_equal(nseries._series, data)
 
188
        assert_equal(nseries._dates, series._dates)
 
189
        assert_equal(id(nseries),idini)
 
190
    #
 
191
    def test_updatemask(self):
 
192
        "Checks modification of mask."
 
193
        (series, data) =self.d
 
194
        assert_equal(series._mask, [1,0,0,0,0]*3)
 
195
        series.mask = nomask
 
196
        assert(series._mask is nomask)
 
197
        assert(series._series._mask is nomask)
 
198
        #series._series.mask = [1,0,0]*5
 
199
        series.mask = [1,0,0]*5
 
200
        assert_equal(series._mask, [1,0,0]*5)
 
201
        assert_equal(series._series._mask, [1,0,0]*5)
 
202
        series[2] = masked
 
203
        assert_equal(series._mask, [1,0,1]+[1,0,0]*4)
 
204
        assert_equal(series._series._mask, [1,0,1]+[1,0,0]*4)
 
205
    #
 
206
    def test_ismasked(self):
 
207
        "Checks checks on masked"
 
208
        (series, data) =self.d
 
209
        assert(series[0] is tsmasked)
 
210
        assert(tsmasked._series is masked)
 
211
        assert(series._series[0] is masked)
 
212
        assert(series[0]._series is masked)
 
213
 
 
214
 
 
215
#...............................................................................
 
216
 
 
217
class test_getitem(NumpyTestCase):
 
218
    "Some getitem tests"
 
219
    def __init__(self, *args, **kwds):
 
220
        NumpyTestCase.__init__(self, *args, **kwds)
 
221
        dlist = ['2007-01-%02i' % i for i in range(1,16)]
 
222
        dates = date_array_fromlist(dlist)
 
223
        data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3, dtype=float_)
 
224
        self.d = (time_series(data, dlist), data, dates)
 
225
 
 
226
    def test_wdate(self):
 
227
        "Tests  getitem with date as index"
 
228
        (series, data, dates) = self.d
 
229
        last_date = series._dates[-1]
 
230
        assert_equal(series[-1], series[last_date])
 
231
        assert_equal(series._dates[-1], dates[-1])
 
232
        assert_equal(series[-1]._dates[0], dates[-1])
 
233
        assert_equal(series[last_date]._dates[0], dates[-1])
 
234
        assert_equal(series._series[-1], data._data[-1])
 
235
        assert_equal(series[-1]._series, data._data[-1])
 
236
        assert_equal(series._mask[-1], data._mask[-1])
 
237
        #
 
238
        series['2007-01-06'] = 999
 
239
        assert_equal(series[5], 999)
 
240
        #
 
241
    def test_wtimeseries(self):
 
242
        "Tests getitem w/ TimeSeries as index"
 
243
        (series, data, dates) = self.d
 
244
        # Testing a basic condition on data
 
245
        cond = (series<8).filled(False)
 
246
        dseries = series[cond]
 
247
        assert_equal(dseries._data, [1,2,3,4,6,7])
 
248
        assert_equal(dseries._dates, series._dates[[1,2,3,4,6,7]])
 
249
        assert_equal(dseries._mask, nomask)
 
250
        # Testing a basic condition on dates
 
251
        series[series._dates < Date('D',string='2007-01-06')] = masked
 
252
        assert_equal(series[:5]._series._mask, [1,1,1,1,1])
 
253
 
 
254
    def test_wslices(self):
 
255
        "Test get/set items."
 
256
        (series, data, dates) = self.d
 
257
        # Basic slices
 
258
        assert_equal(series[3:7]._series._data, data[3:7]._data)
 
259
        assert_equal(series[3:7]._series._mask, data[3:7]._mask)
 
260
        assert_equal(series[3:7]._dates, dates[3:7])
 
261
        # Ditto
 
262
        assert_equal(series[:5]._series._data, data[:5]._data)
 
263
        assert_equal(series[:5]._series._mask, data[:5]._mask)
 
264
        assert_equal(series[:5]._dates, dates[:5])
 
265
        # With set
 
266
        series[:5] = 0
 
267
        assert_equal(series[:5]._series, [0,0,0,0,0])
 
268
        dseries = N.log(series)
 
269
        series[-5:] = dseries[-5:]
 
270
        assert_equal(series[-5:], dseries[-5:])
 
271
        # Now, using dates !
 
272
        dseries = series[series.dates[3]:series.dates[7]]
 
273
        assert_equal(dseries, series[3:7])
 
274
 
 
275
    def test_on2d(self):
 
276
        "Tests getitem on a 2D series"
 
277
        (a,b,d) = ([1,2,3],[3,2,1], date_array(thisday('M'),length=3))
 
278
        ser_x = time_series(N.column_stack((a,b)), dates=d)
 
279
        assert_equal(ser_x[0,0], time_series(a[0],d[0]))
 
280
        assert_equal(ser_x[0,:], time_series([(a[0],b[0])], d[0]))
 
281
        assert_equal(ser_x[:,0], time_series(a, d))
 
282
        assert_equal(ser_x[:,:], ser_x)
 
283
 
 
284
    def test_onnd(self):
 
285
        "Tests getitem on a nD series"
 
286
        hodie = thisday('D')
 
287
        # Case 1D
 
288
        series = time_series(N.arange(5), mask=[1,0,0,0,0], start_date=hodie)
 
289
        assert_equal(series[0], 0)
 
290
        # Case 1D + mask
 
291
        series = time_series(N.arange(5), mask=[1,0,0,0,0], start_date=hodie)
 
292
        assert series[0] is tsmasked
 
293
        # Case 2D
 
294
        series = time_series(N.arange(10).reshape(5,2), start_date=hodie)
 
295
        assert_equal(len(series), 5)
 
296
        assert_equal(series[0], [[0,1]])
 
297
        assert_equal(series[0]._dates[0], (hodie))
 
298
        assert_equal(series[:,0], [0,2,4,6,8])
 
299
        assert_equal(series[:,0]._dates, series._dates)
 
300
        # Case 2D + mask
 
301
        series = time_series(N.arange(10).reshape(5,2), start_date=hodie,
 
302
                             mask=[[1,1],[0,0],[0,0],[0,0],[0,0]])
 
303
        assert_equal(len(series), 5)
 
304
        assert_equal(series[0], [[0,1]])
 
305
        assert_equal(series[0]._mask, [[1,1]])
 
306
        assert_equal(series[0]._dates[0], (hodie))
 
307
        assert_equal(series[:,0]._data, [0,2,4,6,8])
 
308
        assert_equal(series[:,0]._mask, [1,0,0,0,0])
 
309
        assert_equal(series[:,0]._dates, series._dates)
 
310
        # Case 3D
 
311
        series = time_series(N.arange(30).reshape(5,3,2), start_date=hodie)
 
312
        x = series[0]
 
313
        assert_equal(len(series), 5)
 
314
        assert_equal(series[0], [[[0,1],[2,3],[4,5]]])
 
315
        assert_equal(series[0]._dates[0], (hodie))
 
316
        assert_equal(series[:,0], series._data[:,0])
 
317
        assert_equal(series[:,0]._dates, series._dates)
 
318
        x = series[:,:,0]
 
319
        assert_equal(series[:,:,0], series._data[:,:,0])
 
320
        assert_equal(series[:,:,0]._dates, series._dates)
 
321
 
 
322
class test_functions(NumpyTestCase):
 
323
    "Some getitem tests"
 
324
    def __init__(self, *args, **kwds):
 
325
        NumpyTestCase.__init__(self, *args, **kwds)
 
326
        dlist = ['2007-01-%02i' % i for i in range(1,16)]
 
327
        dates = date_array_fromlist(dlist)
 
328
        data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3)
 
329
        self.d = (time_series(data, dlist), data, dates)
 
330
    #
 
331
    def test_adjustendpoints(self):
 
332
        "Tests adjust_endpoints"
 
333
        (series, data, dates) = self.d
 
334
        dseries = adjust_endpoints(series, series.dates[0], series.dates[-1])
 
335
        assert_equal(dseries, series)
 
336
        dseries = adjust_endpoints(series, series.dates[3], series.dates[-3])
 
337
        assert_equal(dseries, series[3:-2])
 
338
        dseries = adjust_endpoints(series, end_date=Date('D', string='2007-01-31'))
 
339
        assert_equal(dseries.size, 31)
 
340
        assert_equal(dseries._mask, N.r_[series._mask, [1]*16])
 
341
        dseries = adjust_endpoints(series, end_date=Date('D', string='2007-01-06'))
 
342
        assert_equal(dseries.size, 6)
 
343
        assert_equal(dseries, series[:6])
 
344
        dseries = adjust_endpoints(series,
 
345
                                   start_date=Date('D', string='2007-01-06'),
 
346
                                   end_date=Date('D', string='2007-01-31'))
 
347
        assert_equal(dseries.size, 26)
 
348
        assert_equal(dseries._mask, N.r_[series._mask[5:], [1]*16])
 
349
    #
 
350
    def test_alignseries(self):
 
351
        "Tests align_series & align_with"
 
352
        (series, data, dates) = self.d
 
353
        #
 
354
        empty_series = time_series([], freq='d')
 
355
        a, b = align_series(series, empty_series)
 
356
        assert_equal(a.start_date, b.start_date)
 
357
        assert_equal(a.end_date, b.end_date)
 
358
        #
 
359
        aseries = time_series(data, dates+10)
 
360
        bseries = time_series(data, dates-10)
 
361
        (a, b) = align_with(series, aseries, bseries)
 
362
        assert_equal(a._dates, series._dates)
 
363
        assert_equal(b._dates, series._dates)
 
364
        assert_equal(a[-5:], series[:5])
 
365
        assert_equal(b[:5], series[-5:])
 
366
    #
 
367
    def test_tshift(self):
 
368
        "Test tshift function"
 
369
        series = self.d[0]
 
370
        shift_negative = series.tshift(-1)
 
371
        result_data = [999] + [0,1,2,3,4,5,6,7,8,9,10,11,12,13]
 
372
        result_mask = [1  ] + [1,0,0,0,0,1,0,0,0,0,1, 0, 0, 0 ]
 
373
        shift_negative_result = time_series(result_data, series._dates, mask=result_mask)
 
374
 
 
375
        shift_positive = series.tshift(1)
 
376
        result_data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14] + [999]
 
377
        result_mask = [0,0,0,0,1,0,0,0,0,1, 0, 0, 0, 0 ] + [1  ]
 
378
        shift_positive_result = time_series(result_data, series._dates, mask=result_mask)
 
379
 
 
380
        assert_array_equal(shift_negative, shift_negative_result)
 
381
        assert_array_equal(shift_positive, shift_positive_result)
 
382
    #
 
383
    def test_split(self):
 
384
        """Test the split function."""
 
385
        ms = time_series(N.arange(62).reshape(31,2),
 
386
                         start_date=Date(freq='d', year=2005, month=7, day=1))
 
387
        d1,d2 = split(ms)
 
388
        assert_array_equal(d1.data, ms.data[:,0])
 
389
        assert_array_equal(d1.dates, ms.dates)
 
390
        assert_array_equal(d2.data, ms.data[:,1])
 
391
 
 
392
        series = self.d[0]
 
393
        ss = split(series)[0]
 
394
        assert_array_equal(series, ss)
 
395
    #
 
396
    def test_convert(self):
 
397
        """Test convert function
 
398
 
 
399
Just check basic functionality. The details of the actual
 
400
date conversion algorithms already tested by asfreq in the
 
401
test_dates test suite.
 
402
        """
 
403
        lowFreqSeries = time_series(N.arange(10),
 
404
                                    start_date=Date(freq='m', year=2005, month=6))
 
405
        highFreqSeries = time_series(N.arange(100),
 
406
                                    start_date=Date(freq='b', year=2005, month=6, day=1))
 
407
        ndseries = time_series(N.arange(124).reshape(62,2), 
 
408
                             start_date=Date(freq='d', year=2005, month=7, day=1))
 
409
 
 
410
        lowToHigh_start = lowFreqSeries.convert('B', position='START')
 
411
 
 
412
        assert_equal(lowToHigh_start.start_date,
 
413
                     Date(freq='m', year=2005, month=6).asfreq("B", relation="BEFORE"))
 
414
        assert_equal(lowToHigh_start.end_date,
 
415
                     (Date(freq='m', year=2005, month=6) + 9).asfreq("B", relation="AFTER"))
 
416
 
 
417
        assert_equal(lowToHigh_start._mask[0], False)
 
418
        assert_equal(lowToHigh_start._mask[-1], True)
 
419
 
 
420
        lowToHigh_end = lowFreqSeries.convert('B', position='END')
 
421
 
 
422
        assert_equal(lowToHigh_end.start_date,
 
423
                     Date(freq='m', year=2005, month=6).asfreq("B", relation="BEFORE"))
 
424
        assert_equal(lowToHigh_end.end_date,
 
425
                     (Date(freq='m', year=2005, month=6) + 9).asfreq("B", relation="AFTER"))
 
426
 
 
427
        assert_equal(lowToHigh_end._mask[0], True)
 
428
        assert_equal(lowToHigh_end._mask[-1], False)
 
429
 
 
430
 
 
431
        highToLow = highFreqSeries.convert('M', func=None)
 
432
 
 
433
        assert_equal(highToLow.ndim, 2)
 
434
        assert_equal(highToLow.shape[1], 23)
 
435
        assert_equal(highToLow.start_date,
 
436
                     Date(freq='b', year=2005, month=6, day=1).asfreq('M'))
 
437
        assert_equal(highToLow.end_date,
 
438
                     (Date(freq='b', year=2005, month=6, day=1) + 99).asfreq('M'))
 
439
 
 
440
        assert_array_equal(lowFreqSeries, lowFreqSeries.convert("M"))
 
441
                
 
442
        assert_equal(ndseries.convert('M',sum), [[930,961],[2852,2883]])
 
443
    #
 
444
    def test_fill_missing_dates(self):
 
445
        """Test fill_missing_dates function"""
 
446
        _start = Date(freq='m', year=2005, month=1)
 
447
        _end = Date(freq='m', year=2005, month=4)
 
448
        #
 
449
        dates = date_array([_start, _end], freq='M')
 
450
        series = time_series([1, 2], dates)
 
451
        filled_ser = fill_missing_dates(series)
 
452
        #
 
453
        assert_equal(filled_ser.start_date, _start)
 
454
        assert_equal(filled_ser.end_date, _end)
 
455
        assert(filled_ser.isfull())
 
456
        assert(not filled_ser.has_duplicated_dates())
 
457
        assert_equal(filled_ser.size, _end - _start + 1)
 
458
        #
 
459
        data = N.arange(5*24).reshape(5,24)
 
460
        datelist = ['2007-07-01','2007-07-02','2007-07-03','2007-07-05','2007-07-06']
 
461
        dates = date_array_fromlist(datelist, 'D')
 
462
        dseries = time_series(data, dates)
 
463
        ndates = date_array_fromrange(start_date=dates[0],end_date=dates[-2])
 
464
        #
 
465
        fseries = fill_missing_dates(dseries)
 
466
        assert_equal(fseries.shape, (6,24))
 
467
        assert_equal(fseries._mask[:,0], [0,0,0,1,0,0])
 
468
        #
 
469
        fseries = fill_missing_dates(dseries[:,0])
 
470
        assert_equal(fseries.shape, (6,))
 
471
        assert_equal(fseries._mask, [0,0,0,1,0,0])
 
472
        #
 
473
        series = time_series(data.ravel()[:4].reshape(2,2),dates=dates[:-1])
 
474
        fseries = fill_missing_dates(series)
 
475
        assert_equal(fseries.shape, (5,))
 
476
        assert_equal(fseries._mask, [0,0,0,1,0,])
 
477
    #
 
478
    def test_maskperiod(self):
 
479
        "Test mask_period"
 
480
        (series, data, dates) = self.d
 
481
        series.mask = nomask
 
482
        (start, end) = ('2007-01-06', '2007-01-12')
 
483
        mask = mask_period(series, start, end, inside=True, include_edges=True,
 
484
                           inplace=False)
 
485
        assert_equal(mask._mask, N.array([0,0,0,0,0,1,1,1,1,1,1,1,0,0,0]))
 
486
        mask = mask_period(series, start, end, inside=True, include_edges=False,
 
487
                           inplace=False)
 
488
        assert_equal(mask._mask, [0,0,0,0,0,0,1,1,1,1,1,0,0,0,0])
 
489
        mask = mask_period(series, start, end, inside=False, include_edges=True,
 
490
                           inplace=False)
 
491
        assert_equal(mask._mask, [1,1,1,1,1,1,0,0,0,0,0,1,1,1,1])
 
492
        mask = mask_period(series, start, end, inside=False, include_edges=False,
 
493
                           inplace=False)
 
494
        assert_equal(mask._mask, [1,1,1,1,1,0,0,0,0,0,0,0,1,1,1])
 
495
        # Now w/ multivariables
 
496
        data = masked_array(numeric.arange(30).reshape(-1,2), dtype=float_)
 
497
        series = time_series(data, dates=dates)
 
498
        mask = mask_period(series, start, end, inside=True, include_edges=True,
 
499
                           inplace=False)
 
500
        result = N.array([0,0,0,0,0,1,1,1,1,1,1,1,0,0,0])
 
501
        assert_equal(mask._mask, result.repeat(2).reshape(-1,2))
 
502
    #
 
503
    def test_pickling(self):
 
504
        "Tests pickling/unpickling"
 
505
        (series, data, dates) = self.d
 
506
        import cPickle
 
507
        series_pickled = cPickle.loads(series.dumps())
 
508
        assert_equal(series_pickled._dates, series._dates)
 
509
        assert_equal(series_pickled._data, series._data)
 
510
        assert_equal(series_pickled._mask, series._mask)
 
511
        #
 
512
        data = masked_array(N.matrix(range(10)).T, mask=[1,0,0,0,0]*2)
 
513
        dates = date_array(start_date=thisday('D'), length=10)
 
514
        series = time_series(data,dates=dates)
 
515
        series_pickled = cPickle.loads(series.dumps())
 
516
        assert_equal(series_pickled._dates, series._dates)
 
517
        assert_equal(series_pickled._data, series._data)
 
518
        assert_equal(series_pickled._mask, series._mask)
 
519
        assert(isinstance(series_pickled._data, N.matrix))
 
520
 
 
521
 
 
522
    def test_empty_timeseries(self):
 
523
        "Tests that empty TimeSeries are  handled properly"
 
524
        empty_ts = time_series([], freq='b')
 
525
        assert_array_equal(empty_ts, empty_ts + 1)
 
526
        assert_array_equal(empty_ts, empty_ts + empty_ts)
 
527
        assert_equal(empty_ts.start_date, None)
 
528
        assert_equal(empty_ts.end_date, None)
 
529
 
 
530
    def test__timeseriescompat_multiple(self):
 
531
        "Tests the compatibility of multiple time series."
 
532
        seriesM_10 = time_series(N.arange(10),
 
533
                                    date_array(
 
534
                                      start_date=Date(freq='m', year=2005, month=1),
 
535
                                      length=10)
 
536
                                )
 
537
 
 
538
        seriesD_10 = time_series(N.arange(10),
 
539
                                    date_array(
 
540
                                      start_date=Date(freq='d', year=2005, month=1, day=1),
 
541
                                      length=10)
 
542
                                )
 
543
 
 
544
        seriesD_5 = time_series(N.arange(5),
 
545
                                    date_array(
 
546
                                      start_date=Date(freq='d', year=2005, month=1, day=1),
 
547
                                      length=5)
 
548
                                )
 
549
 
 
550
        seriesD_5_apr = time_series(N.arange(5),
 
551
                                    date_array(
 
552
                                      start_date=Date(freq='d', year=2005, month=4, day=1),
 
553
                                      length=5)
 
554
                                )
 
555
 
 
556
        assert(tseries._timeseriescompat_multiple(seriesM_10, seriesM_10, seriesM_10))
 
557
 
 
558
        try:
 
559
            tseries._timeseriescompat_multiple(seriesM_10, seriesD_10)
 
560
            exception = False
 
561
        except:
 
562
            exception = True
 
563
        assert(exception)
 
564
 
 
565
        try:
 
566
            tseries._timeseriescompat_multiple(seriesD_5, seriesD_10)
 
567
            exception = False
 
568
        except:
 
569
            exception = True
 
570
        assert(exception)
 
571
 
 
572
        try:
 
573
            tseries._timeseriescompat_multiple(seriesD_5, seriesD_5_apr)
 
574
            exception = False
 
575
        except:
 
576
            exception = True
 
577
        assert(exception)
 
578
 
 
579
    def test_compressed(self):
 
580
        "Tests compress"
 
581
        dlist = ['2007-01-%02i' % i for i in range(1,16)]
 
582
        dates = date_array_fromlist(dlist)
 
583
        data = masked_array(numeric.arange(15), mask=[1,0,0,0,0]*3, dtype=float_)
 
584
        series = time_series(data, dlist)
 
585
        #
 
586
        keeper = N.array([0,1,1,1,1]*3, dtype=bool_)
 
587
        c_series = series.compressed()
 
588
        assert_equal(c_series._data, [1,2,3,4,6,7,8,9,11,12,13,14])
 
589
        assert_equal(c_series._mask, nomask)
 
590
        assert_equal(c_series._dates, dates[keeper])
 
591
        #
 
592
        series_st = time_series(MA.column_stack((data,data[::-1])),
 
593
                                dates=dates)
 
594
        c_series = series_st.compressed()
 
595
        d = [1,2,3,6,7,8,11,12,13]
 
596
        assert_equal(c_series._data, N.c_[(d,list(reversed(d)))])
 
597
        assert_equal(c_series._mask, nomask)
 
598
        assert_equal(c_series._dates, dates[d])
 
599
 
 
600
    def test_concatenate(self):
 
601
        "Tests concatenate"
 
602
        dlist = ['2007-%02i' % i for i in range(1,6)]
 
603
        dates = date_array_fromlist(dlist)
 
604
        data = masked_array(numeric.arange(5), mask=[1,0,0,0,0], dtype=float_)
 
605
        #
 
606
        ser_1 = time_series(data, dates)
 
607
        ser_2 = time_series(data, dates=dates+10)
 
608
        newseries = concatenate_series(ser_1, ser_2)
 
609
        assert_equal(newseries._data,[0,1,2,3,4,0,0,0,0,0,0,1,2,3,4])
 
610
        assert_equal(newseries._mask,[1,0,0,0,0]+[1]*5+[1,0,0,0,0])
 
611
         #
 
612
        ser_1 = time_series(data, dates)
 
613
        ser_2 = time_series(data, dates=dates+10)
 
614
        newseries = concatenate_series(ser_1, ser_2, keep_gap=False)
 
615
        assert_equal(newseries._data,[0,1,2,3,4,0,1,2,3,4])
 
616
        assert_equal(newseries._mask,[1,0,0,0,0]+[1,0,0,0,0])
 
617
        assert newseries.has_missing_dates()
 
618
        #
 
619
        ser_2 = time_series(data, dates=dates+3)
 
620
        newseries = concatenate_series(ser_1, ser_2)
 
621
        assert_equal(newseries._data,[0,1,2,0,1,2,3,4])
 
622
        assert_equal(newseries._mask,[1,0,0,1,0,0,0,0])
 
623
        #
 
624
 
 
625
 
 
626
 
 
627
###############################################################################
 
628
#------------------------------------------------------------------------------
 
629
if __name__ == "__main__":
 
630
    NumpyTest().run()
 
 
b'\\ No newline at end of file'