unitwise 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b743603a818807533ed423c0317ac33b05976d78
-  data.tar.gz: ac6d5fb45058fecc3575e771f2e605cbc3e4afe0
+  metadata.gz: a382c394857814457fe921d7556aa91211d9a752
+  data.tar.gz: 24ecd6c8f3fcd11a281cc0fb860462f2b9766b4c
 SHA512:
-  metadata.gz: 39a648b7693240696ff80404452c1b19bd67569dea17a394d84a4b9cf69e4874f3645ca7e83bb4149ce0304a973adfb9f55ed110a9833036e3c418ecaf0b3e97
-  data.tar.gz: ba6432d868b98e2d0c93d1a821b400a54e9e837e09ee8a13ca41986ccf61a9e1a1586186f04e7cfb40297c6b07ae923109ca6593b634abad2057060148c15af0
+  metadata.gz: a23988ac0f39b46d1f325bb4766e13c3ce025eaee602f5946426e4258b07b9b32f4752298ce78160f049c6be05b7699cfbefaf63a451763559de5fecf2336cbc
+  data.tar.gz: 75f123f3fd5195239f728efc037ce2038dece84b647df8234fca6391b4a9280f0e6d6fad614502737daf62976795253c099fa03a4a5c459837f8b92feaedfaa1

data/README.md

@@ -38,9 +38,8 @@ require 'unitwise/ext'
 
 ### Conversion
 
-Obviously, Unitwise handles simple unit conversion. You can convert to any
-compatible unit (Unitwise won't let you convert say inches to pounds) with the 
-`convert(unit)` method.
+Unitwise is able to convert any unit within the UCUM spec to any other
+compatible unit.
 
 ```ruby
 distance = Unitwise(5, 'kilometer') 
@@ -50,7 +49,8 @@ distance.convert('mile')
 # => <Unitwise::Measurement 3.106849747474748 mile>
 ```
 
-The prettier version of `convert(unit)` is just calling the unit name method:
+The prettier version of `convert(unit)` is just calling the unit as a method
+name:
 
 ```ruby
 distance = 26.2.mile
@@ -70,8 +70,8 @@ It also has the ability to compare measurements with the same or different units
 1.meter > 1.yard # => true
 ```
 
-Again, you have to compare compatible units. Dissimilar units will fail. 
-For example, comparing two temperatures will work, comparing a mass to a length would fail.
+Again, you have to compare compatible units. For example, comparing two 
+temperatures will work, comparing a mass to a length would fail.
 
 ### SI abbreviations
 
@@ -115,7 +115,7 @@ You can multiply or divide measurements and numbers.
 
 ```ruby
 110.volt * 2
-=> <Unitwise::Measurement 220 volt>
+# => <Unitwise::Measurement 220 volt>
 ```
 
 You can multiply or divide measurements with measurements. Here is a fun example
@@ -162,14 +162,23 @@ and foot:
 3.convert('[in_br]') == 3.convert('[in_i]') # => false
 ```
 
-### List of available units
+### Available Units
 
-- You can get the official list from the UCUM website in XML format.
-  [unitsofmeasure.org/ucum-essence.xml](http://unitsofmeasure.org/ucum-essence.xml)
+If you are looking for a particular unit (or 'atom' in the UCUM spec), chances 
+are that it is in here. There is a rudimentary search function for both
+`Unitwise::Atom` and `Unitwise::Prefix`.
 
-- Unitwise occasionally converts the above XML into YAML for use by this
-  library.
-  [github.com/joshwlewis/unitwise/tree/master/data](//github.com/joshwlewis/unitwise/tree/master/data)
+```ruby
+Unitwise::Atom.search('fathom')
+# => [ ... ]
+Unitwise::Prefix.search('milli')
+# => [ ... ]
+```
+
+You can also get the official list from the UCUM website in XML format at 
+[unitsofmeasure.org/ucum-essence.xml](http://unitsofmeasure.org/ucum-essence.xml) 
+or a YAML version within this repo 
+[github.com/joshwlewis/unitwise/tree/master/data](//github.com/joshwlewis/unitwise/tree/master/data).
 
 
 ## Installation

data/lib/unitwise.rb

@@ -1,3 +1,5 @@
+require 'liner'
+
 require "unitwise/version"
 require 'unitwise/base'
 require 'unitwise/expression'
@@ -9,24 +11,37 @@ require 'unitwise/atom'
 require 'unitwise/prefix'
 require 'unitwise/term'
 require 'unitwise/unit'
-require 'unitwise/function'
 require 'unitwise/errors'
 
+# Unitwise is a library for performing mathematical operations and conversions 
+# on all units defined by the [Unified Code for Units of Measure(UCUM).
 module Unitwise
+  # The system path for the installed gem
+  # @api private
   def self.path
     @path ||= File.dirname(File.dirname(__FILE__))
   end
 
+  # A helper to get the location of a yaml data file
+  # @api private
   def self.data_file(key)
     File.join path, "data", "#{key}.yaml"
   end
 end
 
-def Unitwise(first_arg, last_arg=nil)
-  if last_arg
-    Unitwise::Measurement.new(first_arg, last_arg)
+# Measurement initializer shorthand. Use this to instantiate new measurements.
+# @param first [Numeric, String] Either a numeric value or a unit expression
+# @param last [String, Nil] Either a unit expression, or nil
+# @return [Unitwise::Measurement]
+# @example
+#   Unitwise(20, 'mile') # => #<Unitwise::Measurement 20 mile>
+#   Unitwise('km') # => #<Unitwise::Measurement 1 km>
+# @api public
+def Unitwise(first, last=nil)
+  if last
+    Unitwise::Measurement.new(first, last)
   else
-    Unitwise::Measurement.new(1, first_arg)
+    Unitwise::Measurement.new(1, first)
   end
 end
 

data/lib/unitwise/atom.rb

@@ -1,56 +1,92 @@
 module Unitwise
+  # Atoms are the most basic elements in Unitwise. They are named coded and
+  # scaled units without prefixes, multipliers, exponents, etc. Examples are 
+  # 'meter', 'hour', 'pound force'.
   class Atom < Base
-    attr_accessor :classification, :property, :metric, :special, :arbitrary
-    attr_writer :dim
+    liner :classification, :property, :metric, :special, :arbitrary, :dim
 
     include Unitwise::Composable
 
     class << self
+      # Array of hashes representing atom properties.
+      # @api private
       def data
         @data ||= data_files.reduce([]){|m,f| m += YAML::load File.open(f)}
       end
 
+      # Data files containing atom data
+      # @api private
       def data_files
         %w(base_unit derived_unit).map{|type| Unitwise.data_file type}
       end
     end
 
+    # Determine if an atom is base level. All atoms that are not base are
+    # defined directly or indirectly in reference to a base atom.
+    # @return [true, false]
+    # @api public
     def base?
       scale.nil? && !@dim.nil?
     end
 
+    # Determine if an atom is derived. Derived atoms are defined with respect 
+    # to other atoms.
+    # @return [true, false]
+    # @api public
     def derived?
       !base?
     end
 
+    # Determine if an atom is metric. Metric atoms can be combined with metric
+    # prefixes.
+    # @return [true, false]
+    # @api public
     def metric?
       base? ? true : !!metric
     end
 
-    def nonmetric?
-      !metric?
-    end
-
+    # Determine if a unit is special. Special atoms are not defined on a
+    # traditional ratio scale.
+    # @return [true, false]
+    # @api public
     def special?
       !!special
     end
 
+    # Determine if a unit is arbitrary. Arbitrary atoms are not of any specific 
+    # dimension and have no general meaning, therefore cannot be compared with
+    # any other unit.
+    # @return [true, false]
+    # @api public
     def arbitrary?
       !!arbitrary
     end
 
+    # Determine how far away a unit is from a base unit.
+    # @return [Integer]
+    # @api public
     def depth
       base? ? 0 : scale.depth + 1
     end
 
+    # Determine if this is the last atom in the scale chain
+    # @return [true, false]
+    # @api public
     def terminal?
       depth <= 3
     end
 
+    # A representation of an atoms composition. Used to determine if two
+    # different atoms are compatible.
+    # @return [String]
+    # @api public
     def dim
       terminal? ? @dim || property : composition_string
     end
 
+    # Set the atom's scale. It can be set as a Scale or a Functional
+    # @return [Unitwise::Functional, Unitwise::Scale]
+    # @api public
     def scale=(attrs)
       @scale = if attrs[:function_code]
         Functional.new(attrs[:value], attrs[:unit_code], attrs[:function_code])
@@ -59,25 +95,29 @@ module Unitwise
       end
     end
 
+    # Get a numeric value that can be used to with other atoms to compare with 
+    # or operate on. Base units have a scalar of 1.
+    # @return [Numeric]
+    # @api public
     def scalar
       base? ? 1 : scale.scalar
     end
 
-    def functional(x=scalar, direction=1)
-      scale.functional(x, direction)
+    # Get a functional value that can be used with other atoms to compare with
+    # or operate on.
+    # @param x [Numeric] The number to convert to or convert from
+    # @param forward [true, false] Convert to or convert from
+    # @return [Numeric] The converted value
+    def functional(x=scalar, forward=true)
+      scale.functional(x, forward)
     end
 
+    # An atom may have a complex scale with several base atoms at various
+    # depths. This method returns all of this atoms base level terms.
+    # @return [Array] An array containing base Unitwise::Term
     def root_terms
       base? ? [Term.new(atom: self)] : scale.root_terms
     end
 
-    def to_s
-      "#{primary_code} (#{names.join('|')})"
-    end
-
-    def inspect
-      "<#{self.class} #{to_s}>"
-    end
-
   end
 end

data/lib/unitwise/base.rb

@@ -1,8 +1,7 @@
 require 'yaml'
 module Unitwise
   class Base
-    attr_accessor :primary_code, :secondary_code, :symbol
-    attr_reader :names, :scale
+    liner :names, :primary_code, :secondary_code, :symbol, :scale
 
     def self.all
       @all ||= data.map{|d| self.new d }
@@ -27,9 +26,9 @@ module Unitwise
       end
     end
 
-    def initialize(attrs)
-      attrs.each do |k, v|
-        public_send :"#{k}=", v
+    def self.search(term)
+      self.all.select do |i|
+        i.search_strings.any? { |string| string =~ /#{term}/i }
       end
     end
 
@@ -43,5 +42,9 @@ module Unitwise
       end
     end
 
+    def search_strings
+      [primary_code, secondary_code, names, slugs, symbol].flatten.compact
+    end
+
   end
 end

data/lib/unitwise/composable.rb

@@ -1,30 +1,49 @@
 module Unitwise
+  # Composable provides methods for determing the composition of unit, term, or 
+  # measurement. This is used to establish compatibility between units, terms,
+  # or measurements.
   module Composable
 
+    # @api private
     def self.included(base)
       base.send :include, Comparable
     end
 
+    # A representation of a unit based on the atoms it's derived from.
+    # @return [SignedMultiset]
+    # @api public
     def composition
       root_terms.reduce(SignedMultiset.new) do |s, t|
         s.increment(t.atom.dim, t.exponent) if t.atom; s
       end
     end
 
+    # Define a default #dim for included classes.
+    # @return [String]
+    # @api public
     def dim
       composition_string
     end
 
+    # A string representation of a unit based on the atoms it's derived from
+    # @return [String]
+    # @api public
     def composition_string
       composition.sort.map do |k,v|
         v == 1 ? k.to_s : "#{k}#{v}"
       end.join('.')
     end
 
+    # Determine if this instance is similar to or compatible with other
+    # @return [true false]
+    # @api public
     def similar_to?(other)
       self.composition == other.composition
     end
 
+    # Compare whether the instance is greater, less than or equal to other.
+    # @return [-1 0 1]
+    # @api public
     def <=>(other)
       if other.respond_to?(:composition) && similar_to?(other)
         scalar <=> other.scalar

data/lib/unitwise/expression/composer.rb

@@ -2,14 +2,8 @@ module Unitwise
   module Expression
     class Composer
       attr_reader :terms
-      def initialize(input)
-        if input.respond_to?(:terms)
-          @terms = input.terms
-        elsif input.respond_to?(:each)
-          @terms = input
-        else
-          @terms = Expression.decompose(input.to_s)
-        end
+      def initialize(terms)
+        @terms = terms
       end
 
       def set

data/lib/unitwise/expression/decomposer.rb

@@ -2,8 +2,10 @@ module Unitwise
   module Expression
     class Decomposer
 
-      PARSERS = [:primary_code, :secondary_code, :names, :slugs, :symbol].map do |t|
-        Parser.new(t)
+      METHODS = [:primary_code, :secondary_code, :names, :slugs, :symbol]
+
+      PARSERS = METHODS.reduce({}) do |hash, method|
+        hash[method] = Parser.new(method); hash
       end
 
       TRANSFORMER = Transformer.new
@@ -17,23 +19,22 @@ module Unitwise
         end
       end
 
-      def parse
-        PARSERS.reduce(nil) do |m, p|
-          if prs = p.parse(expression) rescue next
-            return prs
+      def transform
+        PARSERS.reduce(nil) do |foo, (method, parser)|
+          if parsed = parser.parse(expression) rescue next
+            return TRANSFORMER.apply(parsed, key: method)
           end
         end
       end
 
-      def transform
-        @transform ||= TRANSFORMER.apply(parse)
-      end
-
       def terms
-        if transform.respond_to?(:terms)
-          transform.terms
-        else
-          Array(transform)
+        @terms ||= begin
+          transformation = transform
+          if transformation.respond_to?(:terms)
+            transformation.terms
+          else
+            Array(transformation)
+          end
         end
       end
 

data/lib/unitwise/expression/parser.rb

@@ -30,18 +30,18 @@ module Unitwise
 
       rule (:number) { fixnum | integer }
 
-      rule (:exponent) { number.as(:exponent) }
+      rule (:exponent) { integer.as(:exponent) }
 
       rule (:factor) { number.as(:factor) }
 
       rule (:operator) { (str('.') | str('/')).as(:operator) }
 
       rule (:term) do
-        ((simpleton | factor) >> exponent.maybe >> annotation.maybe).as(:term)
+        ((factor >> simpleton | simpleton | factor) >> exponent.maybe >> annotation.maybe).as(:term)
       end
 
       rule (:group) do
-        (str('(') >> expression.as(:nested) >> str(')') >> exponent.maybe).as(:group)
+        (factor.maybe >> str('(') >> expression.as(:nested) >> str(')') >> exponent.maybe).as(:group)
       end
 
       rule (:expression) do

data/lib/unitwise/expression/transformer.rb

@@ -1,12 +1,13 @@
 module Unitwise
   module Expression
     class Transformer < Parslet::Transform
+
       rule(integer: simple(:i)) { i.to_i }
       rule(fixnum: simple(:f)) { f.to_f }
 
-      rule(prefix_code: simple(:c)) { Prefix.find(c) }
-      rule(atom_code: simple(:c)) { Atom.find(c) }
-      rule(term: subtree(:h)) { Term.new(h) }
+      rule(prefix_code: simple(:c)) { |ctx| Prefix.find_by(ctx[:key], ctx[:c]) }
+      rule(atom_code: simple(:c))   { |ctx| Atom.find_by(ctx[:key], ctx[:c]) }
+      rule(term: subtree(:h))       { Term.new(h) }
 
       rule(operator: simple(:o), right: simple(:r)) do
         o == '/' ? r ** -1 : r
@@ -18,6 +19,9 @@ module Unitwise
 
       rule(left: simple(:l)) { l }
 
+      rule(group: { factor: simple(:f) , nested: simple(:n), exponent: simple(:e) }) do
+        ( n ** e ) * f
+      end
       rule(group: { nested: simple(:n) , exponent: simple(:e)}) { n ** e }
 
       rule(group: { nested: simple(:n) }) { n }

data/lib/unitwise/ext.rb

@@ -1 +1,2 @@
+require 'unitwise'
 require 'unitwise/ext/numeric'

data/lib/unitwise/functional.rb

@@ -1,20 +1,56 @@
 module Unitwise
   class Functional < Scale
+    extend Math
 
-    attr_reader :function
+    def self._cel(x, forward=true)
+      forward ? x - 273.15 : x + 273.15
+    end
 
-    def initialize(value, unit, function_name)
-      super(value, unit)
-      @function = Function.find(function_name)
+    def self._degf(x, forward=true)
+      forward ? 9.0 * x / 5.0 - 459.67 : 5.0 / 9 * (x + 459.67)
+    end
+
+    def self._hpX(x, forward=true)
+      forward ? -log10(x) : 10 ** -x
+    end
+
+    def self._hpC(x, forward=true)
+      forward ? -log(x) / log(100) : 100 ** -x 
+    end
+
+    def self._tan100(x, forward=true)
+      forward ? 100 * tan(x) : atan(x / 100)
+    end
+
+    def self._ph(x, forward=true)
+      _hpX(x,forward)
     end
 
-    def scalar
-      puts "Warning: Mathematical operations with special units not reccomended by UCUM."
-      super()
+    def self._ld(x, forward=true)
+      forward ? log2(x) : 2 ** x
+    end
+
+    def self._ln(x, forward=true)
+      forward ? log(x) : Math::E ** x
+    end
+
+    def self._lg(x, forward = true)
+      forward ? log10(x) : 10 ** x
+    end
+
+    def self._2lg(x, forward = true)
+      forward ? 2 * log10(x) : 10 ** ( x / 2 )
+    end
+
+    attr_reader :function_name
+
+    def initialize(value, unit, function_name)
+      super(value, unit)
+      @function_name = function_name
     end
 
-    def functional(x=scalar, direction=1)
-      function.functional(x, direction)
+    def functional(x=scalar, forward = true)
+      self.class.send(:"_#{function_name}", x, forward)
     end
 
   end

data/lib/unitwise/measurement.rb

@@ -41,6 +41,15 @@ module Unitwise
       end
     end
 
+    def coerce(other)
+      case other
+      when Numeric
+        return self.class.new(other, '1'), self
+      else
+        raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+      end
+    end
+
     def method_missing(meth, *args, &block)
       if Unitwise::Expression.decompose(meth)
         self.convert(meth)
@@ -58,9 +67,9 @@ module Unitwise
     def converted_value(other_unit)
       if unit.special?
         if other_unit.special?
-          other_unit.functional functional(value, -1)
+          other_unit.functional functional(value, false)
         else
-          functional(value, -1) / other_unit.scalar
+          functional(value, false) / other_unit.scalar
         end
       else
         if other_unit.special?

data/lib/unitwise/prefix.rb

@@ -1,6 +1,6 @@
 module Unitwise
   class Prefix < Base
-    attr_reader :scalar
+    liner :scalar
 
     def self.data
       @data ||= YAML::load File.open(data_file)

data/lib/unitwise/scale.rb

@@ -29,8 +29,8 @@ module Unitwise
       unit.special?
     end
 
-    def functional(x=value, direction=1)
-      unit.functional(x, direction)
+    def functional(x=value, forward=true)
+      unit.functional(x, forward)
     end
 
     def scalar

data/lib/unitwise/term.rb

@@ -1,18 +1,10 @@
 require 'signed_multiset'
 module Unitwise
   class Term
-    attr_writer :atom_code, :prefix_code, :atom, :prefix
-    attr_writer :factor, :exponent
-    attr_accessor :annotation
+    liner :atom_code, :prefix_code, :atom, :prefix, :factor, :exponent, :annotation
 
     include Unitwise::Composable
 
-    def initialize(attributes)
-      attributes.each do |k,v|
-        public_send :"#{k}=", v
-      end
-    end
-
     def prefix_code
       @prefix_code ||= (@prefix.primary_code if @prefix)
     end
@@ -53,8 +45,8 @@ module Unitwise
       (factor * (prefix ? prefix.scalar : 1) * (atom ? atom.scalar : 1)) ** exponent
     end
 
-    def functional(x=scalar, direction=1)
-      (factor * (prefix ? prefix.scalar : 1)) * (atom ? atom.functional(x, direction) : 1) ** exponent
+    def functional(x=scalar, forward=true)
+      (factor * (prefix ? prefix.scalar : 1)) * (atom ? atom.functional(x, forward) : 1) ** exponent
     end
 
     def root_terms
@@ -76,16 +68,20 @@ module Unitwise
     def *(other)
       if other.respond_to?(:terms)
         Unit.new(other.terms << self)
-      else
+      elsif other.respond_to?(:atom)
         Unit.new([self, other])
+      elsif other.is_a?(Numeric)
+        self.class.new(to_hash.merge(factor: factor * other))
       end
     end
 
     def /(other)
       if other.respond_to?(:terms)
         Unit.new(other.terms.map{|t| t ** -1} << self)
-      else
+      elsif other.respond_to?(:atom)
         Unit.new([self, other ** -1])
+      elsif other.is_a?(Numeric)
+        self.class.new(to_hash.merge(factor: factor / other))
       end
     end
 

data/lib/unitwise/unit.rb

@@ -28,8 +28,8 @@ module Unitwise
       terms.count == 1 && terms.all?(&:special?)
     end
 
-    def functional(x=scalar, direction=1)
-      terms.first.functional(x, direction)
+    def functional(x=scalar, forward=true)
+      terms.first.functional(x, forward)
     end
 
     def dup
@@ -59,6 +59,10 @@ module Unitwise
     def *(other)
       if other.respond_to?(:terms)
         self.class.new(terms + other.terms)
+      elsif other.respond_to?(:atom)
+        self.class.new(terms << other)
+      elsif other.is_a?(Numeric)
+        self.class.new(terms.map{ |t| t * other })
       else
         raise TypeError, "Can't multiply #{inspect} by #{other}."
       end
@@ -67,6 +71,8 @@ module Unitwise
     def /(other)
       if other.respond_to?(:terms)
         self.class.new(terms + other.terms.map{ |t| t ** -1})
+      elsif other.respond_to?(:atom)
+        self.class.new(terms << other ** -1)
       else
         raise TypeError, "Can't divide #{inspect} by #{other}."
       end

data/lib/unitwise/version.rb

@@ -1,3 +1,3 @@
 module Unitwise
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/simple_bench.rb

@@ -0,0 +1,21 @@
+require 'unitwise'
+require 'ruby-units'
+require 'benchmark'
+
+Benchmark.bm(10) do |x|
+
+  x.report('unitwise') do
+    100000.times do |x|
+      expression = "mm#{x % 20}"
+      Unitwise::Measurement.new(x, expression)
+    end
+  end
+
+  x.report('ruby-units') do
+    100000.times do |x|
+      expression = "mm^#{x % 20}"
+      Unit(x, expression)
+    end
+  end
+
+end

data/test/unitwise/atom_test.rb

@@ -23,6 +23,14 @@ describe Unitwise::Atom do
     end
   end
 
+  describe "::search" do
+    it "must search for atoms" do
+      result = subject.search("inch")
+      result.count.must_equal 10
+      result.must_include subject.find("inch")
+    end
+  end
+
   let(:second)  { Unitwise::Atom.find("s") }
   let(:yard)    { Unitwise::Atom.find("[yd_i]")}
   let(:pi)      { Unitwise::Atom.find("[pi]")}

data/test/unitwise/expression/decomposer_test.rb

@@ -3,13 +3,6 @@ require 'test_helper'
 describe Unitwise::Expression::Decomposer do
   subject { Unitwise::Expression::Decomposer }
 
-  describe "PARSERS" do
-    it "should return multiple parsers" do
-      subject::PARSERS.must_be_instance_of Array
-      subject::PARSERS.sample.must_be_instance_of Unitwise::Expression::Parser
-    end
-  end
-
   describe "#terms" do
     it "should accept codes" do
       fts = subject.new("[ft_i]/s").terms
@@ -31,6 +24,22 @@ describe Unitwise::Expression::Decomposer do
       saff = subject.new("<i>g<sub>n</sub></i>").terms
       saff.count.must_equal 1
     end
+    it "should accept complex units" do
+      complex = subject.new("(mg.(km/s)3/J)2.Pa").terms
+      complex.count.must_equal 5
+    end
+    it "should accept more complex units" do
+      complex = subject.new("4.1(mm/2s3)4.7.3J-2").terms
+      complex.count.must_equal 3
+    end
+    it "should accept weird units" do
+      frequency = subject.new("/s").terms
+      frequency.count.must_equal 1
+    end
+    it "should accept units with a factor and unit" do
+      oddity = subject.new("2ms2").terms
+      oddity.count.must_equal 1
+    end
   end
 
 end

data/test/unitwise/expression/parser_test.rb

@@ -36,11 +36,11 @@ describe Unitwise::Expression::Parser do
   end
 
   describe "#exponent" do
-    it "must match positives and integers" do
+    it "must match positives integers" do
       subject.exponent.parse('4')[:exponent].must_equal(integer: '4')
     end
-    it "must match negatives and fixnums" do
-      subject.exponent.parse('-5.4')[:exponent].must_equal(fixnum: '-5.4')
+    it "must match negative integers" do
+      subject.exponent.parse('-5')[:exponent].must_equal(integer: '-5')
     end
   end
 

data/test/unitwise/functional_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+describe Unitwise::Functional do
+  subject { Unitwise::Functional }
+  %w{cel degf hpX hpC tan100 ph ld ln lg 2lg}.each do |function|
+    function = :"_#{function}"
+    describe function do
+      it 'should convert back and forth' do
+        number = rand.round(5)
+        there = subject.send function, number, true
+        back_again = subject.send function, there, false
+        back_again.round(5).must_equal number
+      end
+    end
+  end
+
+end

data/test/unitwise/measurement_test.rb

@@ -37,15 +37,15 @@ describe Unitwise::Measurement do
     end
   end
 
-  let(:mph) { Unitwise::Measurement.new(60, '[mi_i]/h') }
-  let(:kmh) { Unitwise::Measurement.new(100, 'km/h') }
+  let(:mph)  { Unitwise::Measurement.new(60, '[mi_i]/h') }
+  let(:kmh)  { Unitwise::Measurement.new(100, 'km/h') }
   let(:mile) { Unitwise::Measurement.new(3, '[mi_i]') }
-  let(:hpm) { Unitwise::Measurement.new(6, 'h/[mi_i]') }
-  let(:cui) { Unitwise::Measurement.new(12, "[in_i]3") }
-  let(:cel) { Unitwise::Measurement.new(22, 'Cel') }
-  let(:k) {Unitwise::Measurement.new(373.15, 'K') }
-  let(:f) {Unitwise::Measurement.new(98.6, '[degF]')}
-  let(:r) { Unitwise::Measurement.new(491.67, '[degR]') }
+  let(:hpm)  { Unitwise::Measurement.new(6, 'h/[mi_i]') }
+  let(:cui)  { Unitwise::Measurement.new(12, "[in_i]3") }
+  let(:cel)  { Unitwise::Measurement.new(22, 'Cel') }
+  let(:k)    { Unitwise::Measurement.new(373.15, 'K') }
+  let(:f)    { Unitwise::Measurement.new(98.6, '[degF]')}
+  let(:r)    { Unitwise::Measurement.new(491.67, '[degR]') }
 
   describe "#scalar" do
     it "must return value relative to terminal atoms" do
@@ -153,6 +153,19 @@ describe Unitwise::Measurement do
       exp.value.must_equal 0.037037037037037035
       exp.unit.to_s.must_equal "1/[mi_i]3"
     end
+    it "must not raise to a weird power" do
+      -> { mile ** 'weird' }.must_raise TypeError
+    end
+  end
+
+  describe "#coerce" do
+    let(:meter) { Unitwise::Measurement.new(1, 'm') }
+    it "must coerce numerics" do
+      meter.coerce(5).must_equal [ Unitwise::Measurement.new(5, '1'), meter ]
+    end
+    it "should raise an error for other crap" do
+      -> { meter.coerce("foo") }.must_raise TypeError
+    end
   end
 
   describe "#method_missing" do

data/test/unitwise/prefix_test.rb

@@ -22,4 +22,12 @@ describe Unitwise::Prefix do
     end
   end
 
+  describe "#search" do
+    it "should search for a prefix" do
+      result = subject.search("mi")
+      result.count.must_equal 3
+      result.must_include subject.find("milli")
+    end
+  end
+
 end

data/unitwise.gemspec

@@ -17,8 +17,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^test/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "signed_multiset"
-  gem.add_dependency "parslet"
+  gem.add_dependency "liner", "~> 0.2.1"
+  gem.add_dependency "signed_multiset", "~> 0.2.0"
+  gem.add_dependency "parslet", "~> 1.5.0"
 
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "rake"

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: unitwise
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Josh Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-01 00:00:00.000000000 Z
+date: 2014-02-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: liner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: signed_multiset
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +152,6 @@ files:
 - lib/unitwise/expression/transformer.rb
 - lib/unitwise/ext.rb
 - lib/unitwise/ext/numeric.rb
-- lib/unitwise/function.rb
 - lib/unitwise/functional.rb
 - lib/unitwise/measurement.rb
 - lib/unitwise/prefix.rb
@@ -154,6 +167,7 @@ files:
 - lib/unitwise/term.rb
 - lib/unitwise/unit.rb
 - lib/unitwise/version.rb
+- simple_bench.rb
 - test/test_helper.rb
 - test/unitwise/atom_test.rb
 - test/unitwise/base_test.rb
@@ -161,7 +175,7 @@ files:
 - test/unitwise/expression/matcher_test.rb
 - test/unitwise/expression/parser_test.rb
 - test/unitwise/ext/numeric_test.rb
-- test/unitwise/function_test.rb
+- test/unitwise/functional_test.rb
 - test/unitwise/measurement_test.rb
 - test/unitwise/prefix_test.rb
 - test/unitwise/term_test.rb
@@ -201,7 +215,7 @@ test_files:
 - test/unitwise/expression/matcher_test.rb
 - test/unitwise/expression/parser_test.rb
 - test/unitwise/ext/numeric_test.rb
-- test/unitwise/function_test.rb
+- test/unitwise/functional_test.rb
 - test/unitwise/measurement_test.rb
 - test/unitwise/prefix_test.rb
 - test/unitwise/term_test.rb

data/lib/unitwise/function.rb

@@ -1,51 +0,0 @@
-module Unitwise
-  class Function
-    include Math
-    class << self
-      def all
-        @all ||= defaults
-      end
-
-      def defaults
-        [ ["cel",   ->(x){ x - 273.15},           ->(x){ x + 273.15}          ],
-          ["degf",  ->(x){9.0 * x / 5.0 - 459.67},->(x){ 5.0/9 * (x + 459.67)}],
-          ["hpX",   ->(x){ -log10(x) },           ->(x){ 10 ** -x }           ],
-          ["hpC",   ->(x){ -log(x) / log(100) },  ->(x){ 100 ** -x }          ],
-          ["tan100",->(x){ 100 * tan(x) },        ->(x){ atan(x / 100) }      ],
-          ["ph",    ->(x){ -log10(x) },           ->(x){ 10 ** -x }           ],
-          ["ld",    ->(x){ log2(x) },             ->(x){ 2 ** -x }            ],
-          ["ln",    ->(x){ log(x) },              ->(x){ Math::E ** x }       ],
-          ["lg",    ->(x){ log10(x) },            ->(x){ 10 ** x }            ],
-          ["2lg",   ->(x){ 2 * log10(x) },         ->(x){ (10 ** x) / 2 }     ]
-        ].map {|args| new(*args) }
-      end
-
-      def add(*args)
-        new_instance = self.new(*args)
-        all << new_instance
-        new_instance
-      end
-
-      def find(name)
-        all.find{|fp| fp.name == name}
-      end
-    end
-
-    attr_reader :name, :direct, :inverse
-
-    def initialize(name, direct, inverse)
-      @name = name
-      @direct = direct
-      @inverse = inverse
-    end
-
-    def functional(x, direction=1)
-      if direction == 1
-        direct.call(x)
-      elsif direction == -1
-        inverse.call(x)
-      end
-    end
-
-  end
-end

data/test/unitwise/function_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-describe Unitwise::Function do
-  subject { Unitwise::Function }
-
-  it '::all must be an Array' do
-    subject.all.must_be_instance_of Array
-  end
-
-  it '::add must add to :all' do
-    defined = subject.add('foo(2 3N)', ->{ 4 }, ->{ 6 })
-    subject.all.must_include(defined)
-  end
-
-  it "::find must find by name" do
-    defined = subject.add("foo", -> { 3 }, -> { 7 })
-    subject.find("foo").must_equal(defined)
-  end
-
-  let (:fp) { Unitwise::Function.new('foo(1 4J)', ->(x){ x + 1}, ->(x){ x - 1 }) }
-
-  it 'must have a #name' do
-    fp.name.must_equal('foo(1 4J)')
-  end
-
-  it 'must have a direct lambda' do
-    fp.direct.call(1).must_equal 2
-  end
-
-  it 'must have a inverse lambda' do
-    fp.inverse.call(1).must_equal 0
-  end
-
-  it 'must have a direct scalar' do
-    fp.functional(1, 1).must_equal 2
-  end
-
-  it 'must have an inverse scalar' do
-    fp.functional(1, -1).must_equal 0
-  end
-
-end