def test_delitem_and_pop(self):
expected = self.panel['ItemA']
result = self.panel.pop('ItemA')
assert_frame_equal(expected, result)
self.assert_('ItemA' not in self.panel.items)
del self.panel['ItemB']
self.assert_('ItemB' not in self.panel.items)
self.assertRaises(Exception, self.panel.__delitem__, 'ItemB')
values = np.empty((3, 3, 3))
values[0] = 0
values[1] = 1
values[2] = 2
panel = WidePanel(values, range(3), range(3), range(3))
# did we delete the right row?
panelc = panel.copy()
del panelc[0]
assert_frame_equal(panelc[1], panel[1])
assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[1]
assert_frame_equal(panelc[0], panel[0])
assert_frame_equal(panelc[2], panel[2])
panelc = panel.copy()
del panelc[2]
assert_frame_equal(panelc[1], panel[1])
assert_frame_equal(panelc[0], panel[0])
def test_fromDict(self):
itema = self.panel['ItemA']
itemb = self.panel['ItemB']
d = {'A' : itema, 'B' : itemb[5:]}
wp = WidePanel.fromDict(d)
self.assert_(wp.major_axis.equals(self.panel.major_axis))
# intersect
wp = WidePanel.fromDict(d, intersect=True)
self.assert_(wp.major_axis.equals(itemb.index[5:]))
def aggregate(self, func):
"""
For given DataFrame, group index by given mapper function or dict, take
the sub-DataFrame (reindex) for this group and call apply(func)
on this sub-DataFrame. Return a DataFrame of the results for each
key.
Parameters
----------
mapper : function, dict-like, or string
Mapping or mapping function. If string given, must be a column
name in the frame
func : function
Function to use for aggregating groups
N.B.: func must produce one value from a Series, otherwise
an error will occur.
Optional: provide set mapping as dictionary
"""
axis_name = self.obj._get_axis_name(self.axis)
getter = lambda p, group: p.reindex(**{axis_name : group})
result_d = self._aggregate_generic(getter, func,
axis=self.axis)
result = WidePanel.fromDict(result_d, intersect=False)
if self.axis > 0:
result = result.swapaxes(0, self.axis)
return result
def forecast(self, h):
"""
Returns the forecasts at 1, 2, ..., n timesteps in the future.
"""
forecast = self._forecast_raw(h).T.swapaxes(1, 2)
index = xrange(1, 1 + h)
w = WidePanel(forecast, self._data.items, index, self._data.minor_axis)
return w
def test_ctor_dict(self):
itema = self.panel['ItemA']
itemb = self.panel['ItemB']
d = {'A' : itema, 'B' : itemb[5:]}
d2 = {'A' : itema._series, 'B' : itemb[5:]._series}
d3 = {'A' : DataFrame(itema._series),
'B' : DataFrame(itemb[5:]._series)}
wp = WidePanel.from_dict(d)
wp2 = WidePanel.from_dict(d2) # nested Dict
wp3 = WidePanel.from_dict(d3)
self.assert_(wp.major_axis.equals(self.panel.major_axis))
assert_panel_equal(wp, wp2)
# intersect
wp = WidePanel.from_dict(d, intersect=True)
self.assert_(wp.major_axis.equals(itemb.index[5:]))
# use constructor
assert_panel_equal(WidePanel(d), WidePanel.from_dict(d))
assert_panel_equal(WidePanel(d2), WidePanel.from_dict(d2))
assert_panel_equal(WidePanel(d3), WidePanel.from_dict(d3))
# cast
result = WidePanel(d, dtype=int)
expected = WidePanel(dict((k, v.astype(int)) for k, v in d.iteritems()))
def test_from_dict(self):
itema = self.panel['ItemA']
itemb = self.panel['ItemB']
d = {'A' : itema, 'B' : itemb[5:]}
d2 = {'A' : itema._series, 'B' : itemb[5:]._series}
d3 = {'A' : DataFrame(itema._series),
'B' : DataFrame(itemb[5:]._series)}
wp = WidePanel.from_dict(d)
wp2 = WidePanel.from_dict(d2) # nested Dict
wp3 = WidePanel.from_dict(d3)
self.assert_(wp.major_axis.equals(self.panel.major_axis))
assert_panel_equal(wp, wp2)
# intersect
wp = WidePanel.from_dict(d, intersect=True)
self.assert_(wp.major_axis.equals(itemb.index[5:]))
def test_fromDict(self):
itema = self.panel['ItemA']
itemb = self.panel['ItemB']
d = {'A' : itema, 'B' : itemb[5:]}
d2 = {'A' : itema._series, 'B' : itemb[5:]._series}
d3 = {'A' : DataFrame(itema._series),
'B' : DataFrame(itemb[5:]._series)}
wp = WidePanel.fromDict(d)
wp2 = WidePanel.fromDict(d2) # nested Dict
wp3 = WidePanel.fromDict(d3)
self.assert_(wp.major_axis.equals(self.panel.major_axis))
assert_panel_equal(wp, wp2)
# intersect
wp = WidePanel.fromDict(d, intersect=True)
self.assert_(wp.major_axis.equals(itemb.index[5:]))
def var_beta(self):
"""Returns the covariance of beta."""
result = {}
result_index = self._result_index
for i in xrange(len(self._var_beta_raw)):
dm = DataFrame(self._var_beta_raw[i], columns=self.beta.columns,
index=self.beta.columns)
result[result_index[i]] = dm
return WidePanel.fromDict(result, intersect=False)
def var_beta(self):
"""Returns the covariance of beta."""
result = {}
result_index = self._result_index
for i in xrange(len(self._var_beta_raw)):
dm = DataMatrix(self._var_beta_raw[i],
columns=self.beta.cols(),
index=self.beta.cols())
result[result_index[i]] = dm
return WidePanel.fromDict(result, intersect=False)
def _filter_data(self):
"""
"""
data = self._x_orig
cat_mapping = {}
if isinstance(data, LongPanel):
data = data.to_wide()
else:
if isinstance(data, WidePanel):
data = data.copy()
if not isinstance(data, SparseWidePanel):
data, cat_mapping = self._convert_x(data)
if not isinstance(data, WidePanel):
data = WidePanel.from_dict(data, intersect=True)
x_names = data.items
if self._weights is not None:
data['__weights__'] = self._weights
# Filter x's without y (so we can make a prediction)
filtered = data.to_long()
# Filter all data together using to_long
# convert to DataFrame
y = self._y_orig
if isinstance(y, Series):
y = y.unstack()
data['__y__'] = y
data_long = data.to_long()
x_filt = filtered.filter(x_names)
if self._weights:
weights_filt = filtered.ix[:, ['__weights__']]
else:
weights_filt = None
x = data_long.filter(x_names)
y = data_long.ix[:, ['__y__']]
if self._weights:
weights = data_long.ix[:, ['__weights__']]
else:
weights = None
return x, x_filt, y, weights, weights_filt, cat_mapping
def resid(self):
"""
Returns the DataFrame containing the residuals of the VAR regressions.
Each column x1 contains the residuals generated by regressing the x1
column of the input against the lagged input.
Returns
-------
DataFrame
"""
d = dict([(key, value.resid) for (key, value) in self.ols_results.iteritems()])
return WidePanel.fromDict(d)
def resid(self):
"""
Returns the DataMatrix containing the residuals of the VAR regressions.
Each column x1 contains the residuals generated by regressing the x1
column of the input against the lagged input.
Returns
-------
DataMatrix
"""
d = dict([(key, value.resid)
for (key, value) in self.ols_results.iteritems()])
return WidePanel.fromDict(d)
def _aggregate_generic(self, agger, axis=0):
result = {}
obj = self._get_obj_with_exclusions()
for name in self.primary:
data = self.get_group(name, obj=obj)
try:
result[name] = agger(data)
except Exception:
result[name] = data.apply(agger, axis=axis)
result = WidePanel.fromDict(result, intersect=False)
if axis > 0:
result = result.swapaxes(0, axis)
return result
def _filter_data(self):
"""
"""
data = self._x_orig
if isinstance(data, LongPanel):
cat_mapping = {}
data = data.toWide()
else:
data, cat_mapping = self._convert_x(data)
if not isinstance(data, WidePanel):
data = WidePanel.fromDict(data, intersect=True)
x_names = data.items
if self._weights is not None:
data['__weights__'] = self._weights
# Filter x's without y (so we can make a prediction)
filtered = data.toLong()
# Filter all data together using toLong
data['__y__'] = self._y_orig
data_long = data.toLong()
x_filt = filtered.filter(x_names)
if self._weights:
weights_filt = filtered['__weights__']
else:
weights_filt = None
x = data_long.filter(x_names)
y = data_long['__y__']
if self._weights:
weights = data_long['__weights__']
else:
weights = None
return x, x_filt, y, weights, weights_filt, cat_mapping
def _filter_data(self):
"""
"""
data = self._x_orig
if isinstance(data, LongPanel):
cat_mapping = {}
data = data.toWide()
else:
data, cat_mapping = self._convert_x(data)
if not isinstance(data, WidePanel):
data = WidePanel.fromDict(data, intersect=True)
x_names = data.items
if self._weights is not None:
data['__weights__'] = self._weights
# Filter x's without y (so we can make a prediction)
filtered = data.toLong()
# Filter all data together using toLong
data['__y__'] = self._y_orig
data_long = data.toLong()
x_filt = filtered.filter(x_names)
if self._weights:
weights_filt = filtered['__weights__']
else:
weights_filt = None
x = data_long.filter(x_names)
y = data_long['__y__']
if self._weights:
weights = data_long['__weights__']
else:
weights = None
return x, x_filt, y, weights, weights_filt, cat_mapping
def _prepare_data(data):
"""Converts the given data into a WidePanel."""
if isinstance(data, WidePanel):
return data
return WidePanel.fromDict(data)
def _prep_panel_data(data):
"""Converts the given data into a WidePanel."""
if isinstance(data, WidePanel):
return data
return WidePanel.fromDict(data)
