ruby-units 1.0.1 → 1.0.2

data/lib/ruby_units/array.rb

@@ -0,0 +1,9 @@
+# make a unit from an array
+# [1, 'mm'].unit => 1 mm
+class Array
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+end

data/lib/ruby_units/complex.rb

@@ -0,0 +1,10 @@
+class Complex < Numeric
+  def to_unit(other = nil)
+    real_unit = self.real.to_unit
+    image_unit = self.image.to_unit
+    raise ArgumentError, 'Units on real and imaginary parts are incompatible' unless real_unit =~ image_unit 
+    final_unit = (real_unit.units.empty? ? image_unit.units : real_unit.units).to_unit
+    final_unit * Complex(real_unit.to(final_unit).scalar, image_unit.to(final_unit).scalar)
+  end
+  alias :unit :to_unit
+end

data/lib/ruby_units/date.rb

@@ -0,0 +1,51 @@
+# Allow date objects to do offsets by a time unit
+# Date.today + U"1 week" => gives today+1 week
+
+require 'date'
+
+class Date
+  alias :unit_date_add :+
+  def +(unit)
+    case unit
+    when Unit:
+      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_add(unit.to('day').scalar)
+    when Time: unit_date_add(unit.to_datetime)
+    else
+      unit_date_add(unit)
+    end
+  end
+
+ 
+  alias :unit_date_sub :-    
+  def -(unit)
+    case unit
+    when Unit: 
+      unit = unit.to('d').round if ['y', 'decade', 'century'].include? unit.units 
+      unit_date_sub(unit.to('day').scalar)
+    when Time: unit_date_sub(unit.to_datetime)
+    else
+      unit_date_sub(unit)
+    end
+  end
+  
+  def to_unit(other = nil)
+    other ? Unit.new(self).to(other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  
+  def to_time
+    Time.local(*ParseDate.parsedate(self.to_s))
+  end
+  
+  alias :units_datetime_inspect :inspect
+  def inspect(raw = false)
+    return self.units_datetime_inspect if raw
+    self.to_s
+  end
+  
+  def to_date
+    Date.civil(self.year, self.month, self.day)
+  end
+  
+end

data/lib/ruby_units/math.rb

@@ -0,0 +1,87 @@
+# Math will convert unit objects to radians and then attempt to use the value for 
+# trigonometric functions.  
+
+module Math
+  alias unit_sqrt sqrt
+  def sqrt(n)
+    if Unit === n
+      (n**(1/2)).to_unit 
+    else
+      unit_sqrt(n)
+    end
+  end
+  
+  alias unit_sin sin
+  def sin(n)
+   Unit === n ? unit_sin(n.to('radian').scalar) : unit_sin(n)
+  end
+
+  alias unit_cos cos
+  def cos(n)
+    Unit === n ? unit_cos(n.to('radian').scalar) : unit_cos(n)
+  end
+    
+  alias unit_sinh sinh
+  def sinh(n)
+    Unit === n ? unit_sinh(n.to('radian').scalar) : unit_sinh(n)
+  end
+
+  alias unit_cosh cosh
+  def cosh(n)
+    Unit === n ? unit_cosh(n.to('radian').scalar) : unit_cosh(n)
+  end
+
+  alias unit_tan tan
+  def tan(n)
+   Unit === n ? unit_tan(n.to('radian').scalar) : unit_tan(n)
+  end
+
+  alias unit_tanh tanh
+  def tanh(n)
+    Unit === n ? unit_tanh(n.to('radian').scalar) : unit_tanh(n)
+  end
+
+  alias unit_hypot hypot
+  # Convert parameters to consistent units and perform the function
+  def hypot(x,y)
+    if Unit === x && Unit === y
+      (x**2 + y**2)**(1/2)
+    else
+      unit_hypot(x,y)
+    end
+  end
+  
+  alias unit_atan2 atan2
+  def atan2(x,y)
+    case
+    when (Unit === x && Unit === y) && (x !~ y)
+      raise ArgumentError, "Incompatible Units"
+    when (Unit === x && Unit === y) && (x =~ y)
+      unit_atan2(x.base_scalar, y.base_scalar)
+    when (Unit === x || Unit === y)
+      raise ArgumentError, "Incompatible Units"
+    else
+      unit_atan2(x,y)
+    end
+  end
+
+   module_function :unit_hypot
+   module_function :hypot
+   module_function :unit_sqrt
+   module_function :sqrt
+   module_function :unit_sin
+   module_function :sin
+   module_function :unit_cos
+   module_function :cos
+   module_function :unit_sinh
+   module_function :sinh
+   module_function :unit_cosh
+   module_function :cosh
+   module_function :unit_tan
+   module_function :tan
+   module_function :unit_tanh
+   module_function :tanh
+   module_function :unit_atan2
+   module_function :atan2
+   
+end

data/lib/ruby_units/numeric.rb

@@ -0,0 +1,8 @@
+# make a unitless unit with a given scalar
+class Numeric
+  def to_unit(other = nil)
+    other ? Unit.new(self, other) : Unit.new(self)
+  end
+  alias :unit :to_unit
+  alias :u :to_unit
+end

data/lib/ruby_units/object.rb

@@ -0,0 +1,8 @@
+class Object
+  def Unit(*other)
+    other.to_unit
+  end
+  
+  alias :U :Unit
+  alias :u :Unit
+end