def test_columns_heterogeneous_aggregate(self):
columns = Columns(self.column_data, kdims=self.kdims,
vdims=self.vdims)
aggregated = Columns(pd.DataFrame([('F', 10., 0.8), ('M', 16.5, 0.7)],
columns=['Gender']+self.vdims),
kdims=self.kdims[:1], vdims=self.vdims)
self.compare_columns(columns.aggregate(['Gender'], np.mean), aggregated)
def test_columns_2D_aggregate_partial_hm(self):
array = np.random.rand(11, 11)
columns = Columns({'x':self.xs, 'y':self.y_ints, 'z': array},
kdims=['x', 'y'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean),
Columns({'x':self.xs, 'z': np.mean(array, axis=1)},
kdims=['x'], vdims=['z']))
def test_columns_2D_aggregate_partial_ht(self):
columns = Columns({
'x': self.xs,
'y': self.ys,
'z': self.zs
},
kdims=['x', 'y'],
vdims=['z'])
reduced = Columns({
'x': self.xs,
'z': self.zs
},
kdims=['x'],
vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean), reduced)
def test_columns_2D_aggregate_partial_hm(self):
z_ints = [el**2 for el in self.y_ints]
columns = Columns({
'x': self.xs,
'y': self.y_ints,
'z': z_ints
},
kdims=['x', 'y'],
vdims=['z'])
self.assertEqual(
columns.aggregate(['x'], np.mean),
Columns({
'x': self.xs,
'z': z_ints
}, kdims=['x'], vdims=['z']))
def test_columns_2d_partial_reduce(self):
columns = Columns(pd.DataFrame({'x': self.xs, 'y': self.ys, 'z': self.zs}),
kdims=['x', 'y'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean),
Columns(pd.DataFrame({'x': self.xs, 'z': self.zs}),
kdims=['x'], vdims=['z']))
def test_columns_2d_aggregate_partial(self):
columns = Columns((self.xs, self.ys, self.zs), kdims=['x', 'y'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean),
Columns((self.xs, self.zs), kdims=['x'], vdims=['z']))
def test_column_heterogeneous_aggregate(self):
columns = Columns(zip(self.keys1, self.values1), kdims=self.kdims,
vdims=self.vdims)
aggregated = Columns(OrderedDict([('M', (16.5, 0.7)), ('F', (10., 0.8))]),
kdims=self.kdims[:1], vdims=self.vdims)
self.compare_columns(columns.aggregate(['Gender'], np.mean), aggregated)
def test_columns_2D_aggregate_partial_ht(self):
columns = Columns({'x':self.xs, 'y':self.ys, 'z':self.zs},
kdims=['x', 'y'], vdims=['z'])
reduced = Columns({'x':self.xs, 'z':self.zs},
kdims=['x'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean), reduced)
class HeterogeneousColumnTypes(HomogeneousColumnTypes):
"""
Tests for data formats that all columns to have varied types
"""
def init_data(self):
self.kdims = ['Gender', 'Age']
self.vdims = ['Weight', 'Height']
self.gender, self.age = ['M','M','F'], [10,16,12]
self.weight, self.height = [15,18,10], [0.8,0.6,0.8]
self.table = Columns({'Gender':self.gender, 'Age':self.age,
'Weight':self.weight, 'Height':self.height},
kdims=self.kdims, vdims=self.vdims)
super(HeterogeneousColumnTypes, self).init_data()
self.ys = np.linspace(0, 1, 11)
self.zs = np.sin(self.xs)
self.columns_ht = Columns({'x':self.xs, 'y':self.ys},
kdims=['x'], vdims=['y'])
# Test the constructor to be supported by all interfaces supporting
# heterogeneous column types.
def test_columns_ndelement_init_ht(self):
"Tests support for heterogeneous NdElement (backwards compatibility)"
columns = Columns(NdElement(zip(self.xs, self.ys), kdims=['x'], vdims=['y']))
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_dataframe_init_ht(self):
"Tests support for heterogeneous DataFrames"
if pd is None:
raise SkipTest("Pandas not available")
columns = Columns(pd.DataFrame({'x':self.xs, 'y':self.ys}), kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
# Test literal formats
def test_columns_uniq_dimvals_ht(self):
self.assertEqual(self.table.dimension_values('Gender', unique=True),
np.array(['M', 'F']))
def test_columns_implicit_indexing_init(self):
columns = Columns(self.ys, kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_tuple_init(self):
columns = Columns((self.xs, self.ys), kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_simple_zip_init(self):
columns = Columns(zip(self.xs, self.ys), kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_zip_init(self):
columns = Columns(zip(self.gender, self.age,
self.weight, self.height),
kdims=self.kdims, vdims=self.vdims)
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_odict_init(self):
columns = Columns(OrderedDict(zip(self.xs, self.ys)), kdims=['A'], vdims=['B'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_dict_init(self):
columns = Columns(dict(zip(self.xs, self.ys)), kdims=['A'], vdims=['B'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
# Operations
def test_columns_sort_vdim_ht(self):
columns = Columns({'x':self.xs, 'y':-self.ys},
kdims=['x'], vdims=['y'])
columns_sorted = Columns({'x':self.xs[::-1], 'y':-self.ys[::-1]},
kdims=['x'], vdims=['y'])
self.assertEqual(columns.sort('y'), columns_sorted)
def test_columns_sort_string_ht(self):
columns_sorted = Columns({'Gender':['F','M','M'], 'Age':[12,10,16],
'Weight':[10,15,18], 'Height':[0.8,0.8,0.6]},
kdims=self.kdims, vdims=self.vdims)
self.assertEqual(self.table.sort(), columns_sorted)
def test_columns_sample_ht(self):
samples = self.columns_ht.sample([0, 5, 10]).dimension_values('y')
self.assertEqual(samples, np.array([0, 0.5, 1]))
def test_columns_reduce_ht(self):
reduced = Columns({'Age':self.age, 'Weight':self.weight, 'Height':self.height},
kdims=self.kdims[1:], vdims=self.vdims)
self.assertEqual(self.table.reduce(['Gender'], np.mean), reduced)
def test_columns_1D_reduce_ht(self):
self.assertEqual(self.columns_ht.reduce('x', np.mean), np.float64(0.5))
def test_columns_2D_reduce_ht(self):
reduced = Columns({'Weight':[14.333333333333334], 'Height':[0.73333333333333339]},
kdims=[], vdims=self.vdims)
self.assertEqual(self.table.reduce(function=np.mean), reduced)
def test_columns_2D_partial_reduce_ht(self):
columns = Columns({'x':self.xs, 'y':self.ys, 'z':self.zs},
kdims=['x', 'y'], vdims=['z'])
reduced = Columns({'x':self.xs, 'z':self.zs},
kdims=['x'], vdims=['z'])
self.assertEqual(columns.reduce(['y'], np.mean), reduced)
def test_column_aggregate_ht(self):
aggregated = Columns({'Gender':['M','F'], 'Weight':[16.5,10], 'Height':[0.7,0.8]},
kdims=self.kdims[:1], vdims=self.vdims)
self.compare_columns(self.table.aggregate(['Gender'], np.mean), aggregated)
def test_columns_2D_aggregate_partial_ht(self):
columns = Columns({'x':self.xs, 'y':self.ys, 'z':self.zs},
kdims=['x', 'y'], vdims=['z'])
reduced = Columns({'x':self.xs, 'z':self.zs},
kdims=['x'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean), reduced)
def test_columns_groupby(self):
group1 = {'Age':[10,16], 'Weight':[15,18], 'Height':[0.8,0.6]}
group2 = {'Age':[12], 'Weight':[10], 'Height':[0.8]}
with sorted_context(False):
grouped = HoloMap([('M', Columns(group1, kdims=['Age'], vdims=self.vdims)),
('F', Columns(group2, kdims=['Age'], vdims=self.vdims))],
kdims=['Gender'])
self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_columns_add_dimensions_value_ht(self):
table = self.columns_ht.add_dimension('z', 1, 0)
self.assertEqual(table.kdims[1], 'z')
self.compare_arrays(table.dimension_values('z'), np.zeros(len(table)))
def test_columns_add_dimensions_values_ht(self):
table = self.columns_ht.add_dimension('z', 1, range(1,12))
self.assertEqual(table.kdims[1], 'z')
self.compare_arrays(table.dimension_values('z'), np.array(list(range(1,12))))
# Indexing
def test_columns_index_row_gender_female(self):
indexed = Columns({'Gender':['F'],'Age':[12],
'Weight':[10], 'Height':[0.8]},
kdims=self.kdims, vdims=self.vdims)
row = self.table['F',:]
self.assertEquals(row, indexed)
def test_columns_index_rows_gender_male(self):
row = self.table['M',:]
indexed = Columns({'Gender':['M','M'],'Age':[10,16],
'Weight':[15,18], 'Height':[0.8,0.6]},
kdims=self.kdims, vdims=self.vdims)
self.assertEquals(row, indexed)
def test_columns_index_row_age(self):
indexed = Columns({'Gender':['F'],'Age':[12],
'Weight':[10], 'Height':[0.8]},
kdims=self.kdims, vdims=self.vdims)
self.assertEquals(self.table[:, 12], indexed)
def test_columns_index_item_table(self):
indexed = Columns({'Gender':['F'],'Age':[12],
'Weight':[10], 'Height':[0.8]},
kdims=self.kdims, vdims=self.vdims)
self.assertEquals(self.table['F', 12], indexed)
def test_columns_index_value1(self):
self.assertEquals(self.table['F', 12, 'Weight'], 10)
def test_columns_index_value2(self):
self.assertEquals(self.table['F', 12, 'Height'], 0.8)
def test_columns_index_column_ht(self):
self.compare_arrays(self.columns_ht['y'], self.ys)
def test_columns_boolean_index(self):
row = self.table[np.array([True, True, False])]
indexed = Columns({'Gender':['M','M'],'Age':[10,16],
'Weight':[15,18], 'Height':[0.8,0.6]},
kdims=self.kdims, vdims=self.vdims)
self.assertEquals(row, indexed)
def test_columns_value_dim_index(self):
row = self.table[:, :, 'Weight']
indexed = Columns({'Gender':['M','M','F'],'Age':[10,16, 12],
'Weight':[15,18, 10]},
kdims=self.kdims, vdims=self.vdims[:1])
self.assertEquals(row, indexed)
def test_columns_value_dim_scalar_index(self):
row = self.table['M', 10, 'Weight']
self.assertEquals(row, 15)
# Casting
def test_columns_array_ht(self):
self.assertEqual(self.columns_ht.array(),
np.column_stack([self.xs, self.ys]))
def test_columns_2D_aggregate_partial_hm(self):
z_ints = [el**2 for el in self.y_ints]
columns = Columns({'x':self.xs, 'y':self.y_ints, 'z':z_ints},
kdims=['x', 'y'], vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean),
Columns({'x':self.xs, 'z':z_ints}, kdims=['x'], vdims=['z']))
class HeterogeneousColumnTypes(HomogeneousColumnTypes):
"""
Tests for data formats that all columns to have varied types
"""
def init_data(self):
self.kdims = ['Gender', 'Age']
self.vdims = ['Weight', 'Height']
self.gender, self.age = ['M', 'M', 'F'], [10, 16, 12]
self.weight, self.height = [15, 18, 10], [0.8, 0.6, 0.8]
self.table = Columns(
{
'Gender': self.gender,
'Age': self.age,
'Weight': self.weight,
'Height': self.height
},
kdims=self.kdims,
vdims=self.vdims)
super(HeterogeneousColumnTypes, self).init_data()
self.ys = np.linspace(0, 1, 11)
self.zs = np.sin(self.xs)
self.columns_ht = Columns({
'x': self.xs,
'y': self.ys
},
kdims=['x'],
vdims=['y'])
# Test the constructor to be supported by all interfaces supporting
# heterogeneous column types.
def test_columns_ndelement_init_ht(self):
"Tests support for heterogeneous NdElement (backwards compatibility)"
columns = Columns(
NdElement(zip(self.xs, self.ys), kdims=['x'], vdims=['y']))
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_dataframe_init_ht(self):
"Tests support for heterogeneous DataFrames"
if pd is None:
raise SkipTest("Pandas not available")
columns = Columns(pd.DataFrame({
'x': self.xs,
'y': self.ys
}),
kdims=['x'],
vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
# Test literal formats
def test_columns_implicit_indexing_init(self):
columns = Columns(self.ys, kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_tuple_init(self):
columns = Columns((self.xs, self.ys), kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_simple_zip_init(self):
columns = Columns(zip(self.xs, self.ys), kdims=['x'], vdims=['y'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_zip_init(self):
columns = Columns(zip(self.gender, self.age, self.weight, self.height),
kdims=self.kdims,
vdims=self.vdims)
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_odict_init(self):
columns = Columns(OrderedDict(zip(self.xs, self.ys)),
kdims=['A'],
vdims=['B'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
def test_columns_dict_init(self):
columns = Columns(dict(zip(self.xs, self.ys)),
kdims=['A'],
vdims=['B'])
self.assertTrue(isinstance(columns.data, self.data_instance_type))
# Operations
def test_columns_sort_vdim_ht(self):
columns = Columns({
'x': self.xs,
'y': -self.ys
},
kdims=['x'],
vdims=['y'])
columns_sorted = Columns({
'x': self.xs[::-1],
'y': -self.ys[::-1]
},
kdims=['x'],
vdims=['y'])
self.assertEqual(columns.sort('y'), columns_sorted)
def test_columns_sort_string_ht(self):
columns_sorted = Columns(
{
'Gender': ['F', 'M', 'M'],
'Age': [12, 10, 16],
'Weight': [10, 15, 18],
'Height': [0.8, 0.8, 0.6]
},
kdims=self.kdims,
vdims=self.vdims)
self.assertEqual(self.table.sort(), columns_sorted)
def test_columns_sample_ht(self):
samples = self.columns_ht.sample([0, 5, 10]).dimension_values('y')
self.assertEqual(samples, np.array([0, 0.5, 1]))
def test_columns_reduce_ht(self):
reduced = Columns(
{
'Age': self.age,
'Weight': self.weight,
'Height': self.height
},
kdims=self.kdims[1:],
vdims=self.vdims)
self.assertEqual(self.table.reduce(['Gender'], np.mean), reduced)
def test_columns_1D_reduce_ht(self):
self.assertEqual(self.columns_ht.reduce('x', np.mean), np.float64(0.5))
def test_columns_2D_reduce_ht(self):
reduced = Columns(
{
'Weight': [14.333333333333334],
'Height': [0.73333333333333339]
},
kdims=[],
vdims=self.vdims)
self.assertEqual(self.table.reduce(function=np.mean), reduced)
def test_columns_2D_partial_reduce_ht(self):
columns = Columns({
'x': self.xs,
'y': self.ys,
'z': self.zs
},
kdims=['x', 'y'],
vdims=['z'])
reduced = Columns({
'x': self.xs,
'z': self.zs
},
kdims=['x'],
vdims=['z'])
self.assertEqual(columns.reduce(['y'], np.mean), reduced)
def test_column_aggregate_ht(self):
aggregated = Columns(
{
'Gender': ['M', 'F'],
'Weight': [16.5, 10],
'Height': [0.7, 0.8]
},
kdims=self.kdims[:1],
vdims=self.vdims)
self.compare_columns(self.table.aggregate(['Gender'], np.mean),
aggregated)
def test_columns_2D_aggregate_partial_ht(self):
columns = Columns({
'x': self.xs,
'y': self.ys,
'z': self.zs
},
kdims=['x', 'y'],
vdims=['z'])
reduced = Columns({
'x': self.xs,
'z': self.zs
},
kdims=['x'],
vdims=['z'])
self.assertEqual(columns.aggregate(['x'], np.mean), reduced)
def test_columns_groupby(self):
group1 = {'Age': [10, 16], 'Weight': [15, 18], 'Height': [0.8, 0.6]}
group2 = {'Age': [12], 'Weight': [10], 'Height': [0.8]}
with sorted_context(False):
grouped = HoloMap(
[('M', Columns(group1, kdims=['Age'], vdims=self.vdims)),
('F', Columns(group2, kdims=['Age'], vdims=self.vdims))],
kdims=['Gender'])
self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_columns_add_dimensions_value_ht(self):
table = self.columns_ht.add_dimension('z', 1, 0)
self.assertEqual(table.kdims[1], 'z')
self.compare_arrays(table.dimension_values('z'), np.zeros(len(table)))
def test_columns_add_dimensions_values_ht(self):
table = self.columns_ht.add_dimension('z', 1, range(1, 12))
self.assertEqual(table.kdims[1], 'z')
self.compare_arrays(table.dimension_values('z'),
np.array(list(range(1, 12))))
# Indexing
def test_columns_index_row_gender_female(self):
indexed = Columns(
{
'Gender': ['F'],
'Age': [12],
'Weight': [10],
'Height': [0.8]
},
kdims=self.kdims,
vdims=self.vdims)
row = self.table['F', :]
self.assertEquals(row, indexed)
def test_columns_index_rows_gender_male(self):
row = self.table['M', :]
indexed = Columns(
{
'Gender': ['M', 'M'],
'Age': [10, 16],
'Weight': [15, 18],
'Height': [0.8, 0.6]
},
kdims=self.kdims,
vdims=self.vdims)
self.assertEquals(row, indexed)
def test_columns_index_row_age(self):
indexed = Columns(
{
'Gender': ['F'],
'Age': [12],
'Weight': [10],
'Height': [0.8]
},
kdims=self.kdims,
vdims=self.vdims)
self.assertEquals(self.table[:, 12], indexed)
def test_columns_index_item_table(self):
indexed = Columns(
{
'Gender': ['F'],
'Age': [12],
'Weight': [10],
'Height': [0.8]
},
kdims=self.kdims,
vdims=self.vdims)
self.assertEquals(self.table['F', 12], indexed)
def test_columns_index_value1(self):
self.assertEquals(self.table['F', 12, 'Weight'], 10)
def test_columns_index_value2(self):
self.assertEquals(self.table['F', 12, 'Height'], 0.8)
def test_columns_index_column_ht(self):
self.compare_arrays(self.columns_ht['y'], self.ys)
def test_columns_boolean_index(self):
row = self.table[np.array([True, True, False])]
indexed = Columns(
{
'Gender': ['M', 'M'],
'Age': [10, 16],
'Weight': [15, 18],
'Height': [0.8, 0.6]
},
kdims=self.kdims,
vdims=self.vdims)
self.assertEquals(row, indexed)
def test_columns_value_dim_index(self):
row = self.table[:, :, 'Weight']
indexed = Columns(
{
'Gender': ['M', 'M', 'F'],
'Age': [10, 16, 12],
'Weight': [15, 18, 10]
},
kdims=self.kdims,
vdims=self.vdims[:1])
self.assertEquals(row, indexed)
def test_columns_value_dim_scalar_index(self):
row = self.table['M', 10, 'Weight']
self.assertEquals(row, 15)
# Casting
def test_columns_array_ht(self):
self.assertEqual(self.columns_ht.array(),
np.column_stack([self.xs, self.ys]))
