Python Columns.add_dimension方法代码示例

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]
 def test_columns_add_dimensions_values(self):
     table = Columns((self.xs, self.ys),
                     kdims=['x'], vdims=['y'])
     table = table.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))))

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]

#.........这里部分代码省略.........

    def test_columns_index_single_row(self):
        columns = Columns(self.column_data, kdims=self.kdims,
                          vdims=self.vdims)
        row = columns['F', 12]
        self.assertEquals(type(row), Columns)
        self.compare_columns(row, Columns(self.column_data[2:],
                                          kdims=self.kdims,
                                          vdims=self.vdims))

    def test_columns_index_value1(self):
        columns = Columns(self.column_data, kdims=self.kdims,
                          vdims=self.vdims)
        self.assertEquals(columns['F', 12, 'Weight'], 10)

    def test_columns_index_value2(self):
        columns = Columns(self.column_data, kdims=self.kdims,
                          vdims=self.vdims)
        self.assertEquals(columns['F', 12, 'Height'], 0.8)

    def test_columns_sort_vdim(self):
        columns = Columns(pd.DataFrame({'x': self.xs, 'y': -self.ys}),
                          kdims=['x'], vdims=['y'])
        columns_sorted = Columns(pd.DataFrame({'x': self.xs[::-1], 'y': -self.ys[::-1]}),
                                 kdims=['x'], vdims=['y'])
        self.assertEqual(columns.sort('y'), columns_sorted)

    def test_columns_sort_heterogeneous_string(self):
        columns = Columns(self.column_data, kdims=self.kdims, vdims=self.vdims)
        columns_sorted = Columns([self.column_data[i] for i in [2, 0, 1]],
                                 kdims=self.kdims, vdims=self.vdims)
        self.assertEqual(columns.sort(), columns_sorted)

    def test_columns_add_dimensions_value(self):
        columns = self.columns.add_dimension('z', 1, 0)
        self.assertEqual(columns.kdims[1], 'z')
        self.compare_arrays(columns.dimension_values('z'), np.zeros(len(columns)))

    def test_columns_add_dimensions_values(self):
        columns = self.columns.add_dimension('z', 1, range(1,12))
        self.assertEqual(columns.kdims[1], 'z')
        self.compare_arrays(columns.dimension_values('z'), np.array(list(range(1,12))))

    def test_columns_getitem_column(self):
        self.compare_arrays(self.columns['y'], self.ys)

    def test_columns_collapse(self):
        collapsed = HoloMap({i: Columns(pd.DataFrame({'x': self.xs, 'y': self.ys*i}), kdims=['x'], vdims=['y'])
                             for i in range(10)}, kdims=['z']).collapse('z', np.mean)
        self.compare_columns(collapsed, Columns(pd.DataFrame({'x': self.xs, 'y': self.ys*4.5}), kdims=['x'], vdims=['y']))

    def test_columns_1d_reduce(self):
        self.assertEqual(self.columns.reduce('x', np.mean), np.float64(0.5))

    def test_columns_2d_reduce(self):
        columns = Columns(pd.DataFrame({'x': self.xs, 'y': self.ys, 'z': self.zs}),
                          kdims=['x', 'y'], vdims=['z'])
        self.assertEqual(np.array(columns.reduce(['x', 'y'], np.mean)),
                         np.array(0.12828985192891))

    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.reduce(['y'], np.mean),
                         Columns(pd.DataFrame({'x': self.xs, 'z': self.zs}),
                                 kdims=['x'], vdims=['z']))

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]
 def test_columns_add_dimensions_value(self):
     table = Columns((self.xs, self.ys),
                     kdims=['x'], vdims=['y'])
     table = table.add_dimension('z', 1, 0)
     self.assertEqual(table.kdims[1], 'z')
     self.compare_arrays(table.dimension_values('z'), np.zeros(len(table)))

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]

#.........这里部分代码省略.........
        self.assertEquals(row, indexed)

    def test_columns_index_rows_gender(self):
        table = Columns(zip(self.keys1, self.values1),
                        kdims=self.kdims, vdims=self.vdims)
        row = table['M',:]
        indexed = Columns(OrderedDict([(('M', 10), (15, 0.8)),
                                       (('M', 16), (18, 0.6))]),
                             kdims=self.kdims, vdims=self.vdims)
        self.assertEquals(row, indexed)

    def test_columns_index_row_age(self):
        table = Columns(zip(self.keys1, self.values1),
                        kdims=self.kdims, vdims=self.vdims)
        indexed = Columns(OrderedDict([(('F', 12), (10, 0.8))]),
                          kdims=self.kdims, vdims=self.vdims)
        self.assertEquals(table[:, 12], indexed)

    def test_columns_index_item_table(self):
        table = Columns(zip(self.keys1, self.values1),
                        kdims=self.kdims, vdims=self.vdims)
        indexed = Columns(OrderedDict([(('F', 12), (10, 0.8))]),
                          kdims=self.kdims, vdims=self.vdims)
        self.assertEquals(table['F', 12], indexed)


    def test_columns_index_value1(self):
        table = Columns(zip(self.keys1, self.values1),
                          kdims=self.kdims, vdims=self.vdims)
        self.assertEquals(table['F', 12, 'Weight'], 10)

    def test_columns_index_value2(self):
        table = Columns(zip(self.keys1, self.values1),
                          kdims=self.kdims, vdims=self.vdims)
        self.assertEquals(table['F', 12, 'Height'], 0.8)

    def test_columns_getitem_column(self):
        self.compare_arrays(self.columns['y'], self.ys)

    def test_columns_add_dimensions_value(self):
        table = self.columns.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(self):
        table = self.columns.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))))

    def test_columns_collapse(self):
        collapsed = HoloMap({i: Columns(dict(zip(self.xs, self.ys*i)), kdims=['x'], vdims=['y'])
                             for i in range(10)}, kdims=['z']).collapse('z', np.mean)
        self.compare_columns(collapsed, Columns(zip(zip(self.xs), self.ys*4.5),
                                                kdims=['x'], vdims=['y']))

    def test_columns_1d_reduce(self):
        self.assertEqual(self.columns.reduce('x', np.mean), np.float64(0.5))

    def test_columns_2d_reduce(self):
        columns = Columns(zip(zip(self.xs, self.ys), self.zs),
                          kdims=['x', 'y'], vdims=['z'])
        self.assertEqual(np.array(columns.reduce(['x', 'y'], np.mean)),
                         np.array(0.12828985192891))

    def test_columns_2d_partial_reduce(self):
        columns = Columns(zip(zip(self.xs, self.ys), self.zs),
                          kdims=['x', 'y'], vdims=['z'])
        reduced = Columns(zip(zip(self.xs), self.zs),
                          kdims=['x'], vdims=['z'])
        self.assertEqual(columns.reduce(['y'], np.mean), reduced)

    def test_columns_heterogeneous_reduce(self):
        columns = Columns(zip(self.keys1, self.values1), kdims=self.kdims,
                          vdims=self.vdims)
        reduced = Columns(zip([k[1:] for k in self.keys1], self.values1),
                          kdims=self.kdims[1:], vdims=self.vdims)
        self.assertEqual(columns.reduce(['Gender'], np.mean), reduced)

    def test_columns_heterogeneous_reduce2d(self):
        columns = Columns(zip(self.keys1, self.values1), kdims=self.kdims,
                          vdims=self.vdims)
        reduced = Columns([((), (14.333333333333334, 0.73333333333333339))], kdims=[], vdims=self.vdims)
        self.assertEqual(columns.reduce(function=np.mean), reduced)

    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(self):
        columns = Columns(zip(zip(self.xs, self.ys), self.zs),
                          kdims=['x', 'y'], vdims=['z'])
        reduced = Columns(zip(zip(self.xs), self.zs),
                          kdims=['x'], vdims=['z'])
        self.assertEqual(columns.aggregate(['x'], np.mean), reduced)

    def test_columns_array(self):
        self.assertEqual(self.columns.array(), np.column_stack([self.xs, self.ys]))

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]
class HomogeneousColumnTypes(object):
    """
    Tests for data formats that require all columns to have the same
    type (e.g numpy arrays)
    """

    def setUp(self):
        self.restore_datatype = Columns.datatype
        self.data_instance_type = None

    def init_data(self):
        self.xs = range(11)
        self.xs_2 = [el**2 for el in self.xs]

        self.y_ints = [i*2 for i in range(11)]
        self.columns_hm = Columns(np.column_stack([self.xs, self.y_ints]),
                                  kdims=['x'], vdims=['y'])

    def tearDown(self):
        Columns.datatype = self.restore_datatype

    # Test the array constructor (homogenous data) to be supported by
    # all interfaces.

    def test_columns_array_init_hm(self):
        "Tests support for arrays (homogeneous)"
        columns = Columns(np.column_stack([self.xs, self.xs_2]),
                          kdims=['x'], vdims=['x2'])
        self.assertTrue(isinstance(columns.data, self.data_instance_type))

    def test_columns_ndelement_init_hm(self):
        "Tests support for homogeneous NdElement (backwards compatibility)"
        columns = Columns(NdElement(zip(self.xs, self.xs_2),
                                    kdims=['x'], vdims=['x2']))
        self.assertTrue(isinstance(columns.data, self.data_instance_type))

    def test_columns_dataframe_init_hm(self):
        "Tests support for homogeneous DataFrames"
        if pd is None:
            raise SkipTest("Pandas not available")
        columns = Columns(pd.DataFrame({'x':self.xs, 'x2':self.xs_2}),
                          kdims=['x'], vdims=[ 'x2'])
        self.assertTrue(isinstance(columns.data, self.data_instance_type))

    # Properties and information

    def test_columns_shape(self):
        self.assertEqual(self.columns_hm.shape, (11, 2))

    def test_columns_range(self):
        self.assertEqual(self.columns_hm.range('y'), (0, 20))

    def test_columns_closest(self):
        closest = self.columns_hm.closest([0.51, 1, 9.9])
        self.assertEqual(closest, [1., 1., 10.])

    # Operations

    def test_columns_sort_vdim_hm(self):
        xs_2 = np.array(self.xs_2)
        columns = Columns(np.column_stack([self.xs, -xs_2]),
                                 kdims=['x'], vdims=['y'])
        columns_sorted = Columns(np.column_stack([self.xs[::-1], -xs_2[::-1]]),
                                 kdims=['x'], vdims=['y'])
        self.assertEqual(columns.sort('y'), columns_sorted)

    def test_columns_sample_hm(self):
        samples = self.columns_hm.sample([0, 5, 10]).dimension_values('y')
        self.assertEqual(samples, np.array([0, 10, 20]))

    def test_columns_array_hm(self):
        self.assertEqual(self.columns_hm.array(),
                         np.column_stack([self.xs, self.y_ints]))

    def test_columns_add_dimensions_value_hm(self):
        table = self.columns_hm.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_hm(self):
        table =  self.columns_hm.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))))


    def test_columns_slice_hm(self):
        columns_slice = Columns({'x':range(5, 9), 'y':[2*i for i in range(5, 9)]},
                                kdims=['x'], vdims=['y'])
        self.assertEqual(self.columns_hm[5:9], columns_slice)

    def test_columns_1D_reduce_hm(self):
        columns = Columns({'x':self.xs, 'y':self.y_ints}, kdims=['x'], vdims=['y'])
        self.assertEqual(columns.reduce('x', np.mean), 10)

    def test_columns_2D_reduce_hm(self):
        columns = Columns({'x':self.xs, 'y':self.y_ints, 'z':[el**2 for el in self.y_ints]},
                          kdims=['x', 'y'], vdims=['z'])
        self.assertEqual(np.array(columns.reduce(['x', 'y'], np.mean)),
                         np.array(140))

#.........这里部分代码省略.........

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]

#.........这里部分代码省略.........
                          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):

# 需要导入模块: from holoviews import Columns [as 别名]
# 或者: from holoviews.Columns import add_dimension [as 别名]
class GridColumnsTest(HomogeneousColumnTypes, ComparisonTestCase):
    """
    Test of the NdColumns interface (mostly for backwards compatibility)
    """

    def setUp(self):
        self.restore_datatype = Columns.datatype
        Columns.datatype = ['grid']
        self.data_instance_type = dict
        self.init_data()

    def init_data(self):
        self.xs = range(11)
        self.xs_2 = [el**2 for el in self.xs]

        self.y_ints = [i*2 for i in range(11)]
        self.columns_hm = Columns((self.xs, self.y_ints),
                                  kdims=['x'], vdims=['y'])

    def test_columns_array_init_hm(self):
        "Tests support for arrays (homogeneous)"
        exception = "None of the available storage backends "\
         "were able to support the supplied data format."
        with self.assertRaisesRegexp(Exception, exception):
            Columns(np.column_stack([self.xs, self.xs_2]),
                    kdims=['x'], vdims=['x2'])

    def test_columns_dataframe_init_hm(self):
        "Tests support for homogeneous DataFrames"
        if pd is None:
            raise SkipTest("Pandas not available")
        exception = "None of the available storage backends "\
         "were able to support the supplied data format."
        with self.assertRaisesRegexp(Exception, exception):
            Columns(pd.DataFrame({'x':self.xs, 'x2':self.xs_2}),
                    kdims=['x'], vdims=['x2'])

    def test_columns_ndelement_init_hm(self):
        "Tests support for homogeneous NdElement (backwards compatibility)"
        exception = "None of the available storage backends "\
         "were able to support the supplied data format."
        with self.assertRaisesRegexp(Exception, exception):
            Columns(NdElement(zip(self.xs, self.xs_2),
                              kdims=['x'], vdims=['x2']))

    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_reduce_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(np.array(columns.reduce(['x', 'y'], np.mean)),
                         np.mean(array))

    def test_columns_add_dimensions_value_hm(self):
        with self.assertRaisesRegexp(Exception, 'Cannot add key dimension to a dense representation.'):
            self.columns_hm.add_dimension('z', 1, 0)

    def test_columns_add_dimensions_values_hm(self):
        table =  self.columns_hm.add_dimension('z', 1, range(1,12), vdim=True)
        self.assertEqual(table.vdims[1], 'z')
        self.compare_arrays(table.dimension_values('z'), np.array(list(range(1,12))))

    def test_columns_sort_vdim_hm(self):
        exception = ('Compressed format cannot be sorted, either instantiate '
                     'in the desired order or use the expanded format.')
        with self.assertRaisesRegexp(Exception, exception):
            self.columns_hm.sort('y')


    def test_columns_groupby(self):
        self.assertEqual(self.columns_hm.groupby('x').keys(), list(self.xs))