auom 0.0.3

data/lib/auom/algebra.rb

@@ -0,0 +1,129 @@
+module AUOM
+  # The AUOM algebra
+  module Algebra
+    # Return addition result
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #
+    # @example
+    #  
+    #   # unitless
+    #   Unit.new(1) + Unit.new(2) # => <Unit @scalar=3>
+    #
+    #   # with unit
+    #   Unit.new(1,:meter) + Unit.new(2,:meter) # => <AUOM::Unit @scalar=3 meter>
+    #
+    #   # incompatible unit
+    #   Unit.new(1,:meter) + Unit.new(2,:euro) # raises ArgumentError!
+    #
+    # @api public
+    #
+    def add(operand)
+      klass = self.class
+      operand = klass.convert(operand)
+
+      unless operand.unit == unit
+        raise ArgumentError, 'Incompatible units for substraction or addition'
+      end
+
+      klass.new(
+        operand.scalar + scalar,
+        numerators.dup,
+        denominators.dup
+      )
+    end
+
+    alias :+ :add
+
+    # Return substraction result
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #
+    # @example
+    #  
+    #   # unitless
+    #   Unit.new(2) - Unit.new(1) # => <Unit @scalar=1>
+    #
+    #   # with unit
+    #   Unit.new(2,:meter) - Unit.new(1,:meter) # => <AUOM::Unit @scalar=1 meter>
+    #
+    #   # incompatible unit
+    #   Unit.new(2,:meter) - Unit.new(1,:euro) # raises ArgumentError!
+    #
+    # @api public
+    #
+    def substract(operand)
+      self.add(self.class.convert(operand) * -1)
+    end
+
+    alias :- :substract
+
+    # Return multiplication result
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #
+    # @example
+    #  
+    #   # unitless
+    #   Unit.new(2) * Unit.new(1) # => <Unit @scalar=2>
+    #
+    #   # with unit
+    #   Unit.new(2, :meter) * Unit.new(1, :meter) # => <AUOM::Unit @scalar=2 meter^2>
+    #
+    #   # differend units
+    #   Unit.new(2, :meter) * Unit.new(1, :euro) # => <AUOM::Unit @scalar=2 meter*euro>
+    #
+    # @api public
+    #
+    def multiply(operand)
+      klass = self.class
+      operand = klass.convert(operand)
+
+      klass.new(
+        operand.scalar * scalar,
+        numerators + operand.numerators,
+        denominators + operand.denominators
+      )
+    end
+
+    alias :* :multiply
+
+    # Return division result
+    #
+    # @param [Object] operand
+    #
+    # @return [Unit]
+    #
+    # @example
+    #  
+    #   # unitless
+    #   Unit.new(2) / Unit.new(1) # => <Unit @scalar=2>
+    #
+    #   # with unit
+    #   Unit.new(2, :meter) / Unit.new(1, :meter) # => <AUOM::Unit @scalar=2>
+    #
+    #   # differend units
+    #   Unit.new(2, :meter) / Unit.new(1, :euro) # => <AUOM::Unit @scalar=2 meter/euro>
+    #
+    # @api public
+    #
+    def divide(operand)
+      klass = self.class
+      operand = klass.convert(operand)
+
+      self * klass.new(
+        1 / operand.scalar,
+        operand.denominators.dup,
+        operand.numerators.dup
+      )
+    end
+
+    alias :/ :divide
+  end
+end

data/lib/auom/equalization.rb

@@ -0,0 +1,90 @@
+module AUOM
+  # Equalization for auom units
+  module Equalization
+    # Check for equivalent value and try to convert
+    #
+    # @param [Object] other
+    #
+    # @return [true]
+    #   return true if is other is a unit and scalar and unit is the same after try of conversion.
+    #
+    # @return [false]
+    #   return false otherwise
+    #
+    # @example
+    #
+    #   u = Unit.new(1, :meter)
+    #   u == u                   # => true
+    #   u == 1                   # => false
+    #   u == Unit.new(1, :meter) # => true
+    #
+    #   u = Unit.new(1)
+    #   u == 1                   # => true
+    #   u == Rational(1)         # => true
+    #   u == 1.0                 # => false
+    #
+    # @api public
+    #
+    def ==(other)
+      eql?(self.class.try_convert(other))
+    end
+
+    # Check for equivalent value and not try to convert
+    #
+    # @param [Object] other
+    #
+    # @example
+    #
+    #   u = Unit.new(1, :meter)
+    #   u == u                   # => true
+    #   u == 1                   # => false
+    #   u == Unit.new(1, :meter) # => true
+    #
+    #   u = Unit.new(1)
+    #   u == 1                   # => false
+    #   u == Rational(1)         # => false
+    #   u == 1.0                 # => false
+    #
+    # @return [true]
+    #   return true if is other is a unit and scalar and unit is the same
+    #
+    # @return [false]
+    #   return false otherwise
+    #
+    # @api public
+    #
+    def eql?(other)
+      (instance_of?(other.class) && cmp?(other))
+    end
+
+    # Return hash value
+    #
+    # @return [Fixnum]
+    #
+    # @example
+    #
+    #   Unit.new(1, :meter).to_hash # => 012345678
+    #
+    # @api public
+    #
+    def hash
+      scalar.hash ^ unit.hash
+    end
+
+  private
+
+    # Compare with other unit instance 
+    #
+    # @return [true]
+    #   returns true if unit and scalar is aequivalent
+    # 
+    # @return [false]
+    #   return false otherwise
+    #
+    # @api private
+    #
+    def cmp?(other)
+      scalar.eql?(other.scalar) && unit.eql?(other.unit)
+    end
+  end
+end

data/lib/auom/inspection.rb

@@ -0,0 +1,103 @@
+module AUOM
+  # Inspection module for auom units
+  module Inspection
+    # Return inspectable representation
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def inspect
+      sprintf('<%s @scalar=%s%s>', self.class.name, pretty_scalar, pretty_unit)
+    end
+
+  private
+
+    # Return prettyfied scalar
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def pretty_scalar
+      scalar = self.scalar
+
+      unless fractions?
+        scalar.to_i
+      else
+        '~%0.4f' % scalar.to_f
+      end
+    end
+
+    # Return prettyfied unit part
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def pretty_unit
+      return '' if unitless?
+
+      klass = self.class
+      numerator   = Inspection.prettify_unit_part(@numerators)
+      denominator = Inspection.prettify_unit_part(@denominators)
+
+      numerator   = '1' if numerator.empty?
+      if denominator.empty?
+        return " #{numerator}"
+      end
+
+
+      sprintf(' %s/%s', numerator, denominator)
+    end
+
+    # Check if scalar has fractions in decimal representation
+    #
+    # @return [true]
+    #   if scalar has fractions in decimal representation
+    #
+    # @return [false]
+    #   if scalar NOT has fractions in decimal representation
+    #
+    # @api private
+    #
+    def fractions?
+      scalar = self.scalar
+      !(scalar.numerator % scalar.denominator).zero?
+    end
+
+    # Return prettified units
+    #
+    # @param [Array] base
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def self.prettify_unit_part(base)
+      counts(base).map { |unit,length| length > 1 ? "#{unit}^#{length}" : unit }.join('*')
+    end
+
+    # Return unit counts
+    #
+    # @param [Array] base
+    #
+    # @return [Hash]
+    #
+    # @api private
+    #
+    def self.counts(base)
+      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
+        else
+          result
+        end
+      end
+    end
+
+    private_class_method :counts
+  end
+end

data/lib/auom/version.rb

@@ -0,0 +1,3 @@
+module AUOM
+  VERSION = '0.0.3'.freeze
+end

data/spec/rcov.opts

@@ -0,0 +1,7 @@
+--exclude-only "spec/,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary
+--failure-threshold 100

data/spec/shared/command_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'a command method' do
+  it 'returns self' do
+    should equal(object)
+  end
+end

data/spec/shared/each_method_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples_for 'an #each method' do
+  it_should_behave_like 'a command method'
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    it 'yields the expected values' do
+      subject.to_a.should eql(object.to_a)
+    end
+  end
+end

data/spec/shared/hash_method_behavior.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+shared_examples_for 'a hash method' do
+  it_should_behave_like 'an idempotent method'
+
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    instance_eval(&specification)
+  end
+
+  it 'memoizes the hash code' do
+    subject.should eql(object.memoized(:hash))
+  end
+end

data/spec/shared/idempotent_method_behavior.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+shared_examples_for 'an idempotent method' do
+  it 'is idempotent' do
+    should equal(instance_eval(&self.class.subject))
+  end
+end

data/spec/shared/incompatible_operation_behavior.rb

@@ -0,0 +1,5 @@
+shared_examples_for 'an incompatible operation' do
+  it 'should raise ArgumentError' do
+    expect { subject }.to raise_error(ArgumentError,'Incompatible units for substraction or addition')
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/shared/operation_behavior.rb

@@ -0,0 +1,12 @@
+shared_examples_for 'an operation' do
+  it 'returns a new object' do
+    object.should_not equal(subject)
+  end
+
+  it 'is idempotent on equivalency' do
+    should eql(instance_eval(&self.class.subject))
+  end
+ 
+  its(:scalar) { should be_kind_of(::Rational) }
+end
+

data/spec/shared/sunits_shared.rb

@@ -0,0 +1,6 @@
+shared_examples_for 'unitless unit' do
+  its(:numerators)   { should == [] }
+  its(:denominators) { should == [] }
+  its(:unit) { should == [[],[]] }
+  it { should be_unitless }
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--loadby random
+--format profile

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+begin
+  require 'rspec'  # try for RSpec 2
+rescue LoadError
+  require 'spec'   # try for RSpec 1
+  RSpec = Spec::Runner
+end
+
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+Dir.glob('spec/examples/**/*.rb').each { |file| require File.expand_path(file) }
+Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each { |f| require f }
+
+require 'auom'