dataframe: support other integer types

Author: gyuho

column.go

@@ -80,11 +80,11 @@ type Column interface {
 	// SortByStringDescending sorts Column in string descending order.
 	SortByStringDescending()
 
-	// SortByNumberAscending sorts Column in number(float) ascending order.
-	SortByNumberAscending()
+	// SortByFloat64Ascending sorts Column in number(float) ascending order.
+	SortByFloat64Ascending()
 
-	// SortByNumberDescending sorts Column in number(float) descending order.
-	SortByNumberDescending()
+	// SortByFloat64Descending sorts Column in number(float) descending order.
+	SortByFloat64Descending()
 
 	// SortByDurationAscending sorts Column in time.Duration ascending order.
 	SortByDurationAscending()
@@ -391,7 +391,7 @@ func (c *column) Copy() Column {
 
 func (c *column) SortByStringAscending()    { sort.Sort(ByStringAscending(c.data)) }
 func (c *column) SortByStringDescending()   { sort.Sort(ByStringDescending(c.data)) }
-func (c *column) SortByNumberAscending()    { sort.Sort(ByNumberAscending(c.data)) }
-func (c *column) SortByNumberDescending()   { sort.Sort(ByNumberDescending(c.data)) }
+func (c *column) SortByFloat64Ascending()   { sort.Sort(ByFloat64Ascending(c.data)) }
+func (c *column) SortByFloat64Descending()  { sort.Sort(ByFloat64Descending(c.data)) }
 func (c *column) SortByDurationAscending()  { sort.Sort(ByDurationAscending(c.data)) }
 func (c *column) SortByDurationDescending() { sort.Sort(ByDurationDescending(c.data)) }

column_test.go

@@ -268,12 +268,12 @@ func TestColumnSortByStringDescending(t *testing.T) {
 	}
 }
 
-func TestColumnSortByNumberAscending(t *testing.T) {
+func TestColumnSortByFloat64Ascending(t *testing.T) {
 	c := NewColumn("column")
 	for i := 0; i < 100; i++ {
 		c.PushBack(NewStringValue(i))
 	}
-	c.SortByNumberAscending()
+	c.SortByFloat64Ascending()
 	fv, err := c.Value(0)
 	if err != nil {
 		t.Fatal(err)
@@ -283,13 +283,13 @@ func TestColumnSortByNumberAscending(t *testing.T) {
 	}
 }
 
-func TestColumnSortByNumberDescending(t *testing.T) {
+func TestColumnSortByFloat64Descending(t *testing.T) {
 	c := NewColumn("column")
 	for i := 0; i < 100; i++ {
 		c.PushBack(NewStringValue(i))
 	}
 	c.PushBack(NewStringValue("199.9"))
-	c.SortByNumberDescending()
+	c.SortByFloat64Descending()
 	fv, err := c.Value(0)
 	if err != nil {
 		t.Fatal(err)

dataframe.go

@@ -469,13 +469,13 @@ func (f *frame) Sort(header string, st SortType, so SortOption) error {
 			lesses = []LessFunc{StringDescendingFunc(idx)}
 		}
 
-	case SortType_Number:
+	case SortType_Float64:
 		switch so {
 		case SortOption_Ascending:
-			lesses = []LessFunc{NumberAscendingFunc(idx)}
+			lesses = []LessFunc{Float64AscendingFunc(idx)}
 
 		case SortOption_Descending:
-			lesses = []LessFunc{NumberDescendingFunc(idx)}
+			lesses = []LessFunc{Float64DescendingFunc(idx)}
 		}
 
 	case SortType_Duration:

dataframe_test.go

@@ -418,7 +418,7 @@ func TestSort(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if err := fr.Sort("second", SortType_Number, SortOption_Descending); err != nil {
+	if err := fr.Sort("second", SortType_Float64, SortOption_Descending); err != nil {
 		t.Fatal(err)
 	}
 	fpath := "test.csv"

sorter.go

@@ -13,7 +13,7 @@ type (
 
 const (
 	SortType_String SortType = iota
-	SortType_Number
+	SortType_Float64
 	SortType_Duration
 )
 
@@ -45,7 +45,7 @@ func StringDescendingFunc(idx int) func(row1, row2 *[]string) bool {
 	}
 }
 
-func NumberAscendingFunc(idx int) func(row1, row2 *[]string) bool {
+func Float64AscendingFunc(idx int) func(row1, row2 *[]string) bool {
 	return func(row1, row2 *[]string) bool {
 		v1s := (*row1)[idx]
 		v1, _ := strconv.ParseFloat(v1s, 64)
@@ -55,7 +55,7 @@ func NumberAscendingFunc(idx int) func(row1, row2 *[]string) bool {
 	}
 }
 
-func NumberDescendingFunc(idx int) func(row1, row2 *[]string) bool {
+func Float64DescendingFunc(idx int) func(row1, row2 *[]string) bool {
 	return func(row1, row2 *[]string) bool {
 		v1s := (*row1)[idx]
 		v1, _ := strconv.ParseFloat(v1s, 64)

value.go

@@ -11,8 +11,14 @@ type Value interface {
 	// String parses Value to string. It returns false if not possible.
 	String() (string, bool)
 
-	// Number parses Value to float64. It returns false if not possible.
-	Number() (float64, bool)
+	// Int64 parses Value to int64. It returns false if not possible.
+	Int64() (int64, bool)
+
+	// Uint64 parses Value to uint64. It returns false if not possible.
+	Uint64() (uint64, bool)
+
+	// Float64 parses Value to float64. It returns false if not possible.
+	Float64() (float64, bool)
 
 	// Time parses Value to time.Time based on the layout. It returns false if not possible.
 	Time(layout string) (time.Time, bool)
@@ -30,6 +36,7 @@ type Value interface {
 	Copy() Value
 }
 
+// NewStringValue takes any interface and returns Value.
 func NewStringValue(v interface{}) Value {
 	switch t := v.(type) {
 	case string:
@@ -54,17 +61,29 @@ func NewStringValue(v interface{}) Value {
 	return nil
 }
 
+// NewStringValueNil returns an empty value.
 func NewStringValueNil() Value {
 	return String("")
 }
 
+// String defines string data types.
 type String string
 
 func (s String) String() (string, bool) {
 	return string(s), true
 }
 
-func (s String) Number() (float64, bool) {
+func (s String) Int64() (int64, bool) {
+	iv, err := strconv.ParseInt(string(s), 10, 64)
+	return iv, err == nil
+}
+
+func (s String) Uint64() (uint64, bool) {
+	iv, err := strconv.ParseUint(string(s), 10, 64)
+	return iv, err == nil
+}
+
+func (s String) Float64() (float64, bool) {
 	f, err := strconv.ParseFloat(string(s), 64)
 	return f, err == nil
 }
@@ -124,35 +143,35 @@ func (vs ByStringDescending) Less(i, j int) bool {
 	return vs1 > vs2
 }
 
-type ByNumberAscending []Value
+type ByFloat64Ascending []Value
 
-func (vs ByNumberAscending) Len() int {
+func (vs ByFloat64Ascending) Len() int {
 	return len(vs)
 }
 
-func (vs ByNumberAscending) Swap(i, j int) {
+func (vs ByFloat64Ascending) Swap(i, j int) {
 	vs[i], vs[j] = vs[j], vs[i]
 }
 
-func (vs ByNumberAscending) Less(i, j int) bool {
-	vs1, _ := vs[i].Number()
-	vs2, _ := vs[j].Number()
+func (vs ByFloat64Ascending) Less(i, j int) bool {
+	vs1, _ := vs[i].Float64()
+	vs2, _ := vs[j].Float64()
 	return vs1 < vs2
 }
 
-type ByNumberDescending []Value
+type ByFloat64Descending []Value
 
-func (vs ByNumberDescending) Len() int {
+func (vs ByFloat64Descending) Len() int {
 	return len(vs)
 }
 
-func (vs ByNumberDescending) Swap(i, j int) {
+func (vs ByFloat64Descending) Swap(i, j int) {
 	vs[i], vs[j] = vs[j], vs[i]
 }
 
-func (vs ByNumberDescending) Less(i, j int) bool {
-	vs1, _ := vs[i].Number()
-	vs2, _ := vs[j].Number()
+func (vs ByFloat64Descending) Less(i, j int) bool {
+	vs1, _ := vs[i].Float64()
+	vs2, _ := vs[j].Float64()
 	return vs1 > vs2
 }
 

value_test.go

@@ -9,12 +9,12 @@ import (
 
 func TestValue(t *testing.T) {
 	v1 := NewStringValue("1")
-	if v, ok := v1.Number(); !ok {
+	if v, ok := v1.Float64(); !ok {
 		t.Fatalf("expected number 1, got %v", v)
 	}
 
 	v2 := NewStringValue("2.2")
-	if v, ok := v2.Number(); !ok || v != 2.2 {
+	if v, ok := v2.Float64(); !ok || v != 2.2 {
 		t.Fatalf("expected number 2.2, got %v", v)
 	}
 
@@ -40,6 +40,24 @@ func TestValue(t *testing.T) {
 	}
 }
 
+func TestValueInt(t *testing.T) {
+	v := NewStringValue("1")
+	fv, ok := v.Float64()
+	if !ok || fv != 1.0 {
+		t.Fatalf("expected number 1, got %f(%v)", fv, v)
+	}
+
+	iv, ok := v.Int64()
+	if !ok || iv != 1 {
+		t.Fatalf("expected number 1, got %d(%v)", iv, v)
+	}
+
+	uv, ok := v.Uint64()
+	if !ok || uv != 1 {
+		t.Fatalf("expected number 1, got %d(%v)", uv, v)
+	}
+}
+
 func TestNewStringValueNil(t *testing.T) {
 	v := NewStringValueNil()
 	if !v.IsNil() {
@@ -69,24 +87,24 @@ func TestByStringDescending(t *testing.T) {
 	}
 }
 
-func TestByNumberAscending(t *testing.T) {
+func TestByFloat64Ascending(t *testing.T) {
 	vs := []Value{}
 	for i := 0; i < 100; i++ {
 		vs = append(vs, NewStringValue(fmt.Sprintf("%d", i)))
 	}
-	sort.Sort(ByNumberAscending(vs))
+	sort.Sort(ByFloat64Ascending(vs))
 	if !vs[0].EqualTo(NewStringValue("0")) {
 		t.Fatalf("expected '0', got %v", vs[0])
 	}
 }
 
-func TestByNumberDescending(t *testing.T) {
+func TestByFloat64Descending(t *testing.T) {
 	vs := []Value{}
 	for i := 0; i < 100; i++ {
 		vs = append(vs, NewStringValue(fmt.Sprintf("%d", i)))
 	}
 	vs = append(vs, NewStringValue("199.9"))
-	sort.Sort(ByNumberDescending(vs))
+	sort.Sort(ByFloat64Descending(vs))
 	if !vs[0].EqualTo(NewStringValue("199.9")) {
 		t.Fatalf("expected '199.9', got %v", vs[0])
 	}