unitwise-193 1.0.4

data/lib/unitwise/standard/scale.rb

@@ -0,0 +1,25 @@
+module Unitwise::Standard
+  class Scale
+    attr_accessor :nori
+
+    def initialize(nori)
+      @nori = nori
+    end
+
+    def value
+      nori.attributes["value"].to_f
+    end
+
+    def primary_unit_code
+      nori.attributes["Unit"]
+    end
+
+    def secondary_unit_code
+      nori.attributes["UNIT"]
+    end
+
+    def to_hash
+      {:value => value, :unit_code => primary_unit_code}
+    end
+  end
+end

data/lib/unitwise/term.rb

@@ -0,0 +1,142 @@
+module Unitwise
+  # A Term is the combination of an atom, prefix, factor and annotation.
+  # Not all properties have to be present. Examples: 'g', 'mm', 'mi2', '4[pi]',
+  # 'kJ{Electric Potential}'
+  class Term < Liner.new(:atom, :prefix, :factor, :exponent, :annotation)
+    include Compatible
+
+    # Set the atom.
+    # @param value [String, Atom] Either a string representing an Atom, or an
+    # Atom
+    # @api public
+    def atom=(value)
+      value.is_a?(Atom) ? super(value) : super(Atom.find(value.to_s))
+    end
+
+    # Set the prefix.
+    # @param value [String, Prefix] Either a string representing a Prefix, or
+    # a Prefix
+    def prefix=(value)
+      value.is_a?(Prefix) ? super(value) : super(Prefix.find(value.to_s))
+    end
+
+    # Is this term special?
+    # @return [true, false]
+    def special?
+      atom.special? rescue false
+    end
+
+    # Determine how far away a unit is from a base unit.
+    # @return [Integer]
+    # @api public
+    def depth
+      atom ? atom.depth + 1 : 0
+    end
+    memoize :depth
+
+    # Determine if this is the last term in the scale chain
+    # @return [true, false]
+    # @api public
+    def terminal?
+      depth <= 3
+    end
+
+    # The multiplication factor for this term. The default value is 1.
+    # @return [Numeric]
+    # @api public
+    def factor
+      super || 1
+    end
+
+    # The exponent for this term. The default value is 1.
+    # @return [Numeric]
+    # @api public
+    def exponent
+      super || 1
+    end
+
+    # The unitless scalar value for this term.
+    # @param magnitude [Numeric] The magnitude to calculate the scalar for.
+    # @return [Numeric] The unitless linear scalar value.
+    # @api public
+    def scalar(magnitude = 1.0)
+      calculate(atom ? atom.scalar(magnitude) : magnitude)
+    end
+
+    # Calculate the magnitude for this term
+    # @param scalar [Numeric] The scalar for which you want the magnitude
+    # @return [Numeric] The magnitude on this scale.
+    # @api public
+    def magnitude(scalar = scalar())
+      calculate(atom ? atom.magnitude(scalar) : 1.0)
+    end
+
+    # The base units this term is derived from
+    # @return [Array] An array of Unitwise::Term
+    # @api public
+    def root_terms
+      if terminal?
+        [self]
+      else
+        atom.scale.root_terms.map do |t|
+          self.class.new(:atom => t.atom, :exponent => t.exponent * exponent)
+        end
+      end
+    end
+    memoize :root_terms
+
+    # Term multiplication. Multiply by a Unit, another Term, or a Numeric.
+    # params other [Unit, Term, Numeric]
+    # @return [Term]
+    def *(other)
+      operate('*', other) ||
+        fail(TypeError, "Can't multiply #{ self } by #{ other }.")
+    end
+
+    # Term division. Divide by a Unit, another Term, or a Numeric.
+    # params other [Unit, Term, Numeric]
+    # @return [Term]
+    def /(other)
+      operate('/', other) ||
+        fail(TypeError, "Can't divide #{ self } by #{ other }.")
+    end
+
+
+    # Term exponentiation. Raise a term to a numeric power.
+    # params other [Numeric]
+    # @return [Term]
+    def **(other)
+      if other.is_a?(Numeric)
+        self.class.new(to_hash.merge(:exponent => exponent * other))
+      else
+        fail TypeError, "Can't raise #{self} to #{other}."
+      end
+    end
+
+    def to_s(mode = :primary_code)
+      [(factor if factor != 1), (prefix.send(mode) if prefix),
+        (atom.send(mode) if atom), (exponent if exponent != 1)].compact.join('')
+    end
+
+    private
+
+    # @api private
+    def calculate(value)
+      (factor * (prefix ? prefix.scalar : 1) * value) ** exponent
+    end
+
+    # Multiply or divide a term
+    # @api private
+    def operate(operator, other)
+      exp = operator == '/' ? -1 : 1
+      if other.respond_to?(:terms)
+        Unit.new(other.terms.map { |t| t ** exp } << self)
+      elsif other.respond_to?(:atom)
+        Unit.new([self, other ** exp])
+      elsif other.is_a?(Numeric)
+        self.class.new(to_hash.merge(:factor => factor.send(operator, other)))
+      end
+    end
+
+  end
+end

data/lib/unitwise/unit.rb

@@ -0,0 +1,181 @@
+module Unitwise
+  # A Unit is essentially a collection of Unitwise::Term. Terms can be combined
+  # through multiplication or division to create a unit. A unit does not have
+  # a magnitude, but it does have a scale.
+  class Unit
+    liner :expression, :terms
+    include Compatible
+
+    # Create a new unit. You can send an expression or a collection of terms
+    # @param input [String, Unit, [Term]] A string expression, a unit, or a
+    # collection of tems.
+    # @api public
+    def initialize(input)
+      case input
+      when Compatible
+        @expression = input.expression
+      when String, Symbol
+        @expression = input.to_s
+      else
+        @terms = input
+      end
+    end
+
+    # The collection of terms used by this unit.
+    # @return [Array]
+    # @api public
+    def terms
+      unless frozen?
+        unless @terms
+          decomposer = Expression.decompose(@expression)
+          @mode  = decomposer.mode
+          @terms = decomposer.terms
+        end
+        freeze
+      end
+      @terms
+    end
+
+    # Build a string representation of this unit by it's terms.
+    # @param mode [Symbol] The mode to use to stringify the atoms
+    # (:primary_code, :names, :secondary_code).
+    # @return [String]
+    # @api public
+    def expression(mode=nil)
+      if @expression && (mode.nil? || mode == self.mode)
+        @expression
+      else
+        Expression.compose(terms, mode || self.mode)
+      end
+    end
+
+    # The collection of atoms that compose this unit. Essentially delegated to
+    # terms.
+    # @return [Array]
+    # @api public
+    def atoms
+      terms.map(&:atom)
+    end
+    memoize :atoms
+
+    # Is this unit special (meaning on a non-linear scale)?
+    # @return [true, false]
+    # @api public
+    def special?
+      terms.count == 1 && terms.all?(&:special?)
+    end
+    memoize :special?
+
+    # A number representing this unit's distance from it's deepest terminal atom.
+    # @return [Integer]
+    # @api public
+    def depth
+      terms.map(&:depth).max + 1
+    end
+    memoize :depth
+
+    # A collection of the deepest terms, or essential composition of the unit.
+    # @return [Array]
+    # @api public
+    def root_terms
+      terms.map(&:root_terms).flatten
+    end
+    memoize :root_terms
+
+    # Get a scalar value for this unit.
+    # @param magnitude [Numeric] An optional magnitude on this unit's scale.
+    # @return [Numeric] A scalar value on a linear scale
+    # @api public
+    def scalar(magnitude = 1.0)
+      terms.reduce(1.0) do |prod, term|
+        prod * term.scalar(magnitude)
+      end
+    end
+
+    # Get a magnitude for this unit based on a linear scale value.
+    # Should only be used by units with special atoms in it's hierarchy.
+    # @param scalar [Numeric] A linear scalar value
+    # @return [Numeric] The equivalent magnitude on this scale
+    # @api public
+    def magnitude(scalar = scalar())
+      terms.reduce(1.0) do |prod, term|
+        prod * term.magnitude(scalar)
+      end
+    end
+
+    # Multiply this unit by another unit, term, or number.
+    # @param other [Unitwise::Unit, Unitwise::Term, Numeric]
+    # @return [Unitwise::Unit]
+    # @api public
+    def *(other)
+      operate('*', other) ||
+        fail(TypeError, "Can't multiply #{ self } by #{ other }.")
+    end
+
+    # Divide this unit by another unit,term, or number.
+    # @param other [Unitwise::Unit, Unitwise::Term, Numeric]
+    # @return [Unitwise::Unit]
+    # @api public
+    def /(other)
+      operate('/', other) ||
+        fail(TypeError, "Can't divide #{ self } by #{ other }.")
+    end
+
+
+    # Raise this unit to a numeric power.
+    # @param other [Numeric]
+    # @return [Unitwise::Unit]
+    # @api public
+    def **(other)
+      if other.is_a?(Numeric)
+        self.class.new(terms.map { |t| t ** other })
+      else
+        fail TypeError, "Can't raise #{self} to #{other}."
+      end
+    end
+
+    # A string representation of this unit.
+    # @param mode [:symbol] The mode used to represent the unit
+    # (:primary_code, :names, :secondary_code)
+    # @return [String]
+    # @api public
+    def to_s(mode = nil)
+      expression(mode)
+    end
+
+    # A collection of the possible string representations of this unit.
+    # Primarily used by Unitwise::Search.
+    # @return [Array]
+    # @api public
+    def aliases
+      [:names, :primary_code, :secondary_code, :symbol].map do |mode|
+        to_s(mode)
+      end.uniq
+    end
+    memoize :aliases
+
+    # The default mode to use for inspecting and printing.
+    # @return [Symbol]
+    # @api semipublic
+    def mode
+      terms
+      @mode || :primary_code
+    end
+
+    private
+
+    # Multiply or divide units
+    # @api private
+    def operate(operator, other)
+      exp = operator == '/' ? -1 : 1
+      if other.respond_to?(:terms)
+        self.class.new(terms + other.terms.map { |t| t ** exp })
+      elsif other.respond_to?(:atom)
+        self.class.new(terms << other ** exp)
+      elsif other.is_a?(Numeric)
+        self.class.new(terms.map { |t| t.send(operator, other) })
+      end
+    end
+
+  end
+end

data/lib/unitwise/version.rb

@@ -0,0 +1,3 @@
+module Unitwise
+  VERSION = '1.0.4'
+end

data/test/support/scale_tests.rb

@@ -0,0 +1,117 @@
+# Shared examples for Unitwise::Scale and Unitwise::Measurement
+module ScaleTests
+  def self.included(base)
+    base.class_eval do
+      subject { described_class.new(4, "J") }
+
+      let(:mph)  { described_class.new(60, '[mi_i]/h') }
+      let(:kmh)  { described_class.new(100, 'km/h') }
+      let(:mile) { described_class.new(3, '[mi_i]') }
+      let(:hpm)  { described_class.new(6, 'h/[mi_i]') }
+      let(:cui)  { described_class.new(12, "[in_i]3") }
+      let(:cel)  { described_class.new(22, 'Cel') }
+      let(:k)    { described_class.new(373.15, 'K') }
+      let(:f)    { described_class.new(98.6, '[degF]')}
+      let(:r)    { described_class.new(491.67, '[degR]') }
+
+      describe "#new" do
+        it "must set attributes" do
+          subject.value.must_equal(4)
+          subject.unit.to_s.must_equal('J')
+        end
+      end
+
+      describe "#unit" do
+        it "must be a unit" do
+          subject.must_respond_to(:unit)
+          subject.unit.must_be_instance_of(Unitwise::Unit)
+        end
+      end
+
+      describe "#root_terms" do
+        it "must be a collection of terms" do
+          subject.must_respond_to(:root_terms)
+          subject.root_terms.must_be_kind_of Enumerable
+          subject.root_terms.first.must_be_instance_of(Unitwise::Term)
+        end
+      end
+
+      describe "#terms" do
+        it "must return an array of terms" do
+          subject.terms.must_be_kind_of(Enumerable)
+          subject.terms.first.must_be_kind_of(Unitwise::Term)
+        end
+      end
+
+      describe "#atoms" do
+        it "must return an array of atoms" do
+          subject.atoms.must_be_kind_of(Enumerable)
+          subject.atoms.first.must_be_kind_of(Unitwise::Atom)
+        end
+      end
+
+      describe "#scalar" do
+        it "must return value relative to terminal atoms" do
+          subject.scalar.must_equal 4000
+          mph.scalar.must_almost_equal 26.8224
+          cel.scalar.must_equal 295.15
+        end
+      end
+
+      describe "#magnitude" do
+        it "must return the magnitude" do
+          mph.magnitude.must_equal(60)
+          cel.magnitude.must_equal(22)
+        end
+      end
+
+      describe "#special?" do
+        it "must return true when unit is special, false otherwise" do
+          subject.special?.must_equal false
+          cel.special?.must_equal true
+        end
+      end
+
+      describe "#depth" do
+        it "must return a number indicating how far down the rabbit hole goes" do
+          subject.depth.must_equal 11
+          k.depth.must_equal 3
+        end
+      end
+
+      describe "#frozen?" do
+        it "must be frozen" do
+          subject.frozen?.must_equal true
+        end
+      end
+
+      describe "#simplified_value" do
+        describe "when the value is equivalent to an Integer" do
+          it "should convert from a Rational" do
+            result = described_class.new(Rational(20,2), 'foot').simplified_value
+            result.must_equal 10
+            result.must_be_kind_of(Integer)
+          end
+          it "should convert from a Float" do
+            result = described_class.new(4.0, 'foot').simplified_value
+            result.must_equal 4
+            result.must_be_kind_of(Integer)
+          end
+          it "should convert from a BigDecimal" do
+            result = described_class.new(BigDecimal("4.5"), "volt").simplified_value
+            result.must_equal 4.5
+            result.must_be_kind_of(Float)
+          end
+        end
+        describe "when the value is equivalent to a Float" do
+          it "should convert from a BigDecimal" do
+            result = described_class.new(BigDecimal("1.5"), 'foot').simplified_value
+            result.must_equal 1.5
+            result.must_be_kind_of(Float)
+          end
+        end
+      end
+
+    end
+  end
+end