initial commit.

range.go

@@ -0,0 +1,97 @@
+package chart
+
+import (
+	"math"
+	"time"
+)
+
+// Range is a type that translates values from a range to a domain.
+type Range interface {
+	GetMin() interface{}
+	GetMax() interface{}
+	Translate(value interface{}) int
+}
+
+// NewRangeOfFloat64 returns a new Range
+func NewRangeOfFloat64(domain int, values ...float64) Range {
+	min, max := MinAndMax(values...)
+	return &RangeOfFloat64{
+		MinValue:    min,
+		MaxValue:    max,
+		MinMaxDelta: max - min,
+		Domain:      domain,
+	}
+}
+
+// RangeOfFloat64 represents a continuous range
+// of float64 values mapped to a [0...WindowMaxValue]
+// interval.
+type RangeOfFloat64 struct {
+	MinValue    float64
+	MaxValue    float64
+	MinMaxDelta float64
+	Domain      int
+}
+
+// GetMin implements the interface method.
+func (r RangeOfFloat64) GetMin() interface{} {
+	return r.MinValue
+}
+
+// GetMax implements the interface method.
+func (r RangeOfFloat64) GetMax() interface{} {
+	return r.MaxValue
+}
+
+// Translate maps a given value into the range space.
+// An example would be a 600 px image, with a min of 10 and a max of 100.
+// Translate(50) would yield (50.0/90.0)*600 ~= 333.33
+func (r RangeOfFloat64) Translate(value interface{}) int {
+	if typedValue, isTyped := value.(float64); isTyped {
+		finalValue := ((r.MaxValue - typedValue) / r.MinMaxDelta) * float64(r.Domain)
+		return int(math.Floor(finalValue))
+	}
+	return 0
+}
+
+// NewRangeOfTime makes a new range of time with the given time values.
+func NewRangeOfTime(domain int, values ...time.Time) Range {
+	min, max := MinAndMaxOfTime(values...)
+	r := &RangeOfTime{
+		MinValue:    min,
+		MaxValue:    max,
+		MinMaxDelta: max.Unix() - min.Unix(),
+		Domain:      domain,
+	}
+	return r
+}
+
+// RangeOfTime represents a timeseries.
+type RangeOfTime struct {
+	MinValue    time.Time
+	MaxValue    time.Time
+	MinMaxDelta int64 //unix time difference
+	Domain      int
+}
+
+// GetMin implements the interface method.
+func (r RangeOfTime) GetMin() interface{} {
+	return r.MinValue
+}
+
+// GetMax implements the interface method.
+func (r RangeOfTime) GetMax() interface{} {
+	return r.MaxValue
+}
+
+// Translate maps a given value into the range space (of time).
+// An example would be a 600 px image, with a min of jan-01-2016 and a max of jun-01-2016.
+// Translate(may-01-2016) would yield ... something.
+func (r RangeOfTime) Translate(value interface{}) int {
+	if typed, isTyped := value.(time.Time); isTyped {
+		valueDelta := r.MaxValue.Unix() - typed.Unix()
+		finalValue := (float64(valueDelta) / float64(r.MinMaxDelta)) * float64(r.Domain)
+		return int(math.Floor(finalValue))
+	}
+	return 0
+}