fixed merge conflict

Author: wesm

pandas/core/matrix.py

@@ -749,6 +749,29 @@ def _float_blockify(dct, index, columns):
     # do something with dtype?
     return make_block(values, columns)
 
+    def select(self, crit, axis=0):
+        """
+        Return data corresponding to axis labels matching criteria
+
+        Parameters
+        ----------
+        crit : function
+            To be called on each index (label). Should return True or False
+        axis : {0, 1}
+
+        Returns
+        -------
+        selection : DataFrame
+        """
+        # HACK until refactor
+        axis_name = self._get_axis_name(axis)
+        if axis == 0:
+            axis = self.index
+        else:
+            axis = np.asarray(self.cols())
+        new_axis = axis[np.asarray([crit(label) for label in axis])]
+        return self.reindex(**{axis_name : new_axis})
+
 def _reorder_columns(mat, current, desired):
     indexer, mask = common.get_indexer(current, desired, None)
     return mat.take(indexer[mask], axis=1)

pandas/core/sparse.py

@@ -3,25 +3,26 @@
 float64 data
 """
 
+# pylint: disable=E1101,E1103
+
 from numpy import nan, ndarray
 import numpy as np
 
 import operator
 
-from pandas.core.common import (_pickle_array, _unpickle_array, _mut_exclusive,
-                                _ensure_index, _try_sort)
+from pandas.core.common import (isnull, _pickle_array, _unpickle_array,
+                                _mut_exclusive, _ensure_index)
 from pandas.core.index import Index
 from pandas.core.series import Series, TimeSeries
 from pandas.core.frame import DataFrame, extract_index
 from pandas.core.matrix import DataMatrix
 from pandas.core.panel import Panel, WidePanel, LongPanelIndex, LongPanel
 import pandas.core.common as common
+import pandas.core.datetools as datetools
 
 from pandas.lib.sparse import BlockIndex, IntIndex
 import pandas.lib.sparse as splib
 
-from pandas.util.testing import set_trace
-
 def make_sparse(arr, kind='block', fill_value=nan):
     """
     Convert ndarray to sparse format
@@ -538,6 +539,44 @@ def valid(self):
         dense_valid = self.to_dense().valid()
         return dense_valid.to_sparse(fill_value=self.fill_value)
 
+    def shift(self, periods, offset=None, timeRule=None):
+        """
+        Analogous to Series.shift
+        """
+        # no special handling of fill values yet
+        if not isnull(self.fill_value):
+            dense_shifted = self.to_dense().shift(periods, offset=offset,
+                                                  timeRule=timeRule)
+            return dense_shifted.to_sparse(fill_value=self.fill_value,
+                                           kind=self.kind)
+
+        if periods == 0:
+            return self.copy()
+
+        if timeRule is not None and offset is None:
+            offset = datetools.getOffset(timeRule)
+
+        if offset is not None:
+            return SparseSeries(self.sp_values,
+                                sparse_index=self.sp_index,
+                                index=self.index.shift(periods, offset),
+                                fill_value=self.fill_value)
+
+        int_index = self.sp_index.to_int_index()
+        new_indices = int_index.indices + periods
+        start, end = new_indices.searchsorted([0, int_index.length])
+
+        new_indices = new_indices[start:end]
+
+        new_sp_index = IntIndex(len(self), new_indices)
+        if isinstance(self.sp_index, BlockIndex):
+            new_sp_index = new_sp_index.to_block_index()
+
+        return SparseSeries(self.sp_values[start:end].copy(),
+                            index=self.index,
+                            sparse_index=new_sp_index,
+                            fill_value=self.fill_value)
+
 class SparseTimeSeries(SparseSeries, TimeSeries):
     pass
 
@@ -780,6 +819,30 @@ def count(self, axis=0):
         """
         return self.apply(SparseSeries.count, axis=0)
 
+    def shift(self, periods, offset=None, timeRule=None):
+        """
+        Analogous to DataFrame.shift
+        """
+        if timeRule is not None and offset is None:
+            offset = datetools.getOffset(timeRule)
+
+        new_series = {}
+        if offset is None:
+            new_index = self.index
+            for col, s in self.iteritems():
+                new_series[col] = s.shift(periods)
+        else:
+            new_index = self.index.shift(periods, offset)
+            for col, s in self.iteritems():
+                new_series[col] = SparseSeries(s.sp_values, index=new_index,
+                                               sparse_index=s.sp_index,
+                                               fill_value=s.fill_value)
+
+        return SparseDataFrame(new_series, index=new_index,
+                               columns=self.columns,
+                               default_fill_value=self.default_fill_value,
+                               default_kind=self.default_kind)
+
 def stack_sparse_frame(frame):
     """
     Only makes sense when fill_value is NaN

pandas/core/tests/test_frame.py

@@ -1417,6 +1417,11 @@ def test_filter(self):
         # pass in None
         self.assertRaises(Exception, self.frame.filter, items=None)
 
+        # objects
+        filtered = self.mixed_frame.filter(like='foo')
+        self.assert_('foo' in filtered)
+
+
     def test_sort(self):
         # what to test?
         sorted = self.frame.sort()

pandas/core/tests/test_sparse.py

@@ -17,6 +17,7 @@
 from pandas import Series, DataFrame, DateRange, WidePanel
 from pandas.core.datetools import BDay
 from pandas.core.series import remove_na
+import pandas.core.datetools as datetools
 import pandas.util.testing as testing
 
 import pandas.core.sparse as spm
@@ -550,6 +551,29 @@ def test_fill_value_corner(self):
         result = cop2 / cop
         self.assert_(np.isnan(result.fill_value))
 
+    def test_shift(self):
+        series = SparseSeries([nan, 1., 2., 3., nan, nan],
+                              index=np.arange(6))
+
+        shifted = series.shift(0)
+        self.assert_(shifted is not series)
+        assert_sp_series_equal(shifted, series)
+
+        f = lambda s: s.shift(1)
+        _dense_series_compare(series, f)
+
+        f = lambda s: s.shift(-2)
+        _dense_series_compare(series, f)
+
+        series = SparseSeries([nan, 1., 2., 3., nan, nan],
+                              index=DateRange('1/1/2000', periods=6))
+        f = lambda s: s.shift(2, timeRule='WEEKDAY')
+        _dense_series_compare(series, f)
+
+        f = lambda s: s.shift(2, offset=datetools.bday)
+        _dense_series_compare(series, f)
+
+
 class TestSparseTimeSeries(TestCase):
     pass
 
@@ -855,12 +879,48 @@ def _check(frame):
             assert_sp_frame_equal(frame, untransposed)
         self._check_all(_check)
 
+    def test_shift(self):
+        def _check(frame):
+            shifted = frame.shift(0)
+            self.assert_(shifted is not frame)
+            assert_sp_frame_equal(shifted, frame)
+
+            f = lambda s: s.shift(1)
+            _dense_frame_compare(frame, f)
+
+            f = lambda s: s.shift(-2)
+            _dense_frame_compare(frame, f)
+
+            f = lambda s: s.shift(2, timeRule='WEEKDAY')
+            _dense_frame_compare(frame, f)
+
+            f = lambda s: s.shift(2, offset=datetools.bday)
+            _dense_frame_compare(frame, f)
+
+        self._check_all(_check)
+
+    def test_count(self):
+        result = self.frame.count()
+        dense_result = self.frame.to_dense().count()
+        assert_series_equal(result, dense_result)
+
     def _check_all(self, check_func):
         check_func(self.frame)
         check_func(self.iframe)
         check_func(self.zframe)
         check_func(self.fill_frame)
 
+def _dense_series_compare(s, f):
+    result = f(s)
+    assert(isinstance(result, SparseSeries))
+    dense_result = f(s.to_dense())
+    assert_series_equal(result.to_dense(), dense_result)
+
+def _dense_frame_compare(frame, f):
+    result = f(frame)
+    assert(isinstance(frame, SparseDataFrame))
+    dense_result = f(frame.to_dense())
+    assert_frame_equal(result.to_dense(), dense_result)
 
 def panel_data1():
     index = DateRange('1/1/2011', periods=8)