SYMBOL INDEX (363 symbols across 67 files)

FILE: aggregate.go
  type GroupBy (line 17) | type GroupBy struct
  type AggregationType (line 24) | type AggregationType
    method String (line 39) | func (a AggregationType) String() string {
  constant Avg (line 27) | Avg AggregationType = iota
  constant Count (line 28) | Count
  constant CountDistinct (line 29) | CountDistinct
  constant Cusum (line 30) | Cusum
  constant Max (line 31) | Max
  constant Min (line 32) | Min
  constant Median (line 33) | Median
  constant Stddev (line 34) | Stddev
  constant Sum (line 35) | Sum
  constant Variance (line 36) | Variance
  type AggregateBy (line 67) | type AggregateBy struct
  method GroupBy (line 74) | func (dt *DataTable) GroupBy(by ...GroupBy) (*Groups, error) {
  method Aggregate (line 114) | func (dt *DataTable) Aggregate(by ...AggregateBy) (*DataTable, error) {
  type Groups (line 125) | type Groups struct
    method Aggregate (line 139) | func (g *Groups) Aggregate(aggs ...AggregateBy) (*DataTable, error) {
  type group (line 131) | type group struct

FILE: aggregate_test.go
  function TestAggregate (line 12) | func TestAggregate(t *testing.T) {

FILE: column.go
  type ColumnType (line 13) | type ColumnType
  constant Bool (line 16) | Bool   ColumnType = "bool"
  constant String (line 17) | String ColumnType = "string"
  constant Int (line 18) | Int    ColumnType = "int"
  constant Int32 (line 21) | Int32 ColumnType = "int32"
  constant Int64 (line 22) | Int64 ColumnType = "int64"
  constant Float32 (line 28) | Float32 ColumnType = "float32"
  constant Float64 (line 29) | Float64 ColumnType = "float64"
  constant Time (line 30) | Time    ColumnType = "time"
  constant Raw (line 31) | Raw     ColumnType = "raw"
  type ColumnOptions (line 35) | type ColumnOptions struct
  type ColumnOption (line 43) | type ColumnOption
  function ColumnHidden (line 46) | func ColumnHidden(v bool) ColumnOption {
  function Expr (line 54) | func Expr(v string) ColumnOption {
  function Values (line 62) | func Values(v ...interface{}) ColumnOption {
  function TimeFormats (line 70) | func TimeFormats(v ...string) ColumnOption {
  type ColumnSerier (line 77) | type ColumnSerier
  function init (line 82) | func init() {
  function RegisterColumnType (line 118) | func RegisterColumnType(name ColumnType, serier ColumnSerier) error {
  function ColumnTypes (line 135) | func ColumnTypes() []ColumnType {
  function newColumnSerie (line 144) | func newColumnSerie(ctyp ColumnType, options ColumnOptions) (serie.Serie...
  type Column (line 153) | type Column interface
  type column (line 162) | type column struct
    method Name (line 171) | func (c *column) Name() string {
    method Type (line 175) | func (c *column) Type() ColumnType {
    method UnderlyingType (line 179) | func (c *column) UnderlyingType() reflect.Type {
    method IsVisible (line 183) | func (c *column) IsVisible() bool {
    method IsComputed (line 187) | func (c *column) IsComputed() bool {
    method emptyCopy (line 191) | func (c *column) emptyCopy() *column {
    method copy (line 207) | func (c *column) copy() *column {

FILE: concat.go
  method Concat (line 4) | func (left *DataTable) Concat(table ...*DataTable) (*DataTable, error) {
  function Concat (line 55) | func Concat(tables []*DataTable) (*DataTable, error) {

FILE: concat_test.go
  function sampleForConcat (line 12) | func sampleForConcat(t *testing.T) (*datatable.DataTable, *datatable.Dat...
  function TestSimpleConcat (line 50) | func TestSimpleConcat(t *testing.T) {
  function TestGrowColConcat (line 70) | func TestGrowColConcat(t *testing.T) {
  function TestConcatWithExpr (line 92) | func TestConcatWithExpr(t *testing.T) {

FILE: copy.go
  method EmptyCopy (line 4) | func (t *DataTable) EmptyCopy() *DataTable {
  method Copy (line 21) | func (t *DataTable) Copy() *DataTable {

FILE: copy_test.go
  function TestEmptyCopy (line 9) | func TestEmptyCopy(t *testing.T) {
  function TestCopy (line 19) | func TestCopy(t *testing.T) {

FILE: eval_expr.go
  method evaluateExpressions (line 6) | func (t *DataTable) evaluateExpressions() error {

FILE: export.go
  type ExportOptions (line 4) | type ExportOptions struct
  type ExportOption (line 8) | type ExportOption
  function ExportHidden (line 11) | func ExportHidden(v bool) ExportOption {
  function newExportOptions (line 18) | func newExportOptions(opt ...ExportOption) ExportOptions {
  method ToMap (line 28) | func (t *DataTable) ToMap(opt ...ExportOption) []map[string]interface{} {
  method ToTable (line 58) | func (t *DataTable) ToTable(opt ...ExportOption) [][]interface{} {
  type Schema (line 92) | type Schema struct
  type SchemaColumn (line 98) | type SchemaColumn struct
  method ToSchema (line 104) | func (t *DataTable) ToSchema(opt ...ExportOption) *Schema {

FILE: export_test.go
  function sampleForExport (line 11) | func sampleForExport(t *testing.T) *datatable.DataTable {
  function TestToTable (line 56) | func TestToTable(t *testing.T) {
  function TestToMap (line 88) | func TestToMap(t *testing.T) {
  function TestToSchema (line 119) | func TestToSchema(t *testing.T) {

FILE: hasher.go
  type hasherImpl (line 12) | type hasherImpl struct
    method Row (line 14) | func (h *hasherImpl) Row(row Row, cols []string) uint64 {
    method Table (line 28) | func (h *hasherImpl) Table(dt *DataTable, cols []string) map[uint64][]...

FILE: import/csv/import.go
  function Import (line 15) | func Import(name, path string, opt ...Option) (*datatable.DataTable, err...
  function detectTypes (line 108) | func detectTypes(rec, dateformat []string) []datatable.ColumnType {

FILE: import/csv/import_test.go
  function TestImport (line 15) | func TestImport(t *testing.T) {

FILE: import/csv/options.go
  type Options (line 6) | type Options struct
  type Option (line 19) | type Option
  function HasHeader (line 22) | func HasHeader(v bool) Option {
  function ColumnNames (line 29) | func ColumnNames(v ...string) Option {
  function ColumnTypes (line 36) | func ColumnTypes(v ...datatable.ColumnType) Option {
  function IgnoreLineWithError (line 43) | func IgnoreLineWithError(v bool) Option {
  function Comma (line 51) | func Comma(v rune) Option {
  function Comment (line 59) | func Comment(v rune) Option {
  function LazyQuotes (line 67) | func LazyQuotes(v bool) Option {
  function TrimLeadingSpace (line 75) | func TrimLeadingSpace(v bool) Option {
  function AcceptDate (line 82) | func AcceptDate(v string) Option {

FILE: join.go
  method InnerJoin (line 13) | func (left *DataTable) InnerJoin(right *DataTable, on []JoinOn) (*DataTa...
  function InnerJoin (line 19) | func InnerJoin(tables []*DataTable, on []JoinOn) (*DataTable, error) {
  method LeftJoin (line 26) | func (left *DataTable) LeftJoin(right *DataTable, on []JoinOn) (*DataTab...
  function LeftJoin (line 32) | func LeftJoin(tables []*DataTable, on []JoinOn) (*DataTable, error) {
  method RightJoin (line 39) | func (left *DataTable) RightJoin(right *DataTable, on []JoinOn) (*DataTa...
  function RightJoin (line 45) | func RightJoin(tables []*DataTable, on []JoinOn) (*DataTable, error) {
  method OuterJoin (line 51) | func (left *DataTable) OuterJoin(right *DataTable, on []JoinOn) (*DataTa...
  function OuterJoin (line 57) | func OuterJoin(tables []*DataTable, on []JoinOn) (*DataTable, error) {
  type JoinOn (line 61) | type JoinOn struct
  function On (line 71) | func On(fields ...string) []JoinOn {
  function Using (line 95) | func Using(fields ...string) []JoinOn {
  type joinType (line 103) | type joinType
  constant innerJoin (line 106) | innerJoin joinType = iota
  constant leftJoin (line 107) | leftJoin
  constant rightJoin (line 108) | rightJoin
  constant outerJoin (line 109) | outerJoin
  function colname (line 112) | func colname(dt *DataTable, col string) string {
  type joinClause (line 120) | type joinClause struct
    method copyColumnsTo (line 130) | func (jc *joinClause) copyColumnsTo(out *DataTable) error {
    method initHashTable (line 170) | func (jc *joinClause) initHashTable() {
  type joinImpl (line 175) | type joinImpl struct
    method Compute (line 191) | func (j *joinImpl) Compute() (*DataTable, error) {
    method checkInput (line 214) | func (j *joinImpl) checkInput() error {
    method initColMapper (line 236) | func (j *joinImpl) initColMapper() {
    method join (line 246) | func (j *joinImpl) join(left, right *DataTable) (*DataTable, error) {
  function newJoinImpl (line 183) | func newJoinImpl(mode joinType, tables []*DataTable, on []JoinOn) *joinI...

FILE: join_test.go
  function sampleForJoin (line 13) | func sampleForJoin() (*datatable.DataTable, *datatable.DataTable) {
  function TestJoinOn (line 35) | func TestJoinOn(t *testing.T) {
  function TestInnerJoin (line 61) | func TestInnerJoin(t *testing.T) {
  function TestLeftJoin (line 76) | func TestLeftJoin(t *testing.T) {
  function TestRightJoin (line 93) | func TestRightJoin(t *testing.T) {
  function TestOuterJoin (line 110) | func TestOuterJoin(t *testing.T) {
  function TestInnerJoinWithExprOnHidden (line 128) | func TestInnerJoinWithExprOnHidden(t *testing.T) {
  function TestLeftJoinWithExpr (line 148) | func TestLeftJoinWithExpr(t *testing.T) {
  function TestRightJoinWithExpr (line 168) | func TestRightJoinWithExpr(t *testing.T) {
  function TestJoinWithColumnName (line 188) | func TestJoinWithColumnName(t *testing.T) {

FILE: mutate_column.go
  method addColumn (line 10) | func (t *DataTable) addColumn(col *column) error {
  method AddColumn (line 61) | func (t *DataTable) AddColumn(name string, ctyp ColumnType, opt ...Colum...
  method RenameColumn (line 83) | func (t *DataTable) RenameColumn(old, name string) error {
  method HideAll (line 103) | func (t *DataTable) HideAll() {
  method HideColumn (line 111) | func (t *DataTable) HideColumn(name string) {
  method ShowAll (line 119) | func (t *DataTable) ShowAll() {
  method ShowColumn (line 127) | func (t *DataTable) ShowColumn(name string) {
  method SwapColumn (line 134) | func (t *DataTable) SwapColumn(a, b string) error {

FILE: mutate_column_test.go
  function TestSwapColumn (line 9) | func TestSwapColumn(t *testing.T) {

FILE: mutate_row.go
  method NewRow (line 8) | func (t *DataTable) NewRow() Row {
  method Append (line 14) | func (t *DataTable) Append(row ...Row) {
  method AppendRow (line 34) | func (t *DataTable) AppendRow(v ...interface{}) error {
  method SwapRow (line 55) | func (t *DataTable) SwapRow(i, j int) {
  method Grow (line 62) | func (t *DataTable) Grow(size int) {
  method Update (line 69) | func (t *DataTable) Update(at int, row Row) error {

FILE: mutate_row_test.go
  function TestSwapRow (line 9) | func TestSwapRow(t *testing.T) {

FILE: row.go
  type Row (line 11) | type Row
    method Set (line 14) | func (r Row) Set(k string, v interface{}) Row {
    method Get (line 20) | func (r Row) Get(k string) interface{} {
    method Hash (line 30) | func (r Row) Hash() uint64 {

FILE: select.go
  method Subset (line 4) | func (t *DataTable) Subset(at, size int) *DataTable {
  method Head (line 20) | func (t *DataTable) Head(size int) *DataTable {
  method Tail (line 25) | func (t *DataTable) Tail(size int) *DataTable {

FILE: serie/converters.go
  function AsFloat64 (line 11) | func AsFloat64(s Serie, missing *float64) Serie {

FILE: serie/copy.go
  method makeEmptyCopy (line 7) | func (s *serie) makeEmptyCopy(capacity int) *serie {
  method EmptyCopy (line 17) | func (s *serie) EmptyCopy() Serie {
  method Copy (line 21) | func (s *serie) Copy() Serie {

FILE: serie/copy_test.go
  function TestCopy (line 10) | func TestCopy(t *testing.T) {
  function TestEmptyCopy (line 23) | func TestEmptyCopy(t *testing.T) {

FILE: serie/iterate.go
  method Iterator (line 4) | func (s *serie) Iterator() Iterator {
  type Iterator (line 13) | type Iterator interface
  type serieIterator (line 19) | type serieIterator struct
    method Next (line 24) | func (it *serieIterator) Next() bool {
    method Current (line 32) | func (it *serieIterator) Current() interface{} {
    method Reset (line 36) | func (it *serieIterator) Reset() {

FILE: serie/iterate_test.go
  function TestIterate (line 10) | func TestIterate(t *testing.T) {

FILE: serie/mutate.go
  method asValue (line 9) | func (s *serie) asValue(i interface{}) []reflect.Value {
  method Append (line 36) | func (s *serie) Append(v ...interface{}) {
  method Prepend (line 45) | func (s *serie) Prepend(v ...interface{}) error {
  method Insert (line 50) | func (s *serie) Insert(at int, v ...interface{}) (err error) {
  method Set (line 84) | func (s *serie) Set(at int, v interface{}) error {
  method Delete (line 101) | func (s *serie) Delete(at int) error {
  method Grow (line 116) | func (s *serie) Grow(size int) error {
  method Shrink (line 128) | func (s *serie) Shrink(size int) error {
  method Concat (line 144) | func (s *serie) Concat(serie ...Serie) error {
  method Clear (line 161) | func (s *serie) Clear() {

FILE: serie/mutate_test.go
  function TestAppend (line 10) | func TestAppend(t *testing.T) {
  function TestPrepend (line 21) | func TestPrepend(t *testing.T) {
  function TestInsert (line 32) | func TestInsert(t *testing.T) {
  function TestSet (line 43) | func TestSet(t *testing.T) {
  function TestDelete (line 62) | func TestDelete(t *testing.T) {
  function TestGrow (line 79) | func TestGrow(t *testing.T) {
  function TestShrink (line 94) | func TestShrink(t *testing.T) {
  function TestConcat (line 108) | func TestConcat(t *testing.T) {
  function TestClear (line 120) | func TestClear(t *testing.T) {

FILE: serie/select.go
  method Head (line 8) | func (s *serie) Head(size int) Serie {
  method Tail (line 13) | func (s *serie) Tail(size int) Serie {
  method Subset (line 18) | func (s *serie) Subset(at, size int) Serie {
  method Filter (line 34) | func (s *serie) Filter(predicate interface{}) Serie {
  method Distinct (line 67) | func (s *serie) Distinct() Serie {
  method Pick (line 86) | func (s *serie) Pick(at ...int) Serie {
  method Where (line 101) | func (s *serie) Where(predicate func(interface{}) bool) Serie {
  method NonNils (line 121) | func (s *serie) NonNils() Serie {

FILE: serie/select_test.go
  function TestHead (line 11) | func TestHead(t *testing.T) {
  function TestTail (line 23) | func TestTail(t *testing.T) {
  function TestSubset (line 35) | func TestSubset(t *testing.T) {
  function TestDistinct (line 69) | func TestDistinct(t *testing.T) {
  function TestPick (line 93) | func TestPick(t *testing.T) {
  function TestWhere (line 108) | func TestWhere(t *testing.T) {
  function TestNonNils (line 128) | func TestNonNils(t *testing.T) {

FILE: serie/serie.go
  type Serie (line 9) | type Serie interface
  type Interfacer (line 67) | type Interfacer interface
  constant Lt (line 72) | Lt = -1
  constant Eq (line 73) | Eq = 0
  constant Gt (line 74) | Gt = 1
  type serie (line 77) | type serie struct
    method Len (line 147) | func (s *serie) Len() int {
    method Type (line 152) | func (s *serie) Type() reflect.Type {
    method Slice (line 157) | func (s *serie) Slice() interface{} {
    method Get (line 165) | func (s *serie) Get(at int) interface{} {
    method All (line 174) | func (s *serie) All() []interface{} {
    method String (line 182) | func (s *serie) String() string {
  function New (line 85) | func New(typ interface{}, converter interface{}, comparer interface{}) S...

FILE: serie/serie_bool.go
  function Bool (line 7) | func Bool(v ...interface{}) Serie {
  function BoolN (line 15) | func BoolN(v ...interface{}) Serie {
  function asBool (line 23) | func asBool(i interface{}) bool {
  function compareBool (line 28) | func compareBool(a, b bool) int {
  type NullBool (line 38) | type NullBool struct
    method Interface (line 43) | func (b NullBool) Interface() interface{} {
  function asNullBool (line 50) | func asNullBool(i interface{}) NullBool {
  function compareNullBool (line 67) | func compareNullBool(a, b NullBool) int {

FILE: serie/serie_bool_test.go
  function TestSerieBool (line 11) | func TestSerieBool(t *testing.T) {
  function TestSerieBoolN (line 27) | func TestSerieBoolN(t *testing.T) {

FILE: serie/serie_float32.go
  function Float32 (line 7) | func Float32(v ...interface{}) Serie {
  function Float32N (line 15) | func Float32N(v ...interface{}) Serie {
  function asFloat32 (line 23) | func asFloat32(i interface{}) float32 {
  function compareFloat32 (line 28) | func compareFloat32(a, b float32) int {
  type NullFloat32 (line 38) | type NullFloat32 struct
    method Interface (line 43) | func (f NullFloat32) Interface() interface{} {
  function asNullFloat32 (line 50) | func asNullFloat32(i interface{}) NullFloat32 {
  function compareNullFloat32 (line 67) | func compareNullFloat32(a, b NullFloat32) int {

FILE: serie/serie_float32_test.go
  function TestSerieFloat32 (line 11) | func TestSerieFloat32(t *testing.T) {
  function TestSerieFloat32N (line 26) | func TestSerieFloat32N(t *testing.T) {

FILE: serie/serie_float64.go
  function Float64 (line 7) | func Float64(v ...interface{}) Serie {
  function Float64N (line 15) | func Float64N(v ...interface{}) Serie {
  function asFloat64 (line 23) | func asFloat64(i interface{}) float64 {
  function compareFloat64 (line 28) | func compareFloat64(a, b float64) int {
  type NullFloat64 (line 38) | type NullFloat64 struct
    method Interface (line 43) | func (f NullFloat64) Interface() interface{} {
  function asNullFloat64 (line 50) | func asNullFloat64(i interface{}) NullFloat64 {
  function compareNullFloat64 (line 67) | func compareNullFloat64(a, b NullFloat64) int {

FILE: serie/serie_float64_test.go
  function TestSerieFloat64 (line 11) | func TestSerieFloat64(t *testing.T) {
  function TestSerieFloat64N (line 26) | func TestSerieFloat64N(t *testing.T) {

FILE: serie/serie_int.go
  function Int (line 7) | func Int(v ...interface{}) Serie {
  function IntN (line 15) | func IntN(v ...interface{}) Serie {
  function asInt (line 23) | func asInt(i interface{}) int {
  function compareInt (line 28) | func compareInt(a, b int) int {
  type NullInt (line 38) | type NullInt struct
    method Interface (line 43) | func (i NullInt) Interface() interface{} {
  function asNullInt (line 50) | func asNullInt(i interface{}) NullInt {
  function compareNullInt (line 67) | func compareNullInt(a, b NullInt) int {

FILE: serie/serie_int32.go
  function Int32 (line 7) | func Int32(v ...interface{}) Serie {
  function Int32N (line 15) | func Int32N(v ...interface{}) Serie {
  function asInt32 (line 23) | func asInt32(i interface{}) int32 {
  function compareInt32 (line 28) | func compareInt32(a, b int32) int {
  type NullInt32 (line 38) | type NullInt32 struct
    method Interface (line 43) | func (i NullInt32) Interface() interface{} {
  function asNullInt32 (line 50) | func asNullInt32(i interface{}) NullInt32 {
  function compareNullInt32 (line 67) | func compareNullInt32(a, b NullInt32) int {

FILE: serie/serie_int32_test.go
  function TestSerieInt32 (line 11) | func TestSerieInt32(t *testing.T) {
  function TestSerieInt32N (line 49) | func TestSerieInt32N(t *testing.T) {

FILE: serie/serie_int64.go
  function Int64 (line 7) | func Int64(v ...interface{}) Serie {
  function Int64N (line 15) | func Int64N(v ...interface{}) Serie {
  function asInt64 (line 23) | func asInt64(i interface{}) int64 {
  function compareInt64 (line 28) | func compareInt64(a, b int64) int {
  type NullInt64 (line 38) | type NullInt64 struct
    method Interface (line 43) | func (i NullInt64) Interface() interface{} {
  function asNullInt64 (line 50) | func asNullInt64(i interface{}) NullInt64 {
  function compareNullInt64 (line 67) | func compareNullInt64(a, b NullInt64) int {

FILE: serie/serie_int64_test.go
  function TestSerieInt64 (line 11) | func TestSerieInt64(t *testing.T) {
  function TestSerieInt64N (line 49) | func TestSerieInt64N(t *testing.T) {

FILE: serie/serie_int_test.go
  function TestSerieInt (line 11) | func TestSerieInt(t *testing.T) {
  function TestSerieIntN (line 25) | func TestSerieIntN(t *testing.T) {

FILE: serie/serie_raw.go
  function Raw (line 8) | func Raw(v ...interface{}) Serie {
  type RawValue (line 16) | type RawValue struct
    method Interface (line 21) | func (r RawValue) Interface() interface{} {
    method String (line 28) | func (r RawValue) String() string {
  function asRawValue (line 32) | func asRawValue(i interface{}) RawValue {
  function compareRawValue (line 45) | func compareRawValue(a, b RawValue) int {

FILE: serie/serie_raw_test.go
  function TestSerieRaw (line 11) | func TestSerieRaw(t *testing.T) {

FILE: serie/serie_string.go
  function String (line 10) | func String(v ...interface{}) Serie {
  function StringN (line 19) | func StringN(v ...interface{}) Serie {
  function asString (line 27) | func asString(i interface{}) string {
  type NullString (line 32) | type NullString struct
    method Interface (line 37) | func (s NullString) Interface() interface{} {
  function asNullString (line 44) | func asNullString(i interface{}) NullString {
  function compareNullString (line 61) | func compareNullString(a, b NullString) int {

FILE: serie/serie_string_test.go
  function TestString (line 9) | func TestString(t *testing.T) {

FILE: serie/serie_test.go
  function TestNewSerie (line 11) | func TestNewSerie(t *testing.T) {

FILE: serie/serie_time.go
  function Time (line 10) | func Time(format ...string) Serie {
  function TimeN (line 15) | func TimeN(format ...string) Serie {
  function compareTime (line 19) | func compareTime(a, b time.Time) int {
  function asTime (line 29) | func asTime(formats []string) func(interface{}) time.Time {
  type NullTime (line 36) | type NullTime struct
    method Interface (line 41) | func (t NullTime) Interface() interface{} {
  function asNullTime (line 48) | func asNullTime(formats []string) func(interface{}) NullTime {
  function compareNullTime (line 67) | func compareNullTime(a, b NullTime) int {

FILE: serie/serie_time_test.go
  function TestSerieTime (line 10) | func TestSerieTime(t *testing.T) {
  function TestSerieTimeN (line 26) | func TestSerieTimeN(t *testing.T) {

FILE: serie/sort.go
  method Swap (line 8) | func (s *serie) Swap(i, j int) {
  method Less (line 16) | func (s *serie) Less(i, j int) bool {
  method Compare (line 22) | func (s *serie) Compare(i, j int) int {
  method SortAsc (line 29) | func (s *serie) SortAsc() {
  method SortDesc (line 33) | func (s *serie) SortDesc() {

FILE: serie/sort_test.go
  function TestSortInt (line 10) | func TestSortInt(t *testing.T) {
  function TestSortString (line 38) | func TestSortString(t *testing.T) {

FILE: serie/stat.go
  type StatOptions (line 14) | type StatOptions struct
  type StatOption (line 18) | type StatOption
  function Missing (line 21) | func Missing(f float64) StatOption {
  method asFloats (line 27) | func (s *serie) asFloats(opt ...StatOption) []float64 {
  method Avg (line 38) | func (s *serie) Avg(opt ...StatOption) float64 {
  method Count (line 47) | func (s *serie) Count(opt ...StatOption) int64 {
  method CountDistinct (line 53) | func (s *serie) CountDistinct(opt ...StatOption) int64 {
  method Cusum (line 60) | func (s *serie) Cusum(opt ...StatOption) []float64 {
  method Max (line 77) | func (s *serie) Max(opt ...StatOption) float64 {
  method Min (line 87) | func (s *serie) Min(opt ...StatOption) float64 {
  method Median (line 97) | func (s *serie) Median(opt ...StatOption) float64 {
  method Stddev (line 112) | func (s *serie) Stddev(opt ...StatOption) float64 {
  method Sum (line 121) | func (s *serie) Sum(opt ...StatOption) float64 {
  method Variance (line 131) | func (s *serie) Variance(opt ...StatOption) float64 {

FILE: serie/stat_test.go
  function TestAvg (line 14) | func TestAvg(t *testing.T) {
  function TestCount (line 33) | func TestCount(t *testing.T) {
  function TestSum (line 51) | func TestSum(t *testing.T) {
  function TestMedian (line 58) | func TestMedian(t *testing.T) {

FILE: serie/utils_test.go
  function assertSerieEq (line 11) | func assertSerieEq(t *testing.T, s serie.Serie, v ...interface{}) {

FILE: serie_test.go
  function TestSerieFactory (line 9) | func TestSerieFactory(t *testing.T) {

FILE: sort.go
  type SortBy (line 10) | type SortBy struct
  type sorter (line 17) | type sorter struct
    method Len (line 22) | func (s *sorter) Len() int {
    method Swap (line 26) | func (s *sorter) Swap(i, j int) {
    method Less (line 30) | func (s *sorter) Less(i, j int) bool {
  method Sort (line 47) | func (t *DataTable) Sort(by ...SortBy) *DataTable {

FILE: sort_test.go
  function TestSort (line 11) | func TestSort(t *testing.T) {

FILE: table.go
  function New (line 9) | func New(name string) *DataTable {
  type DataTable (line 14) | type DataTable struct
    method Name (line 23) | func (t *DataTable) Name() string {
    method Rename (line 28) | func (t *DataTable) Rename(name string) {
    method NumRows (line 33) | func (t *DataTable) NumRows() int {
    method NumCols (line 38) | func (t *DataTable) NumCols() int {
    method Columns (line 43) | func (t *DataTable) Columns() []string {
    method HiddenColumns (line 54) | func (t *DataTable) HiddenColumns() []string {
    method Column (line 66) | func (t *DataTable) Column(name string) Column {
    method ColumnIndex (line 77) | func (t *DataTable) ColumnIndex(name string) int {
    method Records (line 88) | func (t *DataTable) Records() [][]string {
    method Rows (line 118) | func (t *DataTable) Rows(opt ...ExportOption) []Row {
    method String (line 147) | func (t *DataTable) String() string {
    method Row (line 154) | func (t *DataTable) Row(at int, opt ...ExportOption) Row {

FILE: table_print.go
  type PrintOptions (line 13) | type PrintOptions struct
  type PrintOption (line 20) | type PrintOption
  function PrintColumnName (line 22) | func PrintColumnName(v bool) PrintOption {
  function PrintColumnType (line 28) | func PrintColumnType(v bool) PrintOption {
  function PrintRowNumber (line 34) | func PrintRowNumber(v bool) PrintOption {
  function PrintMaxRows (line 40) | func PrintMaxRows(v int) PrintOption {
  method Print (line 47) | func (t *DataTable) Print(writer io.Writer, opt ...PrintOption) {

FILE: table_print_test.go
  function TestPrint (line 10) | func TestPrint(t *testing.T) {

FILE: table_test.go
  function TestNewTable (line 11) | func TestNewTable(t *testing.T) {
  function TestNewRow (line 41) | func TestNewRow(t *testing.T) {
  function TestExprColumn (line 91) | func TestExprColumn(t *testing.T) {
  function TestAppendRow (line 109) | func TestAppendRow(t *testing.T) {
  function TestRows (line 129) | func TestRows(t *testing.T) {
  function TestRow (line 157) | func TestRow(t *testing.T) {

FILE: test/main.go
  function main (line 13) | func main() {

FILE: utils_test.go
  function checkTable (line 11) | func checkTable(t *testing.T, tb *datatable.DataTable, cells ...interfac...
  function New (line 32) | func New(t *testing.T) *datatable.DataTable {

FILE: where.go
  method Where (line 4) | func (t *DataTable) Where(predicate func(row Row) bool) *DataTable {

FILE: where_test.go
  function TestWhere (line 13) | func TestWhere(t *testing.T) {