barometer 0.1.0

data/lib/barometer/data/pressure.rb

@@ -0,0 +1,133 @@
+module Barometer
+  #
+  # A simple Pressure class
+  # 
+  # Think of this like the Integer class. Enhancement
+  # is that you can create a number (in a certain unit), then
+  # get that number back already converted to another unit.
+  #
+  # All comparison operations will be done in metric
+  #
+  # NOTE: the metric units for pressure aren't commonly used, except
+  #       that this class was designed for storing weather data,
+  #       and it seems that it is more common in this case
+  #
+  class Pressure < Barometer::Units
+    
+    METRIC_UNITS = "mb"
+    IMPERIAL_UNITS = "in"
+    
+    attr_accessor :millibars, :inches
+    
+    def initialize(metric=true)
+      @millibars = nil
+      @inches = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.mb = value; end
+    def imperial_default=(value); self.in = value; end
+
+    #
+    # CONVERTERS
+    #
+    
+    def self.mb_to_in(mb)
+      return nil unless mb && (mb.is_a?(Integer) || mb.is_a?(Float))
+      mb.to_f * 0.02953
+    end
+    
+    def self.in_to_mb(inches)
+      return nil unless inches &&
+        (inches.is_a?(Integer) || inches.is_a?(Float))
+      inches.to_f * 33.8639
+    end
+    
+    #
+    # ACCESSORS
+    #
+    
+    # store millibars
+    def mb=(mb)
+      return if !mb || !(mb.is_a?(Integer) || mb.is_a?(Float))
+      @millibars = mb.to_f
+      self.update_inches(mb.to_f)
+    end
+    
+    # store inches
+    def in=(inches)
+      return if !inches || !(inches.is_a?(Integer) || inches.is_a?(Float))
+      @inches = inches.to_f
+      self.update_millibars(inches.to_f)
+    end
+    
+    # return the stored millibars or convert from inches
+    def mb(as_integer=true)
+      mb = (@millibars || Pressure.in_to_mb(@inches))
+      mb ? (as_integer ? mb.to_i : (100*mb).round/100.0) : nil
+    end
+    
+    # return the stored inches or convert from millibars
+    def in(as_integer=true)
+      inches = (@inches || Pressure.mb_to_in(@millibars))
+      inches ? (as_integer ? inches.to_i : (100*inches).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      self.mb <=> other.mb
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.mb : self.in
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.mb(false) : self.in(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.mb} #{METRIC_UNITS}" : "#{self.in} #{IMPERIAL_UNITS}"
+    end
+    
+    # will just return the units (no value)
+    def units(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? METRIC_UNITS : IMPERIAL_UNITS
+    end
+    
+    # when we set inches, it is possible the a non-equivalent value of
+    # millibars remains.  if so, clear it.
+    def update_millibars(inches)
+      return unless @millibars
+      difference = Pressure.in_to_mb(inches.to_f) - @millibars
+      # only clear millibars if the stored millibars is off be more then 1 unit
+      # then the conversion of inches
+      @millibars = nil unless difference.abs <= 1.0
+    end
+    
+    # when we set millibars, it is possible the a non-equivalent value of
+    # inches remains.  if so, clear it.
+    def update_inches(mb)
+      return unless @inches
+      difference = Pressure.mb_to_in(mb.to_f) - @inches
+      # only clear inches if the stored inches is off be more then 1 unit
+      # then the conversion of millibars
+      @inches = nil unless difference.abs <= 1.0
+    end
+    
+    def nil?
+      (@millibars || @inches) ? false : true
+    end
+    
+  end
+end

data/lib/barometer/data/speed.rb

@@ -0,0 +1,147 @@
+module Barometer
+  #
+  # A simple Speed class
+  # 
+  # Think of this like the Integer class. Enhancement
+  # is that you can create a number (in a certain unit), then
+  # get that number back already converted to another unit.
+  #
+  # Speed is a vector, thus it has a perticular direction, although
+  # the direction is independent of the units
+  #
+  # All comparison operations will be done in metric
+  # 
+  # NOTE: this currently only supports the scale of
+  #       kilometers (km) and miles (m) per hour.  There is currently
+  #       no way to scale to smaller units (eg km -> m -> mm)
+  class Speed < Barometer::Units
+    
+    METRIC_UNITS = "kph"
+    IMPERIAL_UNITS = "mph"
+    
+    attr_accessor :kilometers, :miles
+    attr_accessor :degrees, :direction
+    
+    def initialize(metric=true)
+      @kilometers = nil
+      @miles = nil
+      @degrees = nil
+      @direction = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.kph = value; end
+    def imperial_default=(value); self.mph = value; end
+    
+    #
+    # CONVERTERS
+    #
+    
+    def self.km_to_m(km)
+      return nil unless km && (km.is_a?(Integer) || km.is_a?(Float))
+      km.to_f * 0.622
+    end
+    
+    def self.m_to_km(m)
+      return nil unless m && (m.is_a?(Integer) || m.is_a?(Float))
+      m.to_f * 1.609
+    end
+    
+    #
+    # ACCESSORS
+    #
+    
+    # store kilometers per hour
+    def kph=(kph)
+      return if !kph || !(kph.is_a?(Integer) || kph.is_a?(Float))
+      @kilometers = kph.to_f
+      self.update_miles(kph.to_f)
+    end
+    
+    # store miles per hour
+    def mph=(mph)
+      return if !mph || !(mph.is_a?(Integer) || mph.is_a?(Float))
+      @miles = mph.to_f
+      self.update_kilometers(mph.to_f)
+    end
+    
+    def direction=(direction)
+      return if !direction || !direction.is_a?(String)
+      @direction = direction
+    end
+    
+    def degrees=(degrees)
+      return if !degrees || !(degrees.is_a?(Integer) || degrees.is_a?(Float))
+      @degrees = degrees
+    end
+    
+    # return the stored kilometers or convert from miles
+    def kph(as_integer=true)
+      km = (@kilometers || Speed.m_to_km(@miles))
+      km ? (as_integer ? km.to_i : (100*km).round/100.0) : nil
+    end
+    
+    # return the stored miles or convert from kilometers
+    def mph(as_integer=true)
+      m = (@miles || Speed.km_to_m(@kilometers))
+      m ? (as_integer ? m.to_i : (100*m).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      self.kph <=> other.kph
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.kph : self.mph
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.kph(false) : self.mph(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.kph} #{METRIC_UNITS}" : "#{self.mph} #{IMPERIAL_UNITS}"
+    end
+    
+    # will just return the units (no value)
+    def units(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? METRIC_UNITS : IMPERIAL_UNITS
+    end
+    
+    # when we set miles, it is possible the a non-equivalent value of
+    # kilometers remains.  if so, clear it.
+    def update_kilometers(m)
+      return unless @kilometers
+      difference = Speed.m_to_km(m.to_f) - @kilometers
+      # only clear kilometers if the stored kilometers is off be more then 1 unit
+      # then the conversion of miles
+      @kilometers = nil unless difference.abs <= 1.0
+    end
+    
+    # when we set kilometers, it is possible the a non-equivalent value of
+    # miles remains.  if so, clear it.
+    def update_miles(km)
+      return unless @miles
+      difference = Speed.km_to_m(km.to_f) - @miles
+      # only clear miles if the stored miles is off be more then 1 unit
+      # then the conversion of kilometers
+      @miles = nil unless difference.abs <= 1.0
+    end
+    
+    def nil?
+      (@kilometers || @miles) ? false : true
+    end
+    
+  end
+end

data/lib/barometer/data/sun.rb

@@ -0,0 +1,35 @@
+module Barometer
+  #
+  # A simple Sun class
+  # 
+  # Used to store sunrise and sunset information
+  #
+  class Sun
+    
+    def initialize(rise=nil, set=nil)
+      raise ArgumentError unless (rise.is_a?(Time) || rise.nil?)
+      raise ArgumentError unless (set.is_a?(Time) || set.nil?)
+      @rise_utc = rise
+      @set_utc = set
+    end
+
+    def rise; @rise_utc; end
+    def set; @set_utc; end
+    
+    # useful for incrementing the sunrise and sunset times by exactly
+    # N days ... used when using the same sun data for other days
+    def self.add_days!(sun, n=1)
+      raise ArgumentError unless sun.is_a?(Barometer::Sun)
+      raise ArgumentError unless n.is_a?(Fixnum)
+      seconds_to_add = 60*60*24*n
+      rise_utc = sun.rise + seconds_to_add
+      set_utc = sun.set + seconds_to_add
+      self.new(rise_utc, set_utc)
+    end
+    
+    def nil?
+      (@rise_utc || @set_utc) ? false : true
+    end
+    
+  end
+end

data/lib/barometer/data/temperature.rb

@@ -0,0 +1,164 @@
+module Barometer
+  #
+  # A simple Temperature class
+  # 
+  # Think of this like the Integer class. Enhancement
+  # is that you can create a number (in a certain unit), then
+  # get that number back already converted to another unit.
+  #
+  # All comparison operations will be done in the absolute
+  # scale of Kelvin (K)
+  #
+  class Temperature < Barometer::Units
+    
+    METRIC_UNITS = "C"
+    IMPERIAL_UNITS = "F"
+    
+    attr_accessor :celsius, :fahrenheit, :kelvin
+    
+    def initialize(metric=true)
+      @celsius = nil
+      @fahrenheit = nil
+      @kelvin = nil
+      super(metric)
+    end
+    
+    def metric_default=(value); self.c = value; end
+    def imperial_default=(value); self.f = value; end
+
+    #
+    # CONVERTERS
+    #
+    
+    def self.c_to_k(c)
+      return nil unless c && (c.is_a?(Integer) || c.is_a?(Float))
+      273.15 + c.to_f
+    end
+    
+    # Tf = (9/5)*Tc+32
+    def self.c_to_f(c)
+      return nil unless c && (c.is_a?(Integer) || c.is_a?(Float))
+       ((9.0/5.0)*c.to_f)+32.0
+    end
+    
+    # Tc = (5/9)*(Tf-32)
+    def self.f_to_c(f)
+      return nil unless f && (f.is_a?(Integer) || f.is_a?(Float))
+      (5.0/9.0)*(f.to_f-32.0)
+    end
+    
+    def self.f_to_k(f)
+      return nil unless f && (f.is_a?(Integer) || f.is_a?(Float))
+      c = self.f_to_c(f.to_f)
+      self.c_to_k(c)
+    end
+    
+    def self.k_to_c(k)
+      return nil unless k && (k.is_a?(Integer) || k.is_a?(Float))
+      k.to_f - 273.15
+    end
+    
+    def self.k_to_f(k)
+      return nil unless k && (k.is_a?(Integer) || k.is_a?(Float))
+      c = self.k_to_c(k.to_f)
+      self.c_to_f(c)
+    end
+    
+    #
+    # ACCESSORS
+    #
+    
+    # store celsius and kelvin
+    def c=(c)
+      return if !c || !(c.is_a?(Integer) || c.is_a?(Float))
+      @celsius = c.to_f
+      @kelvin = Temperature.c_to_k(c.to_f)
+      self.update_fahrenheit(c.to_f)
+    end
+    
+    # store fahrenheit and kelvin
+    def f=(f)
+      return if !f || !(f.is_a?(Integer) || f.is_a?(Float))
+      @fahrenheit = f.to_f
+      @kelvin = Temperature.f_to_k(f.to_f)
+      self.update_celsius(f.to_f)
+    end
+    
+    # store kelvin, convert to all
+    def k=(k)
+      return if !k || !(k.is_a?(Integer) || k.is_a?(Float))
+      @kelvin = k.to_f
+      @celsius = Temperature.k_to_c(k.to_f)
+      @fahrenheit = Temperature.k_to_f(k.to_f)
+    end
+    
+    # return the stored celsius or convert from Kelvin
+    def c(as_integer=true)
+      c = (@celsius || Temperature.k_to_c(@kelvin))
+      c ? (as_integer ? c.to_i : (100*c).round/100.0) : nil
+    end
+    
+    # return the stored fahrenheit or convert from Kelvin
+    def f(as_integer=true)
+      f = (@fahrenheit || Temperature.k_to_f(@kelvin))
+      f ? (as_integer ? f.to_i : (100*f).round/100.0) : nil
+    end
+    
+    #
+    # OPERATORS
+    #
+    
+    def <=>(other)
+      @kelvin <=> other.kelvin
+    end
+    
+    #
+    # HELPERS
+    #
+    
+    # will just return the value (no units)
+    def to_i(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.c : self.f
+    end
+    
+    # will just return the value (no units) with more precision
+    def to_f(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? self.c(false) : self.f(false)
+    end
+    
+    # will return the value with units
+    def to_s(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? "#{self.c} #{METRIC_UNITS}" : "#{self.f} #{IMPERIAL_UNITS}"
+    end
+    
+    # will just return the units (no value)
+    def units(metric=nil)
+      (metric || (metric.nil? && self.metric?)) ? METRIC_UNITS : IMPERIAL_UNITS
+    end
+    
+    # when we set fahrenheit, it is possible the a non-equivalent value of
+    # celsius remains.  if so, clear it.
+    def update_celsius(f)
+      return unless @celsius
+      difference = Temperature.f_to_c(f.to_f) - @celsius
+      # only clear celsius if the stored celsius is off be more then 1 degree
+      # then the conversion of fahrenheit
+      @celsius = nil unless difference.abs <= 1.0
+    end
+    
+    # when we set celsius, it is possible the a non-equivalent value of
+    # fahrenheit remains.  if so, clear it.
+    def update_fahrenheit(c)
+      return unless @fahrenheit
+      difference = Temperature.c_to_f(c.to_f) - @fahrenheit
+      # only clear fahrenheit if the stored fahrenheit is off be more then 1 degree
+      # then the conversion of celsius
+      @fahrenheit = nil unless difference.abs <= 1.0
+    end
+    
+    def nil?
+      (@celsius || @fahrenheit || @kelvin) ? false : true
+    end
+    
+  end
+end