--- /dev/null
+package otsdb
+
+import (
+ "fmt"
+ "math"
+ "os"
+ "sort"
+)
+
+type OTS_DataPoint struct {
+ TimeStamp float64
+ Rate float64
+}
+
+type OTS_TimeSeries struct {
+ DataPoints []OTS_DataPoint
+}
+
+/* Functions for the sort interface. */
+func (obj *OTS_TimeSeries) Len () int {
+ return (len (obj.DataPoints))
+}
+
+func (obj *OTS_TimeSeries) Less (i, j int) bool {
+ if obj.DataPoints[i].TimeStamp < obj.DataPoints[j].TimeStamp {
+ return true
+ }
+ return false
+}
+
+func (obj *OTS_TimeSeries) Swap (i, j int) {
+ tmp := obj.DataPoints[i]
+ obj.DataPoints[i] = obj.DataPoints[j]
+ obj.DataPoints[j] = tmp
+}
+
+func Fmod64 (a float64, b float64) float64 {
+ tmp := int (a / b)
+ return b * float64 (tmp)
+}
+
+func (obj *OTS_TimeSeries) Write (name string) os.Error {
+ fd, err := os.OpenFile (name, os.O_WRONLY, 0666)
+ if err != nil {
+ return err
+ }
+
+ for i := 0; i < len (obj.DataPoints); i++ {
+ data_point := obj.DataPoints[i]
+ str := fmt.Sprintf ("%.3f,%g\n", data_point.TimeStamp, data_point.Rate)
+
+ fd.WriteString (str)
+ }
+
+ fd.Close ()
+ return nil
+}
+
+func ReadFile (name string) (obj *OTS_TimeSeries, err os.Error) {
+ fd, err := os.Open (name)
+ if err != nil {
+ return nil, err
+ }
+
+ /* dp_list := make ([]OTS_DataPoint, intervals_num */
+ obj = new (OTS_TimeSeries)
+
+ for ;; {
+ var timestamp float64
+ var rate float64
+
+ status, err := fmt.Fscanln (fd, "%f,%f", ×tamp, &rate)
+ if err != nil {
+ break
+ } else if status != 2 {
+ continue
+ }
+
+ fmt.Printf ("timestamp = %.3f; rate = %g;\n", timestamp, rate)
+
+ obj.DataPoints = append (obj.DataPoints, OTS_DataPoint{timestamp, rate})
+ }
+
+ fd.Close ()
+ return obj, nil
+}
+
+func (obj *OTS_TimeSeries) ConsolidatePointAverage (ts_start, ts_end float64) OTS_DataPoint {
+ var dp OTS_DataPoint
+
+ if ts_start > ts_end {
+ tmp := ts_end
+ ts_end = ts_start
+ ts_start = tmp
+ }
+
+ dp.TimeStamp = ts_end
+ dp.Rate = math.NaN ()
+
+ if len (obj.DataPoints) < 1 {
+ /* The object contains no data. */
+ return dp
+ } else if ts_start > obj.DataPoints[len (obj.DataPoints) - 1].TimeStamp {
+ /* The timespan is after all the data in the object. */
+ return dp
+ } else if ts_end < obj.DataPoints[0].TimeStamp {
+ /* The timespan is before all the data in the object. */
+ return dp
+ }
+
+ /* Find the first rate _after_ the start of the interval. */
+ idx_start := sort.Search (len (obj.DataPoints), func (i int) bool {
+ if obj.DataPoints[i].TimeStamp > ts_start {
+ return true
+ }
+ return false
+ })
+
+ /* The start is outside of the range of the timestamp. With the above checks
+ * this means that the start is _before_ the data in the object. We can thus
+ * use the first elements in the slice. */
+ if idx_start >= len (obj.DataPoints) {
+ idx_start = 0
+ }
+
+ /* There is no data points _between_ ts_start and ts_end. Return the first
+ * measured rate _after_ the desired timespan as the rate of the timespan. */
+ if obj.DataPoints[idx_start].TimeStamp >= ts_end {
+ dp.Rate = obj.DataPoints[idx_start].Rate
+ return dp
+ }
+
+ var timespan_len float64 = 0.0
+ var timespan_sum float64 = 0.0
+ for i := idx_start; i < len (obj.DataPoints); i++ {
+ dp_ts_start := ts_start
+ if (i > 0) && (dp_ts_start < obj.DataPoints[i - 1].TimeStamp) {
+ dp_ts_start = obj.DataPoints[i - 1].TimeStamp
+ }
+
+ dp_ts_end := obj.DataPoints[i].TimeStamp
+ if dp_ts_end > ts_end {
+ dp_ts_end = ts_end
+ }
+
+ dp_ts_diff := dp_ts_end - dp_ts_start
+ /* assert dp_ts_diff > 0.0 */
+ timespan_len += dp_ts_diff
+ timespan_sum += dp_ts_diff * obj.DataPoints[i].Rate
+
+ if obj.DataPoints[i].TimeStamp >= ts_end {
+ break;
+ }
+ } /* for i */
+
+ dp.Rate = timespan_sum / timespan_len
+ return dp
+} /* ConsolidatePointAverage */
+
+func (obj *OTS_TimeSeries) ConsolidateAverage (interval float64) *OTS_TimeSeries {
+ if interval <= 0.0 {
+ return nil
+ }
+
+ ts_raw_first := obj.DataPoints[0].TimeStamp
+ ts_raw_last := obj.DataPoints[len (obj.DataPoints) - 1].TimeStamp
+
+ fmt.Printf ("ts_raw_first = %g; ts_raw_last = %g;\n",
+ ts_raw_first, ts_raw_last)
+
+ /* Determine the timespan the consolidated data will span. */
+ ts_csl_first := Fmod64 (ts_raw_first, interval)
+ ts_csl_last := Fmod64 (ts_raw_last, interval)
+ if ts_csl_first < ts_raw_first {
+ ts_csl_first += interval
+ }
+
+ fmt.Printf ("ts_csl_first = %g; ts_csl_last = %g;\n",
+ ts_csl_first, ts_csl_last)
+
+ intervals_num := int ((ts_csl_last - ts_csl_first) / interval)
+ fmt.Printf ("Got a %gs timespan (%d intervals).\n",
+ ts_csl_last - ts_csl_first, intervals_num)
+
+ /* Allocate return structure */
+ ret_data := new (OTS_TimeSeries)
+ ret_data.DataPoints = make ([]OTS_DataPoint, intervals_num)
+
+ /* FIXME: This is currently a O(n log(n)) algorithm. It should instead be a O(n)
+ * algorithm. This is possible since obj is sorted. The problem is that
+ * ConsolidatePointAverage() does a binary search when we actually know where
+ * to go in the array. */
+ for i := 0; i < intervals_num; i++ {
+ ts := ts_csl_first + (float64 (i + 1) * interval)
+
+ fmt.Printf ("Building data for interval ]%g-%g].\n", ts - interval, ts)
+
+ ret_data.DataPoints[i] = obj.ConsolidatePointAverage (ts - interval, ts)
+ }
+
+ return ret_data
+} /* ConsolidateAverage */
+
+func (obj *OTS_TimeSeries) Print () {
+ for i := 0; i < len (obj.DataPoints); i++ {
+ data_point := obj.DataPoints[i]
+ fmt.Printf ("[%g] %g\n", data_point.TimeStamp, data_point.Rate)
+ }
+} /* Print () */
+
+/* vim: set syntax=go sw=2 sts=2 et : */
projects / otsdb-go.git / blobdiff