Speeds up the data frame interpolation function.

The gait/interpolate function is only used in the GaitData.split_at() method
and the way I orginally coded it using Pandas paradigms was very slow. This
change speeds things up by about 40X. I had to change the test because it no
longer supports nans in the DataFrame. Being that it is only used in the
split_at method this seemed ok. So far I've never had nans in the data frame by
the time it gets to the split at method. GaitData isn't built to handle nans,
they should be fixed before creating a GaitData object.

Author: moorepants

gaitanalysis/gait.py

@@ -8,6 +8,7 @@
 # external libraries
 import numpy as np
 from scipy.integrate import simps
+from scipy.interpolate import interp1d
 from scipy.signal import firwin, filtfilt
 import matplotlib.pyplot as plt
 import pandas
@@ -80,7 +81,7 @@ def find_constant_speed(time, speed, plot=False, filter_cutoff=1.0):
 
 
 def interpolate(data_frame, time):
-    """Returns a data frame with a index based on the provided time
+    """Returns a new data frame with a index based on the provided time
     array and linear interpolation.
 
     Parameters
@@ -100,21 +101,14 @@ def interpolate(data_frame, time):
 
     """
 
-    total_index = np.sort(np.hstack((data_frame.index.values, time)))
-    reindexed_data_frame = data_frame.reindex(total_index)
-    interpolated_data_frame = \
-        reindexed_data_frame.apply(pandas.Series.interpolate,
-                                   method='values').loc[time]
-
-    # If the first or last value of a series is NA then the interpolate
-    # function leaves it as an NA value, so use backfill to take care of
-    # those.
-    interpolated_data_frame = \
-        interpolated_data_frame.fillna(method='backfill')
-    # Because the time vector may have matching indices as the original
-    # index (i.e. always the zero indice), drop any duplicates so the len()
-    # stays consistent
-    return interpolated_data_frame.drop_duplicates()
+    column_names = data_frame.columns
+    old_time = data_frame.index.values
+    vals = data_frame.values
+
+    f = interp1d(old_time, vals, axis=0)
+    new_vals = f(time)
+
+    return pandas.DataFrame(new_vals, index=time, columns=column_names)
 
 
 class GaitData(object):

gaitanalysis/tests/test_gait.py

@@ -34,10 +34,10 @@ def test_find_constant_speed():
 
 def test_interpolate():
 
-    df = pandas.DataFrame({'a': [np.nan, 3.0, 5.0, 7.0],
-                           'b': [5.0, np.nan, 9.0, 11.0],
+    df = pandas.DataFrame({'a': [2.0, 3.0, 5.0, 7.0],
+                           'b': [5.0, 8.0, 9.0, 11.0],
                            'c': [2.0, 4.0, 6.0, 8.0],
-                           'd': [0.5, 1.0, 1.5, np.nan]},
+                           'd': [0.5, 1.0, 1.5, 2.5]},
                           index=[0.0, 2.0, 4.0, 6.0])
 
     time = [0.0, 1.0, 3.0, 5.0]
@@ -47,10 +47,10 @@ def test_interpolate():
     # NOTE : pandas.Series.interpolate does not extrapolate (because
     # np.interp doesn't.
 
-    df_expected = pandas.DataFrame({'a': [4.0, 4.0, 4.0, 6.0],
-                                    'b': [5.0, 6.0, 8.0, 10.0],
+    df_expected = pandas.DataFrame({'a': [2.0, 2.5, 4.0, 6.0],
+                                    'b': [5.0, 6.5, 8.5, 10.0],
                                     'c': [2.0, 3.0, 5.0, 7.0],
-                                    'd': [0.5, 0.75, 1.25, 1.5]},
+                                    'd': [0.5, 0.75, 1.25, 2.0]},
                                    index=time)
 
     testing.assert_allclose(interpolated.values, df_expected.values)