DataFrame.resample Can Be Very Innaccurate With Timedelta Rule
DataFrame.resample() is not accurate, at least when using time delta as rule. 
This is because it does not interpolate between values when up-sampling, nor does aggregation take into account the exact sampling point when down-sampling. When a new sampling point falls between two original samples:
- when up-sampling, the only option is to select one of them or leave NaN (fill_method)
- when down-sampling, simple aggregators such as mean do not consider the distance between the new sampling point to the others. When trying to pass an aggregator function, pandas does not tell it exactly where the new sample point falls either.

Consider a simple example which generates three linear series in a DataFrame of length 10 seconds with exactly 10 points.
### Down-sampling

Let's try down-sampling to 6 points (over the same length of 10 seconds) using DataFrame.resample() and using scipy.interpolate.interp1d().

![resampled_6](https://cloud.githubusercontent.com/assets/13135979/8696874/0c4ee49c-2af9-11e5-979d-eae6c744ccd8.png)

Black dots are the original samples, colored lines and X's are the resampled data.
First, DataFrame.resample (left figure) actually **misses** the original points entirely.
Second, note the distortion near 09:00:06 and 09:00:07 where the slope of the interpolated data is simply wrong. This is exactly the sort of problem that happens when the exact position of the new sample is not taken into account.

Compare to the scipy.interpolation.interpolate (right figure) which interpolates the original (and correct) lines exactly.
### Up-sampling

Let's try up-sampling to 16 points (over the same length of 10 seconds).

![resampled_16](https://cloud.githubusercontent.com/assets/13135979/8697005/0f8c2f7e-2afa-11e5-8cde-a1f6223a7c4c.png)

Again, we see inaccuracies and "stairs", and again, simple linear interpolation with scipy produces the correct result.
### Code

The following code reproduces the above figures. This code uses how='mean' for resample(). Using fill_method='bfill' or 'ffill' gives even worse results.

``` python
import pandas as pd
from scipy.interpolate import interp1d  
import numpy as np
import matplotlib.pylab as pl

n = 10
x = pd.date_range(start='2015-07-13 9:00:00', freq='S', periods=n)
y = np.vstack([range(n), range(n+1,1+2*n), range(1,2*n+1,2)]).T
df = pd.DataFrame(y, index=x)

def PandasResample(df, length):
    td = (df.index[-1] - df.index[0]) / (length-1)
    return df.resample(td, how='mean').interpolate() # Handle NaNs when upsampling

def CorrectResample(df, length):
    time_delta = (df.index[-1] - df.index[0]) / (length-1)
    new_index = pd.date_range(start=df.index[0], end=df.index[-1], freq=time_delta)
    f = interp1d(df.index.astype('i8'), df.values.T)
    return pd.DataFrame(data=f(new_index.astype('i8')).T, index=new_index)

def PlotComparison(a, b, ax, title):
    a.plot(ax=ax, style='ko', legend=False)
    b.plot(ax=ax, style='x-', title=title)

def TryLength(new_length):
    dfa = PandasResample(df, new_length)
    dfb = CorrectResample(df, new_length)
    fig, ax = pl.subplots(1,2, figsize=(12,6))
    PlotComparison(df, dfa, ax[0], 'DataFrame.resample')
    PlotComparison(df, dfb, ax[1], 'scipi.interpolate')
    pl.suptitle('Resample to %d' % new_length)
    pl.savefig('resampled_%d.png' % new_length)


TryLength(6)    
TryLength(16)    
pl.show()
```

I'm using pandas 0.16.2 from WinPython 2.7.10.1 x64.
I can provide show_versions() if needed, but this issue is long enough already :)
