auom 0.0.6 → 0.1.0

data/lib/auom/algebra.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module AUOM
   # The AUOM algebra
   module Algebra
@@ -8,7 +10,7 @@ module AUOM
     # @return [Unit]
     #
     # @example
-    #  
+    #
     #   # unitless
     #   Unit.new(1) + Unit.new(2) # => <Unit @scalar=3>
     #
@@ -24,7 +26,7 @@ module AUOM
       klass = self.class
       operand = klass.convert(operand)
       assert_same_unit(operand)
-      klass.new(operand.scalar + scalar, numerators.dup, denominators.dup)
+      klass.new(operand.scalar + scalar, numerators, denominators)
     end
 
     alias_method :+, :add
@@ -36,7 +38,7 @@ module AUOM
     # @return [Unit]
     #
     # @example
-    #  
+    #
     #   # unitless
     #   Unit.new(2) - Unit.new(1) # => <Unit @scalar=1>
     #
@@ -49,7 +51,7 @@ module AUOM
     # @api public
     #
     def substract(operand)
-      add(self.class.convert(operand) * -1)
+      add(operand * -1)
     end
 
     alias_method :-, :substract
@@ -61,7 +63,7 @@ module AUOM
     # @return [Unit]
     #
     # @example
-    #  
+    #
     #   # unitless
     #   Unit.new(2) * Unit.new(1) # => <Unit @scalar=2>
     #
@@ -93,7 +95,7 @@ module AUOM
     # @return [Unit]
     #
     # @example
-    #  
+    #
     #   # unitless
     #   Unit.new(2) / Unit.new(1) # => <Unit @scalar=2>
     #
@@ -111,11 +113,12 @@ module AUOM
 
       self * klass.new(
         1 / operand.scalar,
-        operand.denominators.dup,
-        operand.numerators.dup
+        operand.denominators,
+        operand.numerators
       )
     end
 
     alias_method :/, :divide
-  end
-end
+
+  end # Algebra
+end # AUOM

data/lib/auom/equalization.rb

@@ -1,6 +1,9 @@
+# encoding: UTF-8
+
 module AUOM
   # Equalization for auom units
   module Equalization
+
     # Check for equivalent value and try to convert
     #
     # @param [Object] other
@@ -28,5 +31,6 @@ module AUOM
     def ==(other)
       eql?(self.class.try_convert(other))
     end
-  end
-end
+
+  end # Equalization
+end # AUOM

data/lib/auom/inspection.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module AUOM
   # Inspection module for auom units
   module Inspection
@@ -8,7 +10,7 @@ module AUOM
     # @api private
     #
     def inspect
-      sprintf('<%s @scalar=%s%s>', self.class.name, pretty_scalar, pretty_unit)
+      sprintf('<%s @scalar=%s%s>', self.class, pretty_scalar, pretty_unit)
     end
 
   private
@@ -20,43 +22,26 @@ module AUOM
     # @api private
     #
     def pretty_scalar
-      unless fractions?
-        integer_value
+      if reminder?
+        sprintf('~%0.4f', scalar)
       else
-        '~%0.4f' % float_value
+        scalar.to_i
       end
     end
 
-    # Return float value
-    #
-    # @return [Float]
-    #
-    # @api private
-    #
-    def float_value
-      scalar.to_f
-    end
-
-    # Return integer value
-    #
-    # @return [Fixnum]
-    #
-    # @api private
-    #
-    def integer_value
-      scalar.to_i
-    end
-
     # Return prettyfied unit part
     #
     # @return [String]
+    #   if there is a prettifiable unit part
+    #
+    # @return [nil]
+    #   otherwise
     #
     # @api private
     #
     def pretty_unit
-      return '' if unitless?
+      return if unitless?
 
-      klass = self.class
       numerator   = Inspection.prettify_unit_part(@numerators)
       denominator = Inspection.prettify_unit_part(@denominators)
 
@@ -65,42 +50,21 @@ module AUOM
         return " #{numerator}"
       end
 
-
       sprintf(' %s/%s', numerator, denominator)
     end
 
-    # Check if scalar has fractions in decimal representation
+    # Test if scalar has and reminder in decimal representation
     #
     # @return [true]
-    #   if scalar has fractions in decimal representation
+    #   if there is a reminder
     #
     # @return [false]
-    #   if scalar NOT has fractions in decimal representation
-    #
-    # @api private
-    #
-    def fractions?
-      !(scalar_numerator % scalar_denominator).zero?
-    end
-
-    # Return scalar numerator
-    #
-    # @return [Fixnum]
+    #   otherwise
     #
     # @api private
     #
-    def scalar_numerator
-      scalar.numerator
-    end
-
-    # Return scalar denominator
-    #
-    # @return [Fixnum]
-    #
-    # @api private
-    #
-    def scalar_denominator
-      scalar.denominator
+    def reminder?
+      !(scalar % scalar.denominator).zero?
     end
 
     # Return prettified units
@@ -112,7 +76,7 @@ module AUOM
     # @api private
     #
     def self.prettify_unit_part(base)
-      counts(base).map { |unit,length| length > 1 ? "#{unit}^#{length}" : unit }.join('*')
+      counts(base).map { |unit, length| length > 1 ? "#{unit}^#{length}" : unit }.join('*')
     end
 
     # Return unit counts
@@ -124,8 +88,8 @@ module AUOM
     # @api private
     #
     def self.counts(base)
-      counts = base.each_with_object(Hash.new(0)) { |unit,hash| hash[unit] += 1 }
-      counts.sort do |left,right| 
+      counts = base.each_with_object(Hash.new(0)) { |unit, hash| hash[unit] += 1 }
+      counts.sort do |left, right|
         result = right.last <=> left.last
         if result == 0
           left.first <=> right.first
@@ -136,5 +100,6 @@ module AUOM
     end
 
     private_class_method :counts
-  end
-end
+
+  end # Inspection
+end # AUOM

data/lib/auom/relational.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 module AUOM
   # Mixin to add relational operators
   module Relational
@@ -86,5 +88,5 @@ module AUOM
       scalar.public_send(operation, other.scalar)
     end
 
-  end
-end
+  end # Relational
+end # AUOM

data/lib/auom/unit.rb

@@ -0,0 +1,324 @@
+# encoding: UTF-8
+
+module AUOM
+  # A scalar with units
+  class Unit
+    include Equalizer.new(:scalar, :numerators, :denominators)
+    include Algebra
+    include Equalization
+    include Inspection
+    include Relational
+
+    # Return scalar
+    #
+    # @example
+    #
+    #   include AUOM
+    #   m = Unit.new(1, :meter)
+    #   m.scalar # => Rational(1, 1)
+    #
+    # @return [Rational]
+    #
+    # @api public
+    #
+    attr_reader :scalar
+
+    # Return numerators
+    #
+    # @example
+    #
+    #   include AUOM
+    #   m = Unit.new(1, :meter)
+    #   m.numerators # => [:meter]
+    #
+    # @return [Rational]
+    #
+    # @api public
+    #
+    attr_reader :numerators
+
+    # Return denominators
+    #
+    # @example
+    #
+    #   include AUOM
+    #   m = Unit.new(1, :meter)
+    #   m.denoninators # => []
+    #
+    # @return [Rational]
+    #
+    # @api public
+    #
+    attr_reader :denominators
+
+    # Return unit descriptor
+    #
+    # @return [Array]
+    #
+    # @api public
+    #
+    # @example
+    #
+    #   u = Unit.new(1, [:meter, :meter], :euro)
+    #   u.unit # => [[:meter, :meter], [:euro]]
+    #
+    attr_reader :unit
+
+    # These constants can easily be changed
+    # by an application specific subclass that overrides
+    # AUOM::Unit.units with an own hash!
+    UNITS = {
+      item:      [1, :item],
+      liter:     [1, :liter],
+      pack:      [1, :pack],
+      can:       [1, :can],
+      kilogramm: [1, :kilogramm],
+      euro:      [1, :euro],
+      meter:     [1, :meter],
+      kilometer: [1000, :meter]
+    }.freeze
+
+    # Return buildin units symbols
+    #
+    # @return [Hash]
+    #
+    # @api private
+    #
+    def self.units
+      UNITS
+    end
+
+    # Check for unitless unit
+    #
+    # @return [true]
+    #   return true if unit is unitless
+    #
+    # @return [false]
+    #   return false if unit is NOT unitless
+    #
+    # @example
+    #
+    #   Unit.new(1).unitless?         # => true
+    #   Unit.new(1, :meter).unitless ? # => false
+    #
+    # @api public
+    #
+    def unitless?
+      numerators.empty? and denominators.empty?
+    end
+
+    # Test if units are the same
+    #
+    # @param [Unit] other
+    #
+    # @return [true]
+    #   if units are the same
+    #
+    # @return [false]
+    #   otehrwise
+    #
+    # @example
+    #
+    #   a = Unit.new(1)
+    #   b = Unit.new(1, :euro)
+    #   c = Unit.new(2, :euro)
+    #
+    #   a.same_unit?(b) # => false
+    #   b.same_unit?(c) # => true
+    #
+    # @api public
+    #
+    def same_unit?(other)
+      other.unit.eql?(unit)
+    end
+
+    # Instancitate a new unit
+    #
+    # @param [Rational] scalar
+    # @param [Enumerable] numerators
+    # @param [Enumerable] denominators
+    #
+    # @return [Unit]
+    #
+    # @example
+    #
+    #   # A unitless unit
+    #   u = Unit.new(1)
+    #   u.unitless? # => true
+    #   u.scalar    # => Rational(1, 1)
+    #
+    #   # A unitless unit from string
+    #   u = Unit.new('1.5')
+    #   u.unitless? # => true
+    #   u.scalar    # => Rational(3, 2)
+    #
+    #   # A simple unit
+    #   u = Unit.new(1, :meter)
+    #   u.unitless?  # => false
+    #   u.numerators # => [:meter]
+    #   u.scalar     # => Rational(1, 1)
+    #
+    #   # A complex unit
+    #   u = Unit.new(Rational(1, 3), :euro, :meter)
+    #   u.fractions? # => true
+    #   u.sclar      # => Rational(1, 3)
+    #   u.inspect    # => <AUOM::Unit @scalar=~0.3333 euro/meter>
+    #   u.unit       # => [[:euro], [:meter]]
+    #
+    # @api public
+    #
+    # TODO: Move defaults coercions etc to .build method
+    #
+    def self.new(scalar, numerators = nil, denominators = nil)
+      scalar = rational(scalar)
+
+      scalar, numerators   = resolve([*numerators], scalar, :*)
+      scalar, denominators = resolve([*denominators], scalar, :/)
+
+      # sorting on #to_s as Symbol#<=> is not present on 1.8.7
+      super(scalar, *[numerators, denominators].map { |base| base.sort_by(&:to_s) }).freeze
+    end
+
+    # Assert units are the same
+    #
+    # @param [Unit] other
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def assert_same_unit(other)
+      unless same_unit?(other)
+        raise ArgumentError, 'Incompatible units'
+      end
+
+      self
+    end
+
+    # Return converted operand or raise error
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #
+    # @raise [ArgumentError]
+    #   raises argument error in case operand cannot be converted
+    #
+    # @api private
+    #
+    def self.convert(operand)
+      converted = try_convert(operand)
+      unless converted
+        raise ArgumentError, "Cannot convert #{operand.inspect} to #{self}"
+      end
+      converted
+    end
+
+    # Return converted operand or nil
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #   return unit in case operand can be converted
+    #
+    # @return [nil]
+    #   return nil in case operand can NOT be converted
+    #
+    # @api private
+    #
+    def self.try_convert(operand)
+      case operand
+      when self
+        operand
+      when Fixnum, Rational
+        new(operand)
+      end
+    end
+
+  private
+
+    # Initialize unit
+    #
+    # @param [Rational] scalar
+    # @param [Enumerable] numerators
+    # @param [Enumerable] denominators
+    #
+    # @api private
+    #
+    def initialize(scalar, numerators, denominators)
+      @scalar = scalar
+
+      [numerators, denominators].permutation do |left, right|
+        left.delete_if { |item| right.delete_at(right.index(item) || right.length) }
+      end
+
+      @numerators = numerators.freeze
+      @denominators = denominators.freeze
+
+      @unit = [@numerators, @denominators].freeze
+      @scalar.freeze
+    end
+
+    # Return rational converted from value
+    #
+    # @param [Object] value
+    #
+    # @return [Rationa]
+    #
+    # @raise [ArgumentError]
+    #   raises argument error when cannot be converted to a rational
+    #
+    # @api private
+    #
+    def self.rational(value)
+      case value
+      when Rational
+        value
+      when Fixnum
+        Rational(value)
+      else
+        raise ArgumentError, "#{value.inspect} cannot be converted to rational"
+      end
+    end
+
+    private_class_method :rational
+
+    # Resolve unit component
+    #
+    # @param [Enumerable] components
+    # @param [Symbol] operation
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    def self.resolve(components, scalar, operation)
+      resolved = components.map do |component|
+        scale, component = lookup(component)
+        scalar = scalar.public_send(operation, scale)
+        component
+      end
+      [scalar, resolved]
+    end
+
+    private_class_method :resolve
+
+    # Return unit information
+    #
+    # @param [Symbol] value
+    #   the unit to search for
+    #
+    # @return [Array]
+    #
+    # @api private
+    #
+    def self.lookup(value)
+      units.fetch(value) do
+        raise ArgumentError, "Unknown unit #{value.inspect}"
+      end
+    end
+
+    private_class_method :lookup
+
+  end # Unit
+end # AUOM