Inconsistent Timestamp arithmetic

[willpan]

Subtracting a scalar datetime from a series returns timedeltas, but doesn't do the same for a dataframe.

import pandas as pd 
series = pd.Series(pd.date_range('2000-1-1', periods=100), index=range(0, 100))
df = pd.DataFrame(series)
date = pd.Timestamp('1995-1-1')

series - date
#0    1826 days                                                                                 
#1    1827 days                                                                                 
#2    1828 days
# ....   

df - date
#             0
#0  1975-01-01                                                                                  
#1  1975-01-02                                                                                  
#2  1975-01-03
# ....

It seems like both should return timedeltas.

[jreback]

hmm, this should work, marking as a bug

[jreback]

this seems trivial, but is actually complicated because of this:

In [11]: df = DataFrame({'A' : np.arange(5), 'B' : pd.date_range('20130101',periods=5),'C' : 'foo'})

In [12]: df
Out[12]: 
   A          B    C
0  0 2013-01-01  foo
1  1 2013-01-02  foo
2  2 2013-01-03  foo
3  3 2013-01-04  foo
4  4 2013-01-05  foo

In [13]: df.dtypes
Out[13]: 
A             int64
B    datetime64[ns]
C            object
dtype: object

practically no arithmetic operations make sense with this frame, .eg
df+1, df-Timestamp('20130101') all blow up

that said I agree a compatible dtyped op should work

e.g.

df.select_dtypes(include=['datetime'])-Timestamp('20130101') should work
(and .... + Timestamp('20130101') should raise.

If these were series all is good, and will all work appropriately (and is easy to achive
by applying these ops).

[jbrockmendel]

Looked into this briefly, threw up my hands somewhere between core.internals and core.ops. Is the spaghetti in ops carefully optimized or the result of years of frankensteining?

[jreback]

Looked into this briefly, threw up my hands somewhere between core.internals and core.ops. Is the spaghetti in ops carefully optimized or the result of years of frankensteining?

the code in ops is mostly to handle multiple dispatch (before it became a thing)