quantify 1.0.5 → 1.1.0

data/lib/quantify/core_extensions/numeric.rb

@@ -0,0 +1,19 @@
+
+class Numeric
+  # Syntactic sugar for defining instances of the Quantity class.
+  #
+  # Enables quantities to be specified by using unit names, symbols or JScience
+  # labels as argments on Numeric objects, e.g.
+  #
+  #   1.5.metre      is equivalent to Quantity. new 1.5, :metre
+  #
+  #   1000.t         is equivalent to Quantity. new 1000, :t
+  #
+  def method_missing(method, *args, &block)
+    if unit = Unit.for(method.to_s)
+      Quantify::Quantity.new self, unit
+    else
+      super
+    end
+  end
+end

data/lib/quantify/core_extensions/string.rb

@@ -0,0 +1,29 @@
+
+class String
+
+  def with_superscript_characters
+    self.gsub(/\^2\b/,"²").gsub(/\^3\b/,"³")
+  end
+
+  def without_superscript_characters
+    self.gsub(/¹\b/,"").gsub(/²\b/,"^2").gsub(/³\b/,"^3")
+  end
+  
+  def remove_underscores
+    self.gsub("_"," ")
+  end
+
+  def words
+    split(/\s+/)
+  end
+
+  def word_count
+    words.size
+  end
+
+  def to_quantity
+    Quantify::Quantity.parse(self)
+  end
+  alias :to_q :to_quantity
+
+end

data/lib/quantify/core_extensions/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+
+  def remove_underscores
+    self.to_s.remove_underscores
+  end
+  
+end

data/lib/quantify/dimensions.rb

@@ -1,4 +1,3 @@
-#! usr/bin/ruby
 
 module Quantify
 
@@ -52,7 +51,7 @@ module Quantify
     #
     def self.base_dimensions
       @@dimensions.select do |dimensions|
-        BASE_QUANTITIES.map(&:standardize).include? dimensions.describe
+        BASE_QUANTITIES.map {|q| q.remove_underscores}.include?(dimensions.describe)
       end
     end
 
@@ -83,8 +82,8 @@ module Quantify
     # Remove a dimension from the system of known dimensions
     def self.unload(*unloaded_dimensions)
       [unloaded_dimensions].flatten.each do |unloaded_dimension|
-        unloaded_dimension = Dimensions.for(unloaded_dimensions)
-        @@dimensions.delete_if { |unit| unit.physical_quantity == unloaded_dimension.physical_quantity }
+        unloaded_dimension = Dimensions.for(unloaded_dimension)
+        @@dimensions.delete_if { |dimension| dimension.has_same_identity_as? unloaded_dimension }
       end
     end
 
@@ -97,7 +96,7 @@ module Quantify
     #                                               ... ]
     #
     def self.physical_quantities
-      @@dimensions.map(&:physical_quantity)
+      @@dimensions.map {|dimension| dimension.physical_quantity }
     end
 
     # Retrieve a known quantity - returns a Dimensions instance, which is a
@@ -116,10 +115,9 @@ module Quantify
     #
     def self.for(name)
       return name if name.is_a? Dimensions
-      if name.is_a? String or name.is_a? Symbol
-        if quantity = @@dimensions.find do |quantity|
-            quantity.physical_quantity == name.standardize.downcase
-          end
+      if (name.is_a?(String) || name.is_a?(Symbol))
+        name = name.remove_underscores.downcase
+        if quantity = @@dimensions.find { |quantity| quantity.physical_quantity == name }
           return quantity.clone
         else
           raise Exceptions::InvalidArgumentError, "Physical quantity not known: #{name}"
@@ -141,8 +139,8 @@ module Quantify
     #
     #  end
     #
-    def self.configure &block
-        self.class_eval &block if block
+    def self.configure(&block)
+        self.class_eval(&block) if block
     end
 
     # Provides a shorthand for retrieving known quantities, e.g.:
@@ -185,7 +183,7 @@ module Quantify
     #
     def initialize(options={})
       if options.has_key?(:physical_quantity)
-        @physical_quantity = options.delete(:physical_quantity).standardize.downcase
+        @physical_quantity = options.delete(:physical_quantity).remove_underscores.downcase
       end
       enumerate_base_quantities(options)
       describe
@@ -199,7 +197,7 @@ module Quantify
     # description of the physical quantity represented.
     #
     def load
-      if describe and not loaded?
+      if describe && !loaded?
         @@dimensions << self
       elsif describe
         raise Exceptions::InvalidDimensionError, "A dimension instance with the same physical quantity already exists"
@@ -218,7 +216,7 @@ module Quantify
     end
 
     def has_same_identity_as?(other)
-      self.physical_quantity == other.physical_quantity and not self.physical_quantity.nil?
+      @physical_quantity == other.physical_quantity && !@physical_quantity.nil?
     end
 
     # Return a description of what physical quantity self represents. If no
@@ -246,7 +244,7 @@ module Quantify
     #
     def get_description
       similar = @@dimensions.find { |quantity| quantity == self }
-      @physical_quantity = ( similar.nil? ? nil : similar.physical_quantity )
+      @physical_quantity = similar.nil? ? nil : similar.physical_quantity
     end
 
     # Returns an array containing the known units which represent the physical
@@ -287,8 +285,8 @@ module Quantify
     #                                            #=> 'metre squared per second'
     #
     def si_unit
-      return Unit.steridian if self.describe == 'solid angle'
-      return Unit.radian if self.describe == 'plane angle' 
+      return Unit.steridian if describe == 'solid angle'
+      return Unit.radian if describe == 'plane angle' 
       return si_base_units.inject(Unit.unity) do |compound,unit|
         compound * unit
       end.or_equivalent
@@ -319,7 +317,7 @@ module Quantify
     def si_base_units(by=nil)
       self.to_hash.map do |dimension,index|
         Unit.base_quantity_si_units.select do |unit|
-          unit.measures == dimension.standardize
+          unit.measures == dimension.remove_underscores
         end.first.clone ** index
       end.map(&by)
     end
@@ -346,7 +344,7 @@ module Quantify
     # Returns true if self represents one of the base quantities (i.e. length,
     # mass, time, etc.)
     def is_base?
-      base_quantities.size == 1 and
+      base_quantities.size == 1 &&
         self.instance_variable_get(base_quantities.first) == 1 ? true : false
     end
 
@@ -495,7 +493,7 @@ module Quantify
     def enumerate_base_quantities(options)
       options.each_pair do |base_quantity,index|
         base_quantity = base_quantity.to_s.downcase.to_sym
-        unless index.is_a? Integer and BASE_QUANTITIES.include? base_quantity
+        unless index.is_a?(Integer) && BASE_QUANTITIES.include?(base_quantity)
           raise Exceptions::InvalidDimensionError, "An invalid base quantity was specified (#{base_quantity})"
         end
         variable = "@#{base_quantity}"
@@ -514,7 +512,7 @@ module Quantify
 
     # Make object represent a dimensionless quantity.
     def make_dimensionless
-      self.physical_quantity = 'dimensionless'
+      @physical_quantity = 'dimensionless'
       base_quantities.each { |var| remove_instance_variable(var) }
     end
 

data/lib/quantify/quantify.rb

@@ -4,7 +4,38 @@ module Quantify
     self.module_eval &block if block
   end
 
+  # Check whether superscript characters are turned on.
+  def self.use_superscript_characters?
+    @use_superscript_characters.nil? ? true : @use_superscript_characters
+  end
+
+  # Shorthand method for Quantify.use_superscript_characters=true
+  def self.use_superscript_characters!
+    self.use_superscript_characters=true
+  end
 
+  # Declare whether superscript characters should be used for unit names, symbols
+  # and labels - i.e. "²" and "³" rather than "^2" and "^3". Set to either true or
+  # false. If not set, superscript characters are used by default.
+  #
+  def self.use_superscript_characters=(true_or_false)
+    raise Exceptions::InvalidArgumentError,
+      "Argument must be true or false" unless true_or_false == true || true_or_false == false
+    @use_superscript_characters = true_or_false
+    refresh_all_unit_identifiers!
+  end
+
+  # Switch all unit identifiers (name, symbol, label) to use the currently
+  # configured system for superscripts.
+  #
+  def refresh_all_unit_identifiers!
+    Unit.units.replace(
+      Unit.units.map do |unit|
+        unit.refresh_identifiers!
+        unit
+      end
+    )
+  end
 
   module ExtendedMethods
 
@@ -17,7 +48,7 @@ module Quantify
     #
     def method_missing(method, *args, &block)
       if method.to_s =~ /((si|non_si|compound)_)?(non_(prefixed)_)?((base|derived|benchmark)_)?units(_by_(name|symbol|label))?/
-        if $2 or $4 or $6
+        if $2 || $4 || $6
           conditions = []
           conditions << "unit.is_#{$2}_unit?" if $2
           conditions << "!unit.is_prefixed_unit?" if $4

data/lib/quantify/quantity.rb

@@ -81,19 +81,19 @@ module Quantify
     #   Quantity.new(123.456, :degree_celsius).represents
     #                                                 #=> :temperature
     def represents
-      self.unit.measures
+      @unit.measures
     end
 
     # Returns a string representation of the quantity, using the unit symbol
     def to_s format=:symbol
       if format == :name
-        if self.value == 1 or self.value == -1
-          "#{self.value} #{self.unit.name}"
+        if @value == 1 || @value == -1
+          "#{@value} #{@unit.name}"
         else
-          "#{self.value} #{self.unit.pluralized_name}"
+          "#{@value} #{@unit.pluralized_name}"
         end
       else
-        "#{self.value} #{self.unit.send format}"
+        "#{@value} #{@unit.send format}"
       end
     end
 
@@ -116,20 +116,20 @@ module Quantify
     def to(new_unit)
       new_unit = Unit.for new_unit
       if is_basic_conversion_with_scalings? new_unit
-        Quantity.new(value,unit).conversion_with_scalings! new_unit
+        Quantity.new(@value,@unit).conversion_with_scalings! new_unit
       elsif self.unit.is_alternative_for? new_unit
-        Quantity.new(value,unit).convert_to_equivalent_unit! new_unit
+        Quantity.new(@value,@unit).convert_to_equivalent_unit! new_unit
       elsif self.unit.is_compound_unit?
-        Quantity.new(value,unit).convert_compound_unit_to_non_equivalent_unit! new_unit
+        Quantity.new(@value,@unit).convert_compound_unit_to_non_equivalent_unit! new_unit
       else
         nil # raise? or ...
       end      
     end
 
     def is_basic_conversion_with_scalings?(new_unit)
-      return true if (self.unit.has_scaling? or new_unit.has_scaling?) and
-        not self.unit.is_compound_unit? and
-        not new_unit.is_compound_unit?
+      return true if (@unit.has_scaling? || new_unit.has_scaling?) &&
+        !@unit.is_compound_unit? &&
+        !new_unit.is_compound_unit?
       return false
     end
 
@@ -139,14 +139,14 @@ module Quantify
     # base units
     #
     def convert_to_equivalent_unit!(new_unit)
-      old_unit = unit
+      old_unit = @unit
       self.multiply!(Unit.ratio new_unit, old_unit)
       old_base_units = old_unit.base_units.map { |base| base.unit } if old_unit.is_compound_unit?
       self.cancel_base_units!(*old_base_units || old_unit)
     end
 
     def conversion_with_scalings!(new_unit)
-      @value = (((self.value + self.unit.scaling) * self.unit.factor) / new_unit.factor) - new_unit.scaling
+      @value = (((@value + @unit.scaling) * @unit.factor) / new_unit.factor) - new_unit.scaling
       @unit = new_unit
       return self
     end
@@ -158,7 +158,7 @@ module Quantify
     #   Unit.kilowatt_hour.to :second           #=> 'kilowatt second'
     #
     def convert_compound_unit_to_non_equivalent_unit!(new_unit)
-      self.unit.base_units.select do |base|
+      @unit.base_units.select do |base|
         base.unit.is_alternative_for? new_unit
       end.inject(self) do |quantity,base|
         factor = Unit.ratio(new_unit**base.index, base.unit**base.index)
@@ -168,16 +168,16 @@ module Quantify
 
     # Converts a quantity to the equivalent quantity using only SI units
     def to_si
-      if self.unit.is_compound_unit?
-        Quantity.new(value,unit).convert_compound_unit_to_si!
+      if @unit.is_compound_unit?
+        Quantity.new(@value,@unit).convert_compound_unit_to_si!
       else
-        self.to(unit.si_unit)
+        self.to(@unit.si_unit)
       end
     end
 
     def convert_compound_unit_to_si!
-      until self.unit.is_base_quantity_si_unit? do
-        unit = self.unit.base_units.find do |base|
+      until @unit.is_base_quantity_si_unit? do
+        unit = @unit.base_units.find do |base|
           !base.is_base_quantity_si_unit?
         end.unit
         self.convert_compound_unit_to_non_equivalent_unit!(unit.si_unit)
@@ -192,9 +192,9 @@ module Quantify
     #
     def add_or_subtract!(operator,other)
       if other.is_a? Quantity
-        other = other.to(unit) if other.unit.is_alternative_for?(unit)
-        if self.unit == other.unit
-          @value = value.send operator, other.value
+        other = other.to(@unit) if other.unit.is_alternative_for?(@unit)
+        if @unit.is_equivalent_to? other.unit
+          @value = @value.send operator, other.value
           return self
         else
           raise Quantify::Exceptions::InvalidObjectError "Cannot add or subtract Quantities with different dimensions"
@@ -206,11 +206,11 @@ module Quantify
 
     def multiply_or_divide!(operator,other)
       if other.kind_of? Numeric
-        @value = value.send(operator,other)
+        @value = @value.send(operator,other)
         return self
       elsif other.kind_of? Quantity
-        @unit = unit.send(operator,other.unit).or_equivalent
-        @value = value.send(operator,other.value)
+        @unit = @unit.send(operator,other.unit).or_equivalent
+        @value = @value.send(operator,other.value)
         return self
       else
         raise Quantify::Exceptions::InvalidArgumentError "Cannot multiply or divide a Quantity by a non-Quantity or non-Numeric object"
@@ -219,8 +219,8 @@ module Quantify
 
     def pow!(power)
       raise Exceptions::InvalidArgumentError, "Argument must be an integer" unless power.is_a? Integer
-      @value = value ** power
-      @unit = unit ** power
+      @value = @value ** power
+      @unit = @unit ** power
       return self
     end
 
@@ -241,34 +241,34 @@ module Quantify
     end
 
     def add(other)
-      Quantity.new(value,unit).add!(other)
+      Quantity.new(@value,@unit).add!(other)
     end
     alias :+ :add
 
     def subtract(other)
-      Quantity.new(value,unit).subtract!(other)
+      Quantity.new(@value,@unit).subtract!(other)
     end
     alias :- :subtract
 
     def multiply(other)
-      Quantity.new(value,unit).multiply!(other)
+      Quantity.new(@value,@unit).multiply!(other)
     end
     alias :times :multiply
     alias :* :multiply
 
     def divide(other)
-      Quantity.new(value,unit).divide!(other)
+      Quantity.new(@value,@unit).divide!(other)
     end
     alias :/ :divide
 
     def pow(power)
-      Quantity.new(value,unit).pow!(power)
+      Quantity.new(@value,@unit).pow!(power)
     end
     alias :** :pow
 
     def rationalize_units
-      return self unless unit.is_a? Unit::Compound
-      self.to unit.clone.rationalize_base_units!
+      return self unless @unit.is_a? Unit::Compound
+      self.to @unit.clone.rationalize_base_units!
     end
 
     def rationalize_units!
@@ -279,7 +279,7 @@ module Quantify
     end
 
     def cancel_base_units!(*units)
-      @unit = unit.cancel_base_units!(*units) if unit.is_compound_unit?
+      @unit = @unit.cancel_base_units!(*units) if @unit.is_compound_unit?
       return self
     end
 
@@ -304,8 +304,8 @@ module Quantify
     def <=>(other)
       raise Exceptions::InvalidArgumentError unless other.is_a? Quantity
       raise Exceptions::InvalidArgumentError unless other.unit.is_alternative_for?(unit)
-      other = other.to unit
-      value.to_f <=> other.value.to_f
+      other = other.to @unit
+      @value.to_f <=> other.value.to_f
     end
 
     def ===(range)

data/lib/quantify/unit/base_unit.rb

@@ -45,7 +45,7 @@ module Quantify
       #
       def self.construct(unit,&block)
         new_unit = self.new unit.to_hash
-        yield new_unit if block_given?
+        block.call(new_unit) if block_given?
         return new_unit
       end
 
@@ -64,8 +64,7 @@ module Quantify
         class_eval &block if block
       end
       
-      attr_accessor :name, :symbol, :label, :factor
-      attr_reader :dimensions
+      attr_reader :name, :symbol, :label, :factor, :dimensions
       attr_reader :acts_as_alternative_unit, :acts_as_equivalent_unit
 
       # Create a new Unit::Base instance.
@@ -100,34 +99,88 @@ module Quantify
       # representation in the Dimensions class. This dimensions attribute is to
       # provide much of the unit functionality
       #
-      def initialize(options=nil)    
+      def initialize(options=nil,&block)
         @acts_as_alternative_unit = true
         @acts_as_equivalent_unit = false
-        @factor = 1.0
-        @symbol = nil
-        @label = nil
+        self.factor = 1.0
+        self.symbol = nil
+        self.label = nil
         if options.is_a? Hash
           self.dimensions = options[:dimensions] || options[:physical_quantity]
-          @name = options[:name].standardize.singularize.downcase
-          @factor = options[:factor].to_f if options[:factor]
-          @symbol = options[:symbol].standardize if options[:symbol]
-          @label = options[:label].to_s if options[:label]
+          self.name = options[:name]
+          self.factor = options[:factor] if options[:factor]
+          self.symbol = options[:symbol] if options[:symbol]
+          self.label = options[:label] if options[:label]
         end
-        yield self if block_given?
+        block.call(self) if block_given?
         valid?
       end
 
+      # Set the dimensions attribute of self. Valid arguments passed in are (1)
+      # instances of the Dimensions class; or (2) string or symbol matching
+      # the physical quantity attribute of a known Dimensions object.
+      #
       def dimensions=(dimensions)
         if dimensions.is_a? Dimensions
           @dimensions = dimensions
-        elsif dimensions.is_a? String or dimensions.is_a? Symbol
-          @dimensions = Dimensions.for dimensions
+        elsif dimensions.is_a?(String) || dimensions.is_a?(Symbol)
+          @dimensions = Dimensions.for(dimensions)
         else
           raise Exceptions::InvalidArgumentError, "Unknown physical_quantity specified"
         end
       end
       alias :physical_quantity= :dimensions=
 
+      # Set the name attribute of self. Names are stringified, singlularized and
+      # stripped of underscores. Superscripts are formatted according to the
+      # configuration found in Quantify.use_superscript_characters? Names are NOT
+      # case sensitive (retrieving units by name can use any or mixed cases).
+      #
+      def name=(name)
+        name = name.to_s.remove_underscores.singularize
+        @name = Quantify.use_superscript_characters? ? name.with_superscript_characters : name.without_superscript_characters
+      end
+
+      # Set the symbol attribute of self. Symbols are stringified and stripped of
+      # any underscores. Superscripts are formatted according to the configuration
+      # found in Quantify.use_superscript_characters?
+      #
+      # Conventional symbols for units and unit prefixes prescribe case clearly
+      # (e.g. 'm' => metre, 'M' => mega-; 'g' => gram, 'G' => giga-) and
+      # therefore symbols ARE case senstive.
+      #
+      def symbol=(symbol)
+        symbol = symbol.to_s.remove_underscores
+        @symbol = Quantify.use_superscript_characters? ? symbol.with_superscript_characters : symbol.without_superscript_characters
+      end
+
+      # Set the label attribute of self. This represents the unique identifier for
+      # the unit, and follows JScience for many standard units and general
+      # formatting (e.g. underscores, forward slashes, middots).
+      #
+      # Labels are stringified and superscripts are formatted according to the
+      # configuration found in Quantify.use_superscript_characters?
+      #
+      # Labels are a unique consistent reference and are therefore case senstive.
+      #
+      def label=(label)
+        label = label.to_s.gsub(" ","_")
+        @label = Quantify.use_superscript_characters? ? label.with_superscript_characters : label.without_superscript_characters
+      end
+
+      # Refresh the name, symbol and label attributes of self with respect to the
+      # configuration found in Quantify.use_superscript_characters?
+      #
+      def refresh_identifiers!
+        self.name = name
+        self.symbol = symbol
+        self.label = label
+      end
+
+      def factor=(factor)
+        @factor = factor.to_f
+      end
+
       # Permits a block to be used, operating on self. This is useful for modifying
       # the attributes of an already instantiated unit, especially when defining
       # units on the basis of operation on existing units for adding specific
@@ -139,17 +192,17 @@ module Quantify
       #     unit.name = 'pound per square inch'
       #   end
       #
-      def configure
-        yield self if block_given?
+      def configure(&block)
+        block.call(self) if block_given?
         return self if valid?
       end
 
       # Similar to #configure but makes the new unit configuration the canonical
       # unit for self.label
       #
-      def configure_as_canonical &block
+      def configure_as_canonical(&block)
         unload if loaded?
-        configure &block if block_given?
+        configure(&block) if block_given?
         make_canonical
       end
 
@@ -158,8 +211,8 @@ module Quantify
       # If a block is given, the unit can be configured prior to loading, in a
       # similar to way to the #configure method.
       #
-      def load
-        yield self if block_given?
+      def load(&block)
+        block.call(self) if block_given?
         raise Exceptions::InvalidArgumentError, "A unit with the same label: #{self.name}) already exists" if loaded?
         Quantify::Unit.units << self if valid?
         return self
@@ -224,14 +277,14 @@ module Quantify
       end
 
       def pluralized_name
-        self.name.pluralize
+        @name.pluralize
       end
       
       # Determine if the unit represents one of the base quantities, length,
       # mass, time, temperature, etc.
       #
       def is_base_unit?
-        Dimensions::BASE_QUANTITIES.map(&:standardize).include? self.measures
+        Dimensions::BASE_QUANTITIES.map {|base| base.remove_underscores }.include? self.measures
       end
 
       # Determine if the unit is THE canonical SI unit for a base quantity (length,
@@ -239,20 +292,20 @@ module Quantify
       # returning true only for metre, kilogram, second, Kelvin, etc.
       #
       def is_base_quantity_si_unit?
-        is_si_unit? and is_base_unit? and is_benchmark_unit?
+        is_si_unit? && is_base_unit? && is_benchmark_unit?
       end
 
       # Determine is the unit is a derived unit - that is, a unit made up of more
       # than one of the base quantities
       #
       def is_derived_unit?
-        not is_base_unit?
+        !is_base_unit?
       end
 
       # Determine if the unit is a prefixed unit
       def is_prefixed_unit?
-        return true if valid_prefixes.size > 0 and
-          self.name =~ /\A(#{valid_prefixes.map(&:name).join("|")})/
+        return true if valid_prefixes.size > 0 &&
+          self.name =~ /\A(#{valid_prefixes.map {|p| p.name}.join("|")})/
         return false
       end
 
@@ -263,7 +316,7 @@ module Quantify
       # containing a prefix. This oddity makes this method useful/necessary.
       #
       def is_benchmark_unit?
-        self.factor == 1.0
+        @factor == 1.0
       end
 
       # Determine is a unit object represents an SI named unit
@@ -283,18 +336,18 @@ module Quantify
       end
 
       def is_dimensionless?
-        self.dimensions.is_dimensionless?
+        @dimensions.is_dimensionless?
       end
 
-      # Determine if self is the same unit as another. Similarity is based on
+      # Determine if self is equivalent to another. Equivalency is based on
       # representing the same physical quantity (i.e. dimensions) and the same
       # factor and scaling values.
       #
-      #  Unit.metre.is_same_as? Unit.foot    #=> false
+      #  Unit.metre.is_equivalent_to? Unit.foot    #=> false
       #
-      #  Unit.metre.is_same_as? Unit.gram    #=> false
+      #  Unit.metre.is_equivalent_to? Unit.gram    #=> false
       #
-      #  Unit.metre.is_same_as? Unit.metre   #=> true
+      #  Unit.metre.is_equivalent_to? Unit.metre   #=> true
       #
       # The base_units attr of Compound units are not compared. Neither are the
       # names or symbols. This is because we want to recognise cases where units
@@ -303,25 +356,24 @@ module Quantify
       # example, if we build a unit for energy using only SI units, we want to
       # recognise this as a joule, rather than a kg m^2 s^-2, e.g.
       #
-      #   (Unit.kg*Unit.m*Unit.m/Unit.s/Unit.s).is_same_as? Unit.joule
+      #   (Unit.kg*Unit.m*Unit.m/Unit.s/Unit.s).is_equivalent_to? Unit.joule
       #
       #                                      #=> true
       #
-      def is_same_as?(other)
+      def is_equivalent_to?(other)
         [:dimensions,:factor,:scaling].all? do |attr|
           self.send(attr) == other.send(attr)
         end
       end
-      
-      alias :== :is_same_as?
 
       # Check if unit has the identity as another, i.e. the same label. This is
       # used to determine if a unit with the same accessors already exists in
       # the module variable @@units
       #
       def has_same_identity_as?(other)
-        self.label == other.label and not self.label.nil?
+        @label == other.label && !@label.nil?
       end
+      alias :== :has_same_identity_as?
 
       # Determine if another unit is an alternative unit for self, i.e. do the two
       # units represent the same physical quantity. This is established by compraing
@@ -334,7 +386,7 @@ module Quantify
       #  Unit.metre.is_alternative_for? Unit.metre   #=> true
       #
       def is_alternative_for?(other)
-        other.dimensions == self.dimensions
+        other.dimensions == @dimensions
       end
       
       # List the alternative units for self, i.e. the other units which share
@@ -348,8 +400,8 @@ module Quantify
       # are returned within the array
       #
       def alternatives(by=nil)
-        self.dimensions.units(nil).reject do |unit|
-          unit.is_same_as? self or not unit.acts_as_alternative_unit
+        @dimensions.units(nil).reject do |unit|
+          unit.is_equivalent_to?(self) || !unit.acts_as_alternative_unit
         end.map(&by)
       end
 
@@ -357,18 +409,18 @@ module Quantify
       # by self, e.g.
       #
       def si_unit
-        self.dimensions.si_unit
+        @dimensions.si_unit
       end
 
       def valid?
-        return true if valid_descriptors? and valid_dimensions?
+        return true if valid_descriptors? && valid_dimensions?
         raise Exceptions::InvalidArgumentError, "Unit definition must include a name, a symbol, a label and physical quantity"
       end
 
       def valid_descriptors?
         [:name, :symbol, :label].all? do |attr|
           attribute = send(attr)
-          attribute.is_a? String and not attribute.empty?
+          attribute.is_a?(String) && !attribute.empty?
         end
       end
 
@@ -396,7 +448,7 @@ module Quantify
       #                                               "T", "P" ... ]
       #
       def valid_prefixes(by=nil)
-        return empty_array = [] if self.is_compound_unit?
+        return [] if self.is_compound_unit?
         return Unit::Prefix.si_prefixes.map(&by) if is_si_unit?
         return Unit::Prefix.non_si_prefixes.map(&by) if is_non_si_unit?
       end
@@ -406,7 +458,7 @@ module Quantify
       #
       def multiply(other)
         options = []
-        self.instance_of?(Unit::Compound) ? options += self.base_units : options << self
+        self.instance_of?(Unit::Compound) ? options += @base_units : options << self
         other.instance_of?(Unit::Compound) ? options += other.base_units : options << other
         Unit::Compound.new(*options)
       end
@@ -421,7 +473,7 @@ module Quantify
       #
       def divide(other)
         options = []
-        self.instance_of?(Unit::Compound) ? options += self.base_units : options << self
+        self.instance_of?(Unit::Compound) ? options += @base_units : options << self
 
         if other.instance_of? Unit::Compound
           options += other.base_units.map { |base| base.index *= -1; base }
@@ -461,7 +513,7 @@ module Quantify
       # of self, complete with modified name, symbol, factor, etc..
       #
       def with_prefix(name_or_symbol)
-        if self.name =~ /\A(#{valid_prefixes(:name).join("|")})/
+        if @name =~ /\A(#{valid_prefixes(:name).join("|")})/
           raise Exceptions::InvalidArgumentError, "Cannot add prefix where one already exists: #{self.name}"
         end
         
@@ -469,11 +521,11 @@ module Quantify
 
         unless prefix.nil?
           new_unit_options = {}
-          new_unit_options[:name] = "#{prefix.name}#{self.name}"
-          new_unit_options[:symbol] = "#{prefix.symbol}#{self.symbol}"
-          new_unit_options[:label] = "#{prefix.symbol}#{self.label}"
-          new_unit_options[:factor] = prefix.factor * self.factor
-          new_unit_options[:physical_quantity] = self.dimensions
+          new_unit_options[:name] = "#{prefix.name}#{@name}"
+          new_unit_options[:symbol] = "#{prefix.symbol}#{@symbol}"
+          new_unit_options[:label] = "#{prefix.symbol}#{@label}"
+          new_unit_options[:factor] = prefix.factor * @factor
+          new_unit_options[:physical_quantity] = @dimensions
           self.class.new(new_unit_options)
         else
           raise Exceptions::InvalidArgumentError, "Prefix unit is not known: #{prefix}"
@@ -503,7 +555,7 @@ module Quantify
       #   (1/unit).symbol                     #=> "m^-1"
       #
       def coerce(object)
-        if object.kind_of? Numeric and object == 1
+        if object.kind_of?(Numeric) && object == 1
           return Unit.unity, self
         else
           raise Exceptions::InvalidArgumentError, "Cannot coerce #{self.class} into #{object.class}"
@@ -520,9 +572,9 @@ module Quantify
       #
       def initialize_copy(source)
         super
-        instance_variable_set("@dimensions", dimensions.clone)
+        instance_variable_set("@dimensions", @dimensions.clone)
         if self.is_compound_unit?
-          instance_variable_set("@base_units", base_units.map {|base| base.clone })
+          instance_variable_set("@base_units", @base_units.map {|base| base.clone })
         end
       end
 
@@ -537,12 +589,12 @@ module Quantify
       # is equaivalent to Unit.m.alternatives :name
       #
       def method_missing(method, *args, &block)
-        if method.to_s =~ /(to_)(.*)/ and prefix = Prefix.for($2.to_sym)
-          return self.with_prefix prefix
-        elsif method.to_s =~ /(alternatives_by_)(.*)/ and self.respond_to? $2.to_sym
-          return self.alternatives $2.to_sym
-        elsif method.to_s =~ /(valid_prefixes_by_)(.*)/ and Prefix::Base.instance_methods.include? $2.to_s
-          return self.valid_prefixes $2.to_sym
+        if method.to_s =~ /(to_)(.*)/ && prefix = Prefix.for($2.to_sym)
+          return self.with_prefix(prefix)
+        elsif method.to_s =~ /(alternatives_by_)(.*)/ && self.respond_to?($2.to_sym)
+          return self.alternatives($2.to_sym)
+        elsif method.to_s =~ /(valid_prefixes_by_)(.*)/ && Prefix::Base.instance_methods.include?($2.to_s)
+          return self.valid_prefixes($2.to_sym)
         end
         super
       end