Method AggsToTableCopy

tensor/table/splits.go:455–509

AggsToTableCopy returns a Table containing this Splits' aggregate data and a copy of the first row of data for each split for all non-agg cols, which is useful for recording other data that goes along with aggregated values. Must have Levels and Aggs all created as in the split.Agg* methods. if colN

(colName bool)

// is just the corresponding agg column name -- otherwise it also includes
// the name of the aggregation function with a : divider (e.g., Name:Mean)
func (spl *Splits) AggsToTableCopy(colName bool) *Table {
	nsp := len(spl.Splits)
	if nsp == 0 {
		return nil
	}
	dt := spl.Splits[0].Table
	st := NewTable().SetNumRows(nsp)
	exmap := make(map[string]struct{})
	for _, cn := range spl.Levels {
		st.AddStringColumn(cn)
		exmap[cn] = struct{}{}
	}
	for _, ag := range spl.Aggs {
		col := dt.Columns[ag.ColumnIndex]
		an := dt.ColumnNames[ag.ColumnIndex]
		exmap[an] = struct{}{}
		if colName == AddAggName {
			an += ":" + ag.Name
		}
		st.AddFloat64TensorColumn(an, col.Shape().Sizes[1:], col.Shape().Names[1:]...)
	}
	var cpcol []string
	for _, cn := range dt.ColumnNames {
		if _, ok := exmap[cn]; !ok {
			cpcol = append(cpcol, cn)
			col := dt.ColumnByName(cn)
			st.AddColumn(col.Clone(), cn)
		}
	}
	for si, sidx := range spl.Splits {
		cidx := 0
		for ci := range spl.Levels {
			col := st.Columns[cidx]
			col.SetString1D(si, spl.Values[si][ci])
			cidx++
		}
		for _, ag := range spl.Aggs {
			col := st.Columns[cidx]
			_, csz := col.RowCellSize()
			sti := si * csz
			av := ag.Aggs[si]
			for j, a := range av {
				col.SetFloat1D(sti+j, a)
			}
			cidx++
		}
		if len(sidx.Indexes) > 0 {
			stidx := sidx.Indexes[0]
			for _, cn := range cpcol {
				st.CopyCell(cn, si, dt, cn, stidx)
			}
		}
	}
	return st
}

// Less calls the LessFunc for sorting
func (spl *Splits) Less(i, j int) bool {