Changeset 1053

Show
Ignore:
Timestamp:
06/23/08 13:18:05 (4 months ago)
Author:
pierregm
Message:

* tseries : attempt at simplifying getitem...

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/timeseries/scikits/timeseries/lib/tests/test_avcf.py

    r1044 r1053  
    1717from scikits.timeseries.lib.avcf import avf, acf, cvf, ccf, pacf 
    1818 
    19 from scipy.testing import TestCase, nose 
     19from scipy.testing import * 
    2020from numpy.ma.testutils import assert_almost_equal 
     21 
    2122 
    2223 

  • trunk/timeseries/scikits/timeseries/lib/tests/test_moving_funcs.py

    r1044 r1053  
    1010__date__     = '$Date: 2007-03-03 18:00:20 -0500 (Sat, 03 Mar 2007) $' 
    1111 
    12 #!!!: Switch to the import numpy as np, numpy.ma as ma convention 
    13 #!!!: Get rid of numpy.core.numeric 
    14 #!!!: Use ma.array instead of MaskedArray 
    1512 
    1613import numpy as np 
    1714 
    18 from scipy.testing import TestCase, nose 
     15from scipy.testing import * 
    1916from numpy.ma.testutils import assert_equal, assert_almost_equal 
    2017 
    …… 
    2421import scikits.timeseries as ts 
    2522from scikits.timeseries import time_series, now 
     23from scikits.timeseries.lib import moving_funcs as mf 
    2624 
    27 from scikits.timeseries.lib import moving_funcs as mf 
     25 
    2826 
    2927class TestCMovAverage(TestCase): 
    …… 
    3230        TestCase.__init__(self, *args, **kwds) 
    3331        self.data = np.arange(25) 
    34         self.maskeddata = MaskedArray(self.data) 
     32        self.maskeddata = ma.array(self.data) 
    3533        self.maskeddata[10] = masked 
    3634    # 

  • trunk/timeseries/scikits/timeseries/tests/test_timeseries.py

    r1044 r1053  
    281281class TestGetitem(TestCase): 
    282282    "Some getitem tests" 
    283     def __init__(self, *args, **kwds): 
    284         TestCase.__init__(self, *args, **kwds) 
    285         dlist = ['2007-01-%02i' % i for i in range(1,16)] 
    286         dates = date_array(dlist, freq='D') 
    287         data = ma.array(np.arange(15), mask=[1,0,0,0,0]*3, dtype=float_) 
    288         self.d = (time_series(data, dates), data, dates) 
    289283 
    290284    def setUp(self): 
    …… 
    469463    def test_wtimeseries(self): 
    470464        "Tests getitem w/ TimeSeries as index" 
    471         (series, data, dates) = self.d 
     465        series1D = self.series1D 
    472466        # Testing a basic condition on data 
    473         cond = (series<8).filled(False) 
    474         dseries = series[cond] 
     467        cond = (series1D < 8).filled(False) 
     468        dseries = series1D[cond] 
    475469        assert_equal(dseries._data, [1,2,3,4,6,7]) 
    476         assert_equal(dseries._dates, series._dates[[1,2,3,4,6,7]]) 
     470        assert_equal(dseries._dates, series1D._dates[[1,2,3,4,6,7]]) 
    477471        assert_equal(dseries._mask, nomask) 
    478472        # Testing a basic condition on dates 
    479         series[series._dates < Date('D',string='2007-01-06')] = masked 
    480         assert_equal(series[:5]._series._mask, [1,1,1,1,1]) 
    481  
    482     def test_wslices(self): 
    483         "Test get/set items." 
    484         (series, data, dates) = self.d 
    485         # Basic slices 
    486 #        assert_equal(series[3:7]._series._data, data[3:7]._data) 
    487 #        assert_equal(series[3:7]._series._mask, data[3:7]._mask) 
    488 #        assert_equal(series[3:7]._dates, dates[3:7]) 
    489 #        # Ditto 
    490 #        assert_equal(series[:5]._series._data, data[:5]._data) 
    491 #        assert_equal(series[:5]._series._mask, data[:5]._mask) 
    492 #        assert_equal(series[:5]._dates, dates[:5]) 
    493         # With set 
    494         series[:5] = 0 
    495         assert_equal(series[:5]._series, [0,0,0,0,0]) 
    496         dseries = np.log(series) 
    497         series[-5:] = dseries[-5:] 
    498         assert_equal(series[-5:], dseries[-5:]) 
    499         # Now, using dates ! 
    500         dseries = series[series.dates[3]:series.dates[7]] 
    501         assert_equal(dseries, series[3:7]) 
     473        series1D[series1D._dates < Date('D',string='2007-01-06')] = masked 
     474        assert_equal(series1D[:5]._series._mask, [1,1,1,1,1]) 
    502475 
    503476    def test_on2d(self): 
    …… 
    511484 
    512485 
    513  
     486class TestSetItem(TestCase): 
     487    # 
     488    def setUp(self): 
     489        dlist = ['2007-01-%02i' % i for i in range(1,6)] 
     490        dates = date_array(dlist, freq='D') 
     491        data = ma.array(np.arange(5), mask=[1,0,0,0,0], dtype=float) 
     492        self.series = time_series(data, dates) 
     493        self.dates = dates 
     494    # 
     495    def test_with_integers(self): 
     496        "Tests setitem with integers" 
     497        series = self.series 
     498        series[0] = 1 
     499        assert_equal(series._data, [1,1,2,3,4]) 
     500        assert_equal(series._mask, [0,0,0,0,0]) 
     501        series[0] = masked 
     502        assert_equal(series._data, [1,1,2,3,4]) 
     503        assert_equal(series._mask, [1,0,0,0,0]) 
     504        try: 
     505            series[10] = -999 
     506        except IndexError: 
     507            pass 
     508    # 
     509    def test_with_dates(self): 
     510        "Test setitem w/ dates" 
     511        (series, dates) = (self.series, self.dates) 
     512        # 
     513        last_date = dates[-1] 
     514        series[last_date] = 5 
     515        assert_equal(series._data, [0,1,2,3,5]) 
     516        assert_equal(series._mask, [1,0,0,0,0]) 
     517        # 
     518        last_date += 10 
     519        try: 
     520            series[last_date] = -999 
     521        except IndexError: 
     522            pass 
     523        # With dates as string 
     524        series['2007-01-01'] = 5 
     525        assert_equal(series._data, [5,1,2,3,5]) 
     526        assert_equal(series._mask, [0,0,0,0,0]) 
     527         
     528    # 
     529    def test_with_datearray(self): 
     530        "Test setitem w/ a date_array" 
     531        (series, dates) = (self.series, self.dates) 
     532        # Test with date array 
     533        series[dates[[0,-1]]] = 0 
     534        assert_equal(series._data, [0,1,2,3,0]) 
     535        assert_equal(series._mask, [0,0,0,0,0]) 
     536        # Test with date as list ofstring 
     537        series[['2007-01-01','2007-01-02']] = 10 
     538        assert_equal(series._data, [10,10,2,3,0]) 
     539        assert_equal(series._mask, [0,0,0,0,0]) 
    514540 
    515541#------------------------------------------------------------------------------ 

  • trunk/timeseries/scikits/timeseries/trecords.py

    r1044 r1053  
    189189            return obj 
    190190        # We want some elements .. 
    191         (sindx, dindx) = self._index_checker(indx) 
     191        (sindx, dindx, recheck) = self._index_checker(indx) 
    192192        obj = np.array(self._data[sindx], copy=False, subok=True).view(type(self)) 
    193193        obj.__dict__.update(_dates=_localdict['_dates'][dindx], 

  • trunk/timeseries/scikits/timeseries/tseries.py

    r1051 r1053  
    461461    def _index_checker(self, indx): 
    462462        if isinstance(indx, int): 
    463             return (indx, indx) 
     463            return (indx, indx, False) 
    464464        _dates = self._dates 
    465465        if isinstance(indx, basestring): 
    466466            if indx in (self.dtype.names or ()): 
    467                 return (indx, slice(None, None, None)) 
     467                return (indx, slice(None, None, None), False) 
    468468            try: 
    469469                indx = _dates.date_to_index(Date(_dates.freq, string=indx)) 
    …… 
    473473                msg = "Invalid field or date '%s'" % indx 
    474474                raise IndexError(msg), None, exc_info[2] 
    475             return (indx, indx) 
     475            return (indx, indx, False) 
    476476        if isinstance(indx, (Date, DateArray)): 
    477477            indx = self._dates.date_to_index(indx) 
    478             return (indx, indx) 
     478            return (indx, indx, False) 
    479479        if isinstance(indx, slice): 
    480480            indx = slice(self._slicebound_checker(indx.start), 
    481481                         self._slicebound_checker(indx.stop), 
    482482                         indx.step) 
    483             return (indx, indx) 
     483            return (indx, indx, False) 
    484484        if isinstance(indx, tuple): 
    485485            if not self._varshape: 
    486                 return (indx, indx) 
     486                return (indx, indx, False) 
    487487            else: 
    488                 return (indx, indx[0]) 
    489         return (indx, indx) 
     488                return (indx, indx[0], False) 
     489        return (indx, indx, True) 
    490490 
    491491    def _slicebound_checker(self, bound): 
    …… 
    506506Returns the item described by i. Not a copy. 
    507507        """ 
    508         (sindx, dindx) = self._index_checker(indx) 
     508        (sindx, dindx, recheck) = self._index_checker(indx) 
    509509        _series = ndarray.__getattribute__(self, '_series') 
    510510        _dates = ndarray.__getattribute__(self, '_dates') 
    …… 
    512512            newseries = _series.__getitem__(sindx) 
    513513        except IndexError: 
    514             # Couldn't recognize the index: let's try w/ a DateArray 
     514            # We don't need to recheck the index: just raise an exception 
     515            if not recheck: 
     516                raise 
     517            # Maybe the index is a list of Dates ? 
    515518            try: 
    516519                indx = _dates.date_to_index(indx) 
    …… 
    551554        if self is masked: 
    552555            raise MAError, 'Cannot alter the masked element.' 
    553         (sindx, _) = self._index_checker(indx) 
    554         MaskedArray.__setitem__(self, sindx, value) 
     556        try: 
     557            MaskedArray.__setitem__(self, indx, value) 
     558        except IndexError: 
     559            # Easy case: we're out of bounds... 
     560            if isinstance(indx, int): 
     561                raise 
     562            # Mmh, is the index a (list of) Date(s) ? 
     563            _dates = ndarray.__getattribute__(self, '_dates') 
     564            try: 
     565                indx = _dates.date_to_index(date_array(indx, freq=self.freq)) 
     566            except: 
     567                raise 
     568            else: 
     569                MaskedArray.__setitem__(self, indx, value) 
     570        except ValueError: 
     571            # OK, that should be a slice, then... 
     572            if isinstance(indx, slice): 
     573                sindx = slice(self._slicebound_checker(indx.start), 
     574                              self._slicebound_checker(indx.stop), 
     575                              indx.step) 
     576            # Or maybe a field ? 
     577            elif isinstance(indx, basestring) and indx in self.dtype.names: 
     578                sindx = indx 
     579            # Or some kind of date... 
     580            else: 
     581                _dates = ndarray.__getattribute__(self, '_dates') 
     582                sindx = _dates.date_to_index(date_array(indx, freq=self.freq)) 
     583            # 
     584            try: 
     585                MaskedArray.__setitem__(self, sindx, value) 
     586            except IndexError: 
     587                raise IndexError("Date '%s' out of bounds !" % indx) 
     588        return 
    555589 
    556590