gerbilcharts 0.0.3

data/lib/gerbilcharts/models/monotonous_graph_model.rb

@@ -0,0 +1,192 @@
+module GerbilCharts::Models
+
+# = MonotonousGraphModel
+# simple graph model (x increases monotonously)
+# All timeseries models are derived from this class
+#
+class MonotonousGraphModel < GraphModel
+  
+  attr_reader :xarr							# the x values 
+  attr_reader :yarr						    # the y values 
+  attr_reader :xrange,:yrange				# raw ranges
+  attr_reader :rounderx, :roundery			# rounded ranges according to presets
+  
+  def initialize(name,opt={})
+    super(name)
+    @xrange = RawRange.new
+    @yrange = RawRange.new
+    @rounderx = RoundRange
+    @roundery = RoundRange
+    @xarr=[]
+    @yarr=[]
+  end
+ 
+  # add a tuple, apply a transformer lambda is supplied by the user
+  #
+  # A new datapoint must have a x_val greater than the previous one
+  def add(x_val,y_val)
+
+    
+    if @xarr.length > 0 and @xarr.last > x_val
+      raise "Expecting monotonous series data"  
+    end
+  
+    @xrange.update x_val
+
+    @xarr<<x_val 
+    
+    if @transformer
+        trval = @transformer.xform(y_val)
+        @yarr << trval
+        @yrange.update trval
+    else
+        @yarr << y_val
+        @yrange.update y_val
+    end
+     
+  end
+  
+  # add an array of values at once (just a convenience method)
+  def add_tuples tarr
+    tarr.each do |t|
+      add t[0],t[1]
+    end
+  end
+  
+  def clear
+    @xrange.reset
+    @yrange.reset
+    @xarr=[]
+    @yarr=[]
+  end
+  
+  def count
+    @xarr.size
+  end
+  
+      
+  def latest
+    yield @xarr.last, @yarr.last
+  end
+  
+  def latest_x
+    return @xarr.last
+  end
+  
+  def latest_val
+    return @yarr.last
+  end
+  
+  def latest_x_dbtime
+    return @xarr.last<<32
+  end
+  
+  def first
+    yield @xarr[0],@yarr[0]
+  end
+  
+  def latest_formatted_val
+    return @yrange.format_value(@yarr.last)
+  end
+    
+  def ranges
+    yield @xrange, @yrange if block_given?
+	return @xrange,@yrange
+  end
+  
+  def round_ranges
+    if block_given?
+     yield @rounderx.new(@xrange), @roundery.new(@yrange) 
+	else
+     return @rounderx.new(@xrange), @roundery.new(@yrange)
+	end
+  end
+  
+  def round_given_x(rx)
+    return @rounderx.new(rx)
+  end
+  
+  def round_given_y(ry)
+    return @roundery.new(ry)
+  end
+    
+  def each_tuple
+    for i in (0 .. @xarr.length-1)
+      yield @xarr[i],@yarr[i]
+    end
+  end
+  
+  # crop all tuples older than a cutoff window
+  #
+  # [+cutoffwindow+] 	older than a number of seconds
+  #
+  def crop_window(cutoffwindow)
+    xcutoff = latest_x - cutoffwindow
+	crop_at(xcutoff)
+  end
+  
+  # crop all tuples less than an absolute cutoff
+  # [+cutoff+]	Cutoff value
+  #
+  def crop_at(cutoff)
+    until @xarr.empty? or @xarr.first >= cutoff
+      @xarr.shift
+      @yarr.shift
+    end
+	recompute_ranges
+  end
+
+  # all data points newer than a cut off
+  def tuples_since(x_last)
+      istart = binarySearch(@xarr,x_last,0,@xarr.length)
+      for i in istart..@xarr.length-1
+        yield @xarr[i],@yarr[i]
+      end
+  end
+
+  # for test purposes
+  def randomizeLastValue
+    v=@yarr.last
+    @yarr[@yarr.size-1]=v * ( 0.5 + rand())
+  end
+  
+
+private
+  # recompute ranges
+  def recompute_ranges
+  	@xrange.reset
+	@yrange.reset
+
+	each_tuple do |x,y|
+		@xrange.update x
+		@yrange.update y
+	end
+
+  end
+
+
+  # rudimentary binary search
+  def binarySearch(array, target, i, n)
+    case n
+    when 0
+        raise ArgumentError
+    when 1
+        if array[i] == target
+            return i
+        elsif i+1 < array.length and array[i] < target && array[i+1]>target
+            return i
+        else
+            raise ArgumentError
+        end
+    else
+        j = i + n / 2
+        if array[j] <= target
+            return binarySearch(array, target, j, n - n/2)
+        else
+            return binarySearch(array, target, i, n/2)
+        end
+    end
+  end
+end
+
+end

data/lib/gerbilcharts/models/presets.rb

@@ -0,0 +1,94 @@
+module GerbilCharts::Models
+
+# Presets base class for all ranges
+#
+# Preset values for ranges. So we do not scale charts arbitrarily
+# and the label values are neat and clean
+#
+class Presets
+  
+protected
+    PRESETS = [ 
+              [0,0],  [1,0.2], [5,1],  [10,1],[20,5],
+              [50,10],[100,25],[200,50], [500,100], [1000,200], 
+              [2000,500],   [5000,1000], [8000,2000], [10000,2000],
+              [20000,5000],  [50000,10000], [100000,25000], [200000,50000],
+              [500000,100000],[800000,200000],
+              [1000000,200000],[2000000,500000], [3000000,500000], [4000000,1000000],
+              [5000000,1000000],[6000000, 1500000],
+              [10000000,2500000], [20000000,4000000], [50000000, 10000000],
+              [100000000,25000000], [500000000,100000000], 
+              [1000000000,250000000] 
+            ]
+            
+    TIMEPRESETS = [ 
+              [0,0],  [1,0.2], [5,1],  [10,1],[20,5],
+              [30,10],[60,10],[120,15], [300,60], [600,120], 
+              [900,300], [1800,300], 
+              [3600,900], [7200,1800],[10800,3600], [14400,3600], [21600,7200],
+              [43200, 10800], [86400,21600],
+              [172800, 43200], [259200,86400],
+              [604800,  86400], [1209600,172800], 
+              [2419200, 604800],
+              [7257600, 2419200],
+              [14515200,7257600],
+              [29030400,7257600],
+            ]  
+            
+    UNITPRESETS = [
+              [1e+12, "T"],
+              [1e+09, "G"],
+              [1e+06, "M"],
+              [1e+03, "K"],
+              [1,     ""],
+              [1e-03, "m"],
+              [1e-06, "u"],
+              [1e-09, "n"],
+              [1e-12, "p"],
+            ]
+            
+   PRESET_VAL_POS=0
+   PRESET_LABEL_POS=1
+             
+             
+  # Formats a number with a units suffix
+  #    So a number like 11899833 = 11.90 M 
+  def format_suffix raw_value
+    return "0" if raw_value == 0
+    UNITPRESETS.each do |unit|
+          if raw_value >= unit[0]
+            retval = raw_value  / unit[0]
+            sout=format("%.2f %s", retval, unit[1])
+            sout.gsub! ".00",""
+            return sout
+          end
+    end
+    return raw_value.to_s
+  end
+     
+  # Formats a time value : based on available interval
+  #    tvsec = seconds since Jan 1 1970
+  #    interval = desired window in seconds
+  def format_timeval ( tvsec, interval)   
+    t = Time.at(tvsec).getlocal
+    if interval < 60 
+      return t.strftime("%M:%S")
+    elsif interval < 300
+      return t.strftime("%M:%S")
+    elsif interval < 3600
+      return t.strftime("%H:%M")
+    elsif interval < 86400
+      return t.strftime("%H:%M")
+    elsif interval < 259200
+      return t.strftime("%a-%H:%M")
+    elsif interval < 604800
+      return t.strtime("%b-%d")
+    elsif interval < 2419200
+      return t.strftime("%b-%d")
+    else
+      return t.strftime("%b")
+    end
+  end
+end
+
+end

data/lib/gerbilcharts/models/raw_range.rb

@@ -0,0 +1,68 @@
+module GerbilCharts::Models
+
+# RawRange 
+# 	Maintains a range when values are added to a model
+# 	This tracks the raw min/max values 
+class RawRange  < Presets
+  
+  attr_reader :rmax,:rmin
+  
+  def  initialize
+    @rmax,@rmin=nil,nil
+  end
+  
+  # update - updates the range
+  # 	newval - new incoming value
+  #
+  def update(newval)
+    @rmax=newval if @rmax.nil? or newval > @rmax 
+    @rmin=newval if @rmin.nil? or newval < @rmin 
+  end
+  
+  # update - updates the range (using another range)
+  # 	newval - new range
+  #
+  def update_r(range)
+    update(range.rmax)
+    update(range.rmin)
+  end
+  
+  
+  # returns the min/max 
+  #
+  def min_max
+    yield @rmin,@rmax if block_given?
+    return @rmin,@rmax
+  end
+  
+  def reset
+    @rmin,@rmax=nil,nil
+  end
+  
+  def to_s
+    "Min = #{@rmin} Max=#{@rmax}"
+  end
+  
+  def delta
+    return @rmax-@rmin
+  end
+  
+  # scales a value with respect to the range
+  # 	val = scale this value
+  def scale_factor(val)
+    f = (val-@rmin).to_f/(@rmax-@rmin).to_f
+    return f
+  end
+
+  def zeromin
+    @rmin=0
+  end
+
+  def format_value(val)
+    return format_suffix(val)
+  end
+  
+  
+end
+
+end

data/lib/gerbilcharts/models/round_range.rb

@@ -0,0 +1,104 @@
+module GerbilCharts::Models
+
+# A rounded range from a raw range 
+# Example : RawRange (102,8991) = RoundRange (100,10K)
+#
+class RoundRange < RawRange
+ 
+  attr_reader  :lmax
+  
+  # given a raw range, we calculate a round range
+  def initialize(raw_range)
+    super()
+    @rmin=round_min(raw_range.rmin)
+    @rmax=round_max(raw_range.rmax)
+    @lmax=label_step
+  end
+ 
+   # provide labels
+   # 	yields two items (value,string label)
+   #
+   # 	Usage example:
+   # 	r.each_label do |v,s|
+   # 	  p "Value = #{v} Label String = #{s}"
+   # 	end
+   #
+   def each_label
+     
+    raise "Range not aligned with presets (call round range first)" if not @lmax
+    raise "No data points in model" if @rmax == -1  
+    return  if @lmax == 0
+    
+    if @rmin % @lmax != 0
+      v = (@rmin+@lmax) - (@rmin%@lmax)
+    else
+      v = @rmin
+    end
+    while (v<=@rmax) do
+      yield v, format_suffix(v)    
+      v = v+@lmax
+    end
+   end
+
+  # provide ticks (per label interval)
+  def each_tick(tpl)
+    
+      raise "Range not aligned with presets (call round range first)" if not @lmax  
+      
+      lint = @lmax/tpl
+      if @rmin % lint != 0
+        v = (@rmin+lint) - (@rmin%lint)
+      else
+        v = @rmin
+      end
+      while (v<@rmax) do
+        yield v
+        v = v+lint
+      end
+  end
+  
+private
+  # round_max (ceiling)
+  def round_max(raw)
+       last_pre=1
+       if raw > PRESETS.last[0]
+          return raw
+       else
+         PRESETS.reverse_each do |pre|
+            break if pre[0] < raw
+            last_pre=pre[0]
+         end
+       end
+       return last_pre
+  end
+  
+  # round_min (floor)
+  def round_min(raw)
+     last_pre=0
+     PRESETS.each do |pre|
+        break if pre[0] > raw
+        last_pre=pre[0]
+     end
+     return last_pre
+   end
+
+  # labels
+  def label_step
+    del = @rmax-@rmin
+    
+    last_pre=0.2
+    if del > PRESETS.last[0]
+          return del/10
+    else
+         PRESETS.reverse_each do |pre|
+            break if pre[0] < del
+            last_pre=pre[1]
+         end
+    end
+   return last_pre
+  end
+
+end
+
+end
+