stick 1.2.0 → 1.3.0

data/README

@@ -1,22 +1,26 @@
 = STICK
 
+  http://rubyforge.org/projects/stick
+
 STICK stands for Scientific Code Kit. It's main feature is the
-a sophisticated SI units system.
+a sophisticated SI units system. It also includes a large
+set of natural constants and some extensions for the Matrix
+class.
 
 
 == Installation
 
 You can install via Rubygems
 
-    gems install stick
+    gem install stick
 
 or via tarball
 
     tar -xzf stick-x.y.z.tar.gz
     cd stick
-    sudo util/setup
+    sudo task/setup
 
-(on Windows 'ruby util/setup')
+(on Windows 'ruby task/setup')
 
 
 == Usage
@@ -44,67 +48,52 @@ the additional effect of making Units.with_unit_converter available
 without the <code>Units.</code> prefix, as well as the shortcuts for
 creating Units (see Units#method_missing).
 
-=== Constants
 
-Also included are a large assortment of real world contants.
-The constants are stored in the Math::Constants module, but this
-is included in Math for direct use by other Math libraries.
-Math::Constants::CGS provides the constants in cm kg s format,
-instead of the standard m kg s. Some examples...
+=== Constants
 
-    require 'stick/constants'
+Also included are a large assortment of real world contants. These come in two
+varieties, typeless and typed via units.rb. (PLEASE NOTE: The typed variety is not
+yet complete).
 
-    Math::SPEED_OF_LIGHT                   #=> 2.99792458e8
-    Math::CGS::SPEED_OF_LIGHT              #=> 2.99792458e10
-    Math::Constants::SPEED_OF_LIGHT        #=> 2.99792458e8
-    Math::Constants::CGS::SPEED_OF_LIGHT   #=> 2.99792458e10
+Constants are also provided in both mks (m kg s) and in cgs (cm g s) format.
 
-=== Date/Time convenience methods
+    require 'stick/constants/typeless_mks'
+    require 'stick/constants/typeless_cgs'
 
-There are also some convenience libraries for working with dates and times.
+    include Stick::Constants::Typeless
 
-    require 'stick/time'
+    MKS::SPEED_OF_LIGHT              #=> 2.99792458e8
+    CGS::SPEED_OF_LIGHT              #=> 2.99792458e10
 
-    10.minutes.since(Time.now)
-    2.years.from_now
-    7.weekdays.ago
-    Time.now.next_year
+Big thanks to Daniel Carrera and Brian Gough for their original work on Math::Constants
+from which the typeless numbers derive.
 
 
 === Extensions to the Ruby's Matrix
 
-This is work done by Cosmin Bonchis as a Google Summer of Code 2007 project for Ruby Central Inc.
-
-The project consists of some enhancements to the Ruby "Matrix" module and includes: LU and QR (Householder, Givens, Gram Schmidt, Hessenberg) decompositions, bidiagonalization, eigenvalue and eigenvector calculations.
+Also included are Matrix extensions by Cosmin Bonchis, which was done as a Google Summer of
+Code 2007 project for Ruby Central Inc.
 
-This archive contains in extendmatrix.rb file the source code of the project, an implementation of mapcar used in extending matrix, and all the tests files in the "tests" directory.
+The library consists of some enhancements to the Ruby "Matrix" module and includes:
+LU and QR (Householder, Givens, Gram Schmidt, Hessenberg) decompositions, bidiagonalization,
+eigenvalue and eigenvector calculations.
 
-The code can also be found on the RubyForge repository at http://matrix.rubyforge.org/svn/trunk/ or the project's SVN repository can be checked out through anonymous access with the following command(s).
+This library is contatined in stick/matrix.rb, which also draws upon stick/mapcar.rb.
 
-svn checkout svn://rubyforge.org/var/svn/matrix
-svn checkout http://matrix.rubyforge.org/svn/trunk/
+This code can also be found on RubyForge at http://rubyforge.org/project/matrix.
 
 
 == Authors/Contributors
 
-* Peter Vanbroekhoven (primary author)
+* Peter Vanbroekhoven
 * Thomas Sawyer
 * Cosmin Bonchis
-
-
-== Relevant URLs
-
-Rubyforge project site:
-
-  http://rubyforge.org/projects/stick
-
-Orginal Matrix extensions:
-
-  http://matrix.rubyforge.org/svn/trunk/
+* Daniel Carrera
+* Brian Gough
 
 
 == License
 
-Copyright 2006-2007 Peter Vanbroekhoven
+Copyright 2006-2007 Peter Vanbroekhoven, Thomas Sawyer and Contributors
 
 Ruby/GPL Licensed

data/RELEASE

@@ -0,0 +1,29 @@
+I am happy to finally announce the initial public release of Stick,
+the Scientific Code Kit for Ruby.
+
+  http://stick.rubyforge.org
+
+Stick is a spin-off of Facets, based on the most excellent units.rb
+library by Peter Vanbroekhoven. Units.rb, and its cousin currency.rb,
+provide a very poweful system for working with typed values in a very
+Ruby-esque way. For example:
+
+  10.m / 10.s             #=> 1 m/s
+  1.bit/s + 8.bytes/s     #=> 65.0 bit/s
+  1.mile.to(feet)         #=> 5280.0 feet
+  1.acre.to(yd**2)        #=> 4840.0 yd**2
+
+In addition, the library contains a large collection of natural constants,
+based on the original work of Daniel Carrera and Brian Gough; plus
+Cosmin Bonchis' extensions to the Matrix class. In the future, we
+expect to add a few more useful science and math oriented libraries.
+
+Please note, despite the 1.x version number, this is still a bit of a nascent
+release, as some functionality still needs address. In particular the
+*typed* constants and currency conversions are not yet fully functional.
+But the rest of the library works well. With any luck some of you will find
+the project useful enough to offer a little time to help us polisih it up.
+
+Thanks and enjoy,
+
+Trans and Peter

data/lib/stick/constants/cgs.rb

@@ -35,11 +35,11 @@ require 'stick/units'
 module Stick
   module Constants
 
-    # = Constants in the CGS system (cm, kg, s)
+    # = Constants in the CGS system (cm, g, s)
     #
     # Large assortment of real world contants. The constants are stored in
     # the Math::Constants:CGS module. Math::Constants::CGS provides the
-    # constants in cm kg s format, opposed to the standard m kg s.
+    # constants in cm g s format, opposed to the standard m kg s.
     #
     # == Synopsis
     #

data/lib/stick/constants/typeless.rb

@@ -0,0 +1,3 @@
+require 'stick/constants/typeless_mkg'
+require 'stick/constants/typeless_cgs'
+

data/lib/stick/currency.rb

@@ -1,8 +1,10 @@
 require 'stick/units/currency'
 
 module Stick
+module Units
   # Load conversion units.
   class Converter
     require("currency-standard")
   end
 end
+end

data/lib/stick/units.rb

@@ -1,10 +1,14 @@
 require 'stick/units/units'
 
 module Stick
+module Units
+
   # Load conversion units.
   class Converter
     require("units-standard")
   end
+
+end
 end
 
 
@@ -14,7 +18,7 @@ end
 
   class A
 
-    include ::Units
+    include Stick::Units
 
     def test
       puts 1.bit/s + 8.bytes/s

data/lib/stick/units/base.rb

@@ -70,14 +70,15 @@ end
 #++
 
 module Stick
+module Units
 
   def method_missing(m, *args, &blk)
     if args.length == 1
-      args[0] = (::Stick::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Converter
-      return ::Stick::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
-    elsif (::Stick::Converter.current.registered?(m) rescue false)
+      args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
+      return ::Stick::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
+    elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
       raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-      return ::Stick::Unit.new({m => 1}, ::Stick::Converter.current)
+      return ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current)
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -85,8 +86,8 @@ module Stick
   end
 
   def const_missing(c)
-    if (::Stick::Converter.current.registered?(c) rescue false)
-      return ::Stick::Unit.new({c => 1}, ::Stick::Converter.current)
+    if (::Stick::Units::Converter.current.registered?(c) rescue false)
+      return ::Stick::Units::Unit.new({c => 1}, ::Stick::Units::Converter.current)
     else
       ::Exception.with_clean_backtrace("const_missing") {
         super
@@ -95,7 +96,7 @@ module Stick
   end
 
   def self.append_features(m)
-    m.send(:extend, ::Stick)
+    m.send(:extend, ::Stick::Units)
     super
   end
 
@@ -116,7 +117,7 @@ module Stick
   #
   # See also Converter.current.
   def with_unit_converter(name, &blk) # :yields:
-    ::Stick::Converter.with_converter(name, &blk)
+    ::Stick::Units::Converter.with_converter(name, &blk)
   end
 
   module_function :with_unit_converter
@@ -137,7 +138,7 @@ module Stick
 
     attr_reader :name, :converter
 
-    def initialize(name, converter = ::Stick::Converter.current)
+    def initialize(name, converter = ::Stick::Units::Converter.current)
       name = name.to_sym
       raise ::ArgumentError, "unit #{name.to_s.dump} not registered with #{converter}" if not converter.registered? name
       @name = name
@@ -149,7 +150,7 @@ module Stick
     end
 
     def ==(other)
-      other.is_a?(::Stick::BaseUnit) && other.name == @name && other.converter == @converter
+      other.is_a?(::Stick::Units::BaseUnit) && other.name == @name && other.converter == @converter
     end
 
     alias eql? ==
@@ -159,7 +160,7 @@ module Stick
     end
 
     def to_s
-      if ::Stick::Converter.current.includes?(converter)
+      if ::Stick::Units::Converter.current.includes?(converter)
         @name.to_s
       else
         "#{@converter}:#{@name}"
@@ -202,13 +203,13 @@ module Stick
     #
     # See also Converter, Converter.converter
     def initialize(units = {}, converter = nil)
-      conv = proc { converter ||= ::Stick::Converter.current }
+      conv = proc { converter ||= ::Stick::Units::Converter.current }
       if units.is_a? ::String
         @units = decode_string(units, conv)
       else
         @units = {}
         units.each_pair do |k, v|
-          k = conv[].base_unit(k.to_sym) if not k.is_a? ::Stick::BaseUnit
+          k = conv[].base_unit(k.to_sym) if not k.is_a? ::Stick::Units::BaseUnit
           @units[k] = v
         end
       end
@@ -221,7 +222,7 @@ module Stick
       @units.each_pair do |u, e|
         result[u] = e * p
       end
-      ::Stick::Unit.new(result)
+      ::Stick::Units::Unit.new(result)
     end
 
     # Multiplies with the given Unit.
@@ -240,18 +241,18 @@ module Stick
     end
 
     def coerce(other) # :nodoc:
-      return [::Stick::Unit.new({}), self] if other == 1
-      ::Stick::Converter.coerce_units(self, other)
+      return [::Stick::Units::Unit.new({}), self] if other == 1
+      ::Stick::Units::Converter.coerce_units(self, other)
     end
 
     def simplify
-      ::Stick::Converter.simplify_unit(self)
+      ::Stick::Units::Converter.simplify_unit(self)
     end
 
-    # Returns +true+ iff the two Stick are equals, <i>i.e.,</i> iff they have
+    # Returns +true+ iff the two units are equals, <i>i.e.,</i> iff they have
     # the same exponent for all units, and they both use the same Converter.
     def ==(other)
-      other.is_a?(::Stick::Unit) && other.units == units
+      other.is_a?(::Stick::Units::Unit) && other.units == units
     end
 
     alias eql? ==
@@ -264,7 +265,7 @@ module Stick
     # Unit. This is less strict than equality because for example hours are
     # compatible with seconds ("we can add them"), but hours are not seconds.
     def compatible_with?(other)
-      conv1, conv2 = ::Stick::Converter.coerce_units(self, other)
+      conv1, conv2 = ::Stick::Units::Converter.coerce_units(self, other)
       conv1.units == conv2.units
     end
 
@@ -288,11 +289,11 @@ module Stick
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        args[0] = (::Stick::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Converter
-        return self * ::Stick::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
-      elsif (::Stick::Converter.current.registered?(m) rescue false)
+        args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
+        return self * ::Stick::Units::Unit.new({m => 1}, args[0]) if args[0] && args[0].registered?(m)
+      elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return self * ::Stick::Unit.new({m => 1}, ::Stick::Converter.current)
+        return self * ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -302,7 +303,7 @@ module Stick
     private
 
     def decode_string(s, converter)
-      if ::Stick::Regexps::TOTAL_UNIT_REGEXP =~ s
+      if ::Stick::Units::Regexps::TOTAL_UNIT_REGEXP =~ s
         numerator, denominator = $1, $2
         units = {}
         decode_multiplicative_string(numerator, 1, converter, units) if numerator
@@ -316,9 +317,9 @@ module Stick
     end
 
     def decode_multiplicative_string(s, multiplier, converter, result)
-      s.scan(::Stick::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
+      s.scan(::Stick::Units::Regexps::SINGLE_UNIT_REGEXP) do |conv, unit, exp|
         if unit
-          conv = ::Stick::Converter.converter(conv)
+          conv = ::Stick::Units::Converter.converter(conv)
         else
           conv, unit = converter[], conv
         end
@@ -336,13 +337,13 @@ module Stick
 
     def do_op(op, dual_op, other)
       other = other.to_unit
-      raise TypeError, "cannot convert to Unit" unless ::Stick::Unit === other
+      raise TypeError, "cannot convert to Unit" unless ::Stick::Units::Unit === other
       result = @units.dup
       other.units.each_pair do |u, e|
         result[u] = 0 if not result[u]
         result[u] = result[u].send(dual_op, e)
       end
-      ::Stick::Unit.new(result)
+      ::Stick::Units::Unit.new(result)
     end
 
   end
@@ -353,9 +354,9 @@ module Stick
   #
   # A Value can be added to, subtracted from and multiplied with another value,
   # though only when both Values are using the same Converter. While multiplication
-  # is always possible, adding or subtracting values with incompatible Stick
-  # results in a TypeError. When two Stick are compatible but not the same,
-  # the Value with the larger of the Stick is converted to the smaller of the Stick.
+  # is always possible, adding or subtracting values with incompatible units
+  # results in a TypeError. When two units are compatible but not the same,
+  # the Value with the larger of the units is converted to the smaller of the units.
   # For example adding 100 seconds and 1 minute, the latter is converted to 60 seconds
   # because a second is smaller than a minute. The result is 160 seconds.
   class Value < Numeric
@@ -413,7 +414,7 @@ module Stick
     %w{ * / }.each do |op|
       eval %{
         def #{op}(other)
-          ::Stick::Value.new(*do_multiplicative_op(:#{op}, other))
+          ::Stick::Units::Value.new(*do_multiplicative_op(:#{op}, other))
         end
       }
     end
@@ -421,14 +422,14 @@ module Stick
     %w{ + - modulo remainder % }.each do |op|
       eval %{
         def #{op}(other)
-          ::Stick::Value.new(*do_additive_op(:#{op}, other))
+          ::Stick::Units::Value.new(*do_additive_op(:#{op}, other))
         end
       }
     end
 
     def divmod(other)
       (q, r), unit = *do_additive_op(:divmod, other)
-      [q, ::Stick::Value.new(r, unit)]
+      [q, ::Stick::Units::Value.new(r, unit)]
     end
 
     def div(other)
@@ -444,7 +445,7 @@ module Stick
     end
 
     def **(other) # :nodoc:
-      ::Stick::Value.new(@value ** other, @unit ** other)
+      ::Stick::Units::Value.new(@value ** other, @unit ** other)
     end
 
     def <=>(other) # :nodoc:
@@ -466,7 +467,7 @@ module Stick
     %w{ abs ceil floor next round succ truncate }.each do |op|
       eval %{
         def #{op}
-          ::Stick::Value.new(@value.#{op}, @unit)
+          ::Stick::Units::Value.new(@value.#{op}, @unit)
         end
       }
     end
@@ -482,20 +483,20 @@ module Stick
     # Converts this Value to the given Unit.
     # This only works if the Converters used by this Value's Unit
     # and the given Unit are the same. It obviously fails if the
-    # Stick are not compatible (can't add apples and oranges).
+    # Units are not compatible (can't add apples and oranges).
     def to(to_unit, converter = nil)
       raise ArgumentError, "Wrong number of arguments" if converter && !(::String === to_unit)
       to_unit = to_unit.to_unit(converter)
-      raise TypeError, "cannot convert to Unit" unless ::Stick::Unit === to_unit
+      raise TypeError, "cannot convert to Unit" unless ::Stick::Units::Unit === to_unit
       conv1, conv2 = unit.coerce(to_unit)
       raise TypeError, "incompatible units for operation" if conv1.units != conv2.units
       mult = conv1.multiplier / conv2.multiplier
-      ::Stick::Value.new(value * mult, to_unit)
+      ::Stick::Units::Value.new(value * mult, to_unit)
     end
 
     def coerce(other) # :nodoc:
       if ::Numeric === other
-        [::Stick::Value.new!(other, ::Stick::Unit.new), self]
+        [::Stick::Units::Value.new!(other, ::Stick::Units::Unit.new), self]
       else
         super
       end
@@ -510,7 +511,7 @@ module Stick
     # exception otherwise.
     def to_f
       val = simplify
-      if ::Stick::Value === val
+      if ::Stick::Units::Value === val
         raise TypeError, "Cannot convert to float"
       else
         val.to_f
@@ -521,7 +522,7 @@ module Stick
     # exception otherwise.
     def to_i
       val = simplify
-      if ::Stick::Value === val
+      if ::Stick::Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_i
@@ -532,7 +533,7 @@ module Stick
     # exception otherwise.
     def to_int
       val = simplify
-      if ::Stick::Value === val
+      if ::Stick::Units::Value === val
         raise TypeError, "Cannot convert to integer"
       else
         val.to_int
@@ -546,7 +547,7 @@ module Stick
       if new_unit.unitless?
         @value * mul
       else
-        ::Stick::Value.new(@value * mul, new_unit)
+        ::Stick::Units::Value.new(@value * mul, new_unit)
       end
     end
 
@@ -559,11 +560,11 @@ module Stick
 
     def method_missing(m, *args, &blk)
       if args.length == 1
-        args[0] = (::Stick::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Converter
-        return self * ::Stick::Value.new(1, ::Stick::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
-      elsif (::Stick::Converter.current.registered?(m) rescue false)
+        args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
+        return self * ::Stick::Units::Value.new(1, ::Stick::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
+      elsif (::Stick::Units::Converter.current.registered?(m) rescue false)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return self * ::Stick::Value.new(1, ::Stick::Unit.new({m => 1}, ::Stick::Converter.current))
+        return self * ::Stick::Units::Value.new(1, ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current))
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -573,9 +574,9 @@ module Stick
   private
 
     def self.decode_string(s, converter)
-      if m = ::Stick::Regexps::VALUE_REGEXP.match(s)
+      if m = ::Stick::Units::Regexps::VALUE_REGEXP.match(s)
         value = m[2].empty? ? Integer(m[1]) : Float(m[1])
-        unit = ::Stick::Unit.new(m[3], converter)
+        unit = ::Stick::Units::Unit.new(m[3], converter)
         [value, unit]
       else
         raise ::ArgumentError, "Illegal value string #{s.dump}"
@@ -584,8 +585,8 @@ module Stick
 
     def do_additive_op(op, other)
       other = other.to_value
-      raise TypeError, "cannot convert to Value" unless ::Stick::Value === other
-      if other.is_a? ::Stick::Value
+      raise TypeError, "cannot convert to Value" unless ::Stick::Units::Value === other
+      if other.is_a? ::Stick::Units::Value
         conv1, conv2 = unit.coerce(other.unit)
         raise TypeError, "incompatible units for #{op}" if conv1.units != conv2.units
         mult = conv2.multiplier / conv1.multiplier
@@ -602,9 +603,9 @@ module Stick
 
     def do_multiplicative_op(op, other)
       case other
-      when ::Stick::Value
+      when ::Stick::Units::Value
         [value.send(op, other.value), unit.send(op, other.unit)]
-      when ::Stick::Unit
+      when ::Stick::Units::Unit
         [value, unit.send(op, other)]
       when ::Numeric
         [value.send(op, other), unit]
@@ -613,19 +614,19 @@ module Stick
         #       Problem : how check whether to_value failed without
         #                 masking all exceptions?
         other = other.to_value
-        raise TypeError, "cannot convert to Value" unless ::Stick::Value === other
+        raise TypeError, "cannot convert to Value" unless ::Stick::Units::Value === other
         do_multiplicative_op(op, other)
       end
     end
 
   end
 
-  # This class handles all conversions between Stick.
+  # This class handles all conversions between units.
   #
-  # There are two kinds of Stick; those that are not expressed as a function
-  # of other Stick --called base units-- and those that are expressed
-  # as a function of other Stick --called derived units. The latter kind is
-  # registered specifying how it depends on other Stick, while the former
+  # There are two kinds of units; those that are not expressed as a function
+  # of other units --called base units-- and those that are expressed
+  # as a function of other units --called derived units. The latter kind is
+  # registered specifying how it depends on other units, while the former
   # kind is not.
   #
   # This class also registers a list of Converters that are generally useable.
@@ -672,7 +673,7 @@ module Stick
     # Included the given converter in the receiver, unless it
     # was already included.
     def include(conv)
-      conv = ::Stick::Converter.converter(conv) if not conv.is_a?(::Stick::Converter)
+      conv = ::Stick::Units::Converter.converter(conv) if not conv.is_a?(::Stick::Units::Converter)
       raise "Circular include" if conv.includes?(self)
       @included << conv if not includes? conv
       self
@@ -681,7 +682,7 @@ module Stick
     # Returns whether the given converter was included in the
     # receiver.
     def includes?(conv)
-      conv = ::Stick::Converter.converter(conv) if not conv.is_a?(::Stick::Converter)
+      conv = ::Stick::Units::Converter.converter(conv) if not conv.is_a?(::Stick::Units::Converter)
       return true if conv == self
       @included.each do |c|
         return true if conv == c || c.includes?(conv)
@@ -713,7 +714,7 @@ module Stick
     # Returns the base unit with this name
     def base_unit(name)
       if conv = registered?(name)
-        return ::Stick::BaseUnit.new(name, conv)
+        return ::Stick::Units::BaseUnit.new(name, conv)
       end
       raise "unit #{name.to_s.dump} not registered with #{self}"
     end
@@ -727,7 +728,7 @@ module Stick
     def method_missing(m, *args, &blk)
       if registered?(m)
         raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-        return ::Stick::Unit.new({m => 1}, self)
+        return ::Stick::Units::Unit.new({m => 1}, self)
       end
       ::Exception.with_clean_backtrace("method_missing") {
         super
@@ -750,7 +751,7 @@ module Stick
     #            The differences with aliases is that prefixes work differently;
     #            see +register_si_unit+, +register_binary_unit+ and
     #            +register_binary_iec_unit+.
-    # +equals+:: If present, specifies how the Unit depends on other Stick.
+    # +equals+:: If present, specifies how the Unit depends on other units.
     #            The value for this key can either be a Hash with +unit+ mapping to
     #            a Unit and +multiplier+ mapping to a numeric multiplier, or
     #            a String containing the multiplier, followed by a space, followed by
@@ -793,12 +794,12 @@ module Stick
         abbrev = info[:abbrev]
         multiplier = info[:multiplier] || 1
         power = info[:power] || 1
-        register_unit(pre + unit, :equals => {:unit => ::Stick::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+        register_unit(pre + unit, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         aliases.each do |a|
-          register_unit(pre + a, :equals => {:unit => ::Stick::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+          register_unit(pre + a, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         end
         abbrevs.each do |a|
-          register_unit(abbrev + a, :equals => {:unit => ::Stick::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
+          register_unit(abbrev + a, :equals => {:unit => ::Stick::Units::Unit.new({unit_sym => power}, self), :multiplier => multiplier})
         end
       end
     end
@@ -819,9 +820,9 @@ module Stick
                 :multiplier => data[:multiplier] || data['multiplier']}
       end
       if /^\s*1\s*\// =~ data
-        {:unit => ::Stick::Unit.new(data, self)}
-      elsif m = /^\s*#{::Stick::Regexps::NUMBER_REGEXP}(?:\s+(\S.*)$|\s*$)/.match(data)
-        unit = m[3] ? ::Stick::Unit.new(m[3], self) : ::Stick::Unit.new({}, self)
+        {:unit => ::Stick::Units::Unit.new(data, self)}
+      elsif m = /^\s*#{::Stick::Units::Regexps::NUMBER_REGEXP}(?:\s+(\S.*)$|\s*$)/.match(data)
+        unit = m[3] ? ::Stick::Units::Unit.new(m[3], self) : ::Stick::Units::Unit.new({}, self)
         if m[1]
           multiplier = m[2].empty? ? Integer(m[1]) : Float(m[1])
           {:unit => unit, :multiplier => multiplier}
@@ -829,7 +830,7 @@ module Stick
           {:unit => unit}
         end
       else
-        {:unit => ::Stick::Unit.new(data, self)}
+        {:unit => ::Stick::Units::Unit.new(data, self)}
       end
     end
 
@@ -850,16 +851,16 @@ module Stick
 
       # Returns the current Converter in the current Thread.
       # The default converter is the one returned by <code>converter(:default)</code>.
-      # See also Stick#with_converter and Converter.converter.
+      # See also Stick::Units#with_converter and Converter.converter.
       def current
-        Thread.current[:'Stick::converter'] ||= converter(:default)
+        Thread.current[:'Stick::Units::converter'] ||= converter(:default)
       end
 
       def with_converter(conv) # :nodoc:
-        conv = converter(conv) if not conv.is_a? ::Stick::Converter
-        raise ::ArgumentError, "Converter expected" if not conv.is_a? ::Stick::Converter
+        conv = converter(conv) if not conv.is_a? ::Stick::Units::Converter
+        raise ::ArgumentError, "Converter expected" if not conv.is_a? ::Stick::Units::Converter
         begin
-          old_conv = Thread.current[:'Stick::converter']
+          old_conv = Thread.current[:'Stick::Units::converter']
           if old_conv
             new_conv = Converter.send(:new, nil)
             new_conv.include(old_conv)
@@ -867,10 +868,10 @@ module Stick
           else
             new_conv = conv
           end
-          Thread.current[:'Stick::converter'] = new_conv
+          Thread.current[:'Stick::Units::converter'] = new_conv
           yield
         ensure
-          Thread.current[:'Stick::converter'] = old_conv
+          Thread.current[:'Stick::Units::converter'] = old_conv
         end
       end
 
@@ -918,7 +919,7 @@ module Stick
         units.each_pair do |u, e|
           (u.conversion != :none ? other_units : base_units)[u] = e
         end
-        result = Conversion.new(::Stick::Unit.new(base_units, self), multiplier)
+        result = Conversion.new(::Stick::Units::Unit.new(base_units, self), multiplier)
         other_units.each_pair do |u, e|
           result *= (u.conversion ** e)
         end
@@ -943,17 +944,17 @@ module Stick
   end
 
 end
-
+end
 
 class Numeric
   #
   def method_missing(m, *args, &blk)
     if args.length == 1
-      args[0] = (::Stick::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Converter
-      return ::Stick::Value.new(self, ::Stick::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
-    elsif ::Stick::Converter.current.registered?(m)
+      args[0] = (::Stick::Units::Converter.converter(args[0]) rescue nil) if not args[0].is_a? ::Stick::Units::Converter
+      return ::Stick::Units::Value.new(self, ::Stick::Units::Unit.new({m => 1}, args[0])) if args[0] && args[0].registered?(m)
+    elsif ::Stick::Units::Converter.current.registered?(m)
       raise ::ArgumentError, "Wrong number of arguments" if args.length != 0
-      return ::Stick::Value.new(self, ::Stick::Unit.new({m => 1}, ::Stick::Converter.current))
+      return ::Stick::Units::Value.new(self, ::Stick::Units::Unit.new({m => 1}, ::Stick::Units::Converter.current))
     end
     ::Exception.with_clean_backtrace("method_missing") {
       super
@@ -962,7 +963,7 @@ class Numeric
 
   #
   def to_value(unit)
-    ::Stick::Value.new(self, unit)
+    ::Stick::Units::Value.new(self, unit)
   end
 end
 
@@ -970,11 +971,11 @@ end
 class String
   #
   def to_unit(converter = nil)
-    ::Stick::Unit.new(self, converter)
+    ::Stick::Units::Unit.new(self, converter)
   end
 
   #
   def to_value(converter = nil)
-    ::Stick::Value.new(self, converter)
+    ::Stick::Units::Value.new(self, converter)
   end
 end