unitwise 0.1.0

data/data/prefix.yaml

@@ -0,0 +1,121 @@
+---
+- :names: yotta
+  :symbol: Y
+  :primary_code: Y
+  :secondary_code: YA
+  :scalar: 1e24
+- :names: zetta
+  :symbol: Z
+  :primary_code: Z
+  :secondary_code: ZA
+  :scalar: 1e21
+- :names: exa
+  :symbol: E
+  :primary_code: E
+  :secondary_code: EX
+  :scalar: 1e18
+- :names: peta
+  :symbol: P
+  :primary_code: P
+  :secondary_code: PT
+  :scalar: 1e15
+- :names: tera
+  :symbol: T
+  :primary_code: T
+  :secondary_code: TR
+  :scalar: 1e12
+- :names: giga
+  :symbol: G
+  :primary_code: G
+  :secondary_code: GA
+  :scalar: 1e9
+- :names: mega
+  :symbol: M
+  :primary_code: M
+  :secondary_code: MA
+  :scalar: 1e6
+- :names: kilo
+  :symbol: k
+  :primary_code: k
+  :secondary_code: K
+  :scalar: 1e3
+- :names: hecto
+  :symbol: h
+  :primary_code: h
+  :secondary_code: H
+  :scalar: 1e2
+- :names: deka
+  :symbol: da
+  :primary_code: da
+  :secondary_code: DA
+  :scalar: 1e1
+- :names: deci
+  :symbol: d
+  :primary_code: d
+  :secondary_code: D
+  :scalar: 1e-1
+- :names: centi
+  :symbol: c
+  :primary_code: c
+  :secondary_code: C
+  :scalar: 1e-2
+- :names: milli
+  :symbol: m
+  :primary_code: m
+  :secondary_code: M
+  :scalar: 1e-3
+- :names: micro
+  :symbol: μ
+  :primary_code: u
+  :secondary_code: U
+  :scalar: 1e-6
+- :names: nano
+  :symbol: n
+  :primary_code: n
+  :secondary_code: N
+  :scalar: 1e-9
+- :names: pico
+  :symbol: p
+  :primary_code: p
+  :secondary_code: P
+  :scalar: 1e-12
+- :names: femto
+  :symbol: f
+  :primary_code: f
+  :secondary_code: F
+  :scalar: 1e-15
+- :names: atto
+  :symbol: a
+  :primary_code: a
+  :secondary_code: A
+  :scalar: 1e-18
+- :names: zepto
+  :symbol: z
+  :primary_code: z
+  :secondary_code: ZO
+  :scalar: 1e-21
+- :names: yocto
+  :symbol: y
+  :primary_code: y
+  :secondary_code: YO
+  :scalar: 1e-24
+- :names: kibi
+  :symbol: Ki
+  :primary_code: Ki
+  :secondary_code: KIB
+  :scalar: '1024'
+- :names: mebi
+  :symbol: Mi
+  :primary_code: Mi
+  :secondary_code: MIB
+  :scalar: '1048576'
+- :names: gibi
+  :symbol: Gi
+  :primary_code: Gi
+  :secondary_code: GIB
+  :scalar: '1073741824'
+- :names: tebi
+  :symbol: Ti
+  :primary_code: Ti
+  :secondary_code: TIB
+  :scalar: '1099511627776'

data/lib/unitwise.rb

@@ -0,0 +1,25 @@
+require "unitwise/version"
+require 'unitwise/base'
+require 'unitwise/expression'
+require 'unitwise/composable'
+require 'unitwise/scale'
+require 'unitwise/functional'
+require 'unitwise/measurement'
+require 'unitwise/atom'
+require 'unitwise/prefix'
+require 'unitwise/term'
+require 'unitwise/unit'
+require 'unitwise/function'
+require 'unitwise/errors'
+require 'unitwise/ext'
+
+module Unitwise
+  def self.path
+    @path ||= File.dirname(File.dirname(__FILE__))
+  end
+
+  def self.data_file(key)
+    File.join path, "data", "#{key}.yaml"
+  end
+end
+

data/lib/unitwise/atom.rb

@@ -0,0 +1,84 @@
+module Unitwise
+  class Atom < Base
+    attr_accessor :classification, :property, :metric, :special
+    attr_accessor :arbitrary, :dim
+
+    include Unitwise::Composable
+
+    class << self
+      def data
+        @data ||= data_files.reduce([]){|m,f| m += YAML::load File.open(f)}
+      end
+
+      def data_files
+        %w(base_unit derived_unit).map{|type| Unitwise.data_file type}
+      end
+    end
+
+    def base?
+      scale.nil? && !dim.nil?
+    end
+
+    def derived?
+      !base?
+    end
+
+    def metric?
+      base? ? true : !!metric
+    end
+
+    def nonmetric?
+      !metric?
+    end
+
+    def special?
+      !!special
+    end
+
+    def arbitrary?
+      !!arbitrary
+    end
+
+    def depth
+      base? ? 0 : scale.depth + 1
+    end
+
+    def terminal?
+      depth <= 3
+    end
+
+    def key
+      base? ? dim : property
+    end
+
+    def scale=(attrs)
+      @scale = if attrs[:function_code]
+        Functional.new(attrs[:value], attrs[:unit_code], attrs[:function_code])
+      else
+        Scale.new(attrs[:value], attrs[:unit_code])
+      end
+    end
+
+    def scalar
+      base? ? 1 : scale.scalar
+    end
+
+    def functional(x, direction=1)
+      scale.functional(x, direction)
+    end
+
+
+    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

@@ -0,0 +1,45 @@
+require 'yaml'
+module Unitwise
+  class Base
+    attr_accessor :primary_code, :secondary_code, :symbol
+    attr_reader :names, :scale
+
+    def self.all
+      @all ||= data.map{|d| self.new d }
+    end
+
+    def self.find(string)
+      [:primary_code, :secondary_code, :names, :slugs, :symbol].reduce(nil) do |m, method|
+        if found = find_by(method, string)
+          return found
+        end
+      end
+    end
+
+    def self.find_by(method, string)
+      self.all.find do |i|
+        key = i.send(method)
+        if key.respond_to?(:each)
+          key.include?(string)
+        else
+          key == string
+        end
+      end
+    end
+
+    def initialize(attrs)
+      attrs.each do |k, v|
+        public_send :"#{k}=", v
+      end
+    end
+
+    def names=(names)
+      @names = Array(names)
+    end
+
+    def slugs
+      names.map(&:to_slug)
+    end
+
+  end
+end

data/lib/unitwise/composable.rb

@@ -0,0 +1,25 @@
+module Unitwise
+  module Composable
+
+    def self.included(base)
+      base.send :include, Comparable
+    end
+
+    def composition
+      root_terms.reduce(SignedMultiset.new) do |s, t|
+        s.increment(t.atom.key, t.exponent) if t.atom; s
+      end
+    end
+
+    def similar_to?(other)
+      self.composition == other.composition
+    end
+
+    def <=>(other)
+      if other.respond_to?(:composition) && similar_to?(other)
+        scalar <=> other.scalar
+      end
+    end
+
+  end
+end

data/lib/unitwise/errors.rb

@@ -0,0 +1,7 @@
+module Unitwise
+  class ExpressionError < Exception
+  end
+
+  class ConversionError < Exception
+  end
+end

data/lib/unitwise/expression.rb

@@ -0,0 +1,25 @@
+require 'parslet'
+
+require 'unitwise/expression/matcher'
+require 'unitwise/expression/parser'
+require 'unitwise/expression/transformer'
+require 'unitwise/expression/composer'
+require 'unitwise/expression/decomposer'
+
+module Unitwise
+  module Expression
+    class << self
+      def compose(terms)
+        Composer.new(terms).expression
+      end
+
+      def decompose(expression)
+        begin
+          Decomposer.new(expression).terms
+        rescue ExpressionError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/unitwise/expression/composer.rb

@@ -0,0 +1,41 @@
+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
+      end
+
+      def set
+        @set ||= terms.reduce(SignedMultiset.new) do |s, t|
+          s.increment({f: t.factor, p: t.prefix_code, a: t.atom_code}, t.exponent); s
+        end
+      end
+
+      def numerator
+        @numerator ||= set.select{|k,v| v > 0}.map do |k,v|
+          "#{k[:f] if k[:f] != 1}#{k[:p]}#{k[:a]}#{v if v != 1}"
+        end.select{|t| !t.empty?}.join('.')
+      end
+
+      def denominator
+        @denominator ||= set.select{|k,v| v < 0}.map do |k,v|
+          "#{k[:f] if k[:f] != 1}#{k[:p]}#{k[:a]}#{-v if v != -1}"
+        end.select{|t| !t.empty?}.join('.')
+      end
+
+      def expression
+        @expression = []
+        @expression << (numerator.empty? ? '1' : numerator)
+        (@expression << denominator) unless denominator.empty?
+        @expression.join('/')
+      end
+    end
+  end
+end

data/lib/unitwise/expression/decomposer.rb

@@ -0,0 +1,42 @@
+module Unitwise
+  module Expression
+    class Decomposer
+
+      PARSERS = [:primary_code, :secondary_code, :names, :slugs, :symbol].map do |t|
+        Parser.new(t)
+      end
+
+      TRANSFORMER = Transformer.new
+
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression.to_s
+        if terms.nil? || terms.empty?
+          raise ExpressionError, "Could not evaluate '#{@expression}'."
+        end
+      end
+
+      def parse
+        PARSERS.reduce(nil) do |m, p|
+          if prs = p.parse(expression) rescue next
+            return prs
+          end
+        end
+      end
+
+      def transform
+        @transform ||= TRANSFORMER.apply(parse)
+      end
+
+      def terms
+        if transform.respond_to?(:terms)
+          transform.terms
+        else
+          Array(transform)
+        end
+      end
+
+    end
+  end
+end

data/lib/unitwise/expression/matcher.rb

@@ -0,0 +1,41 @@
+module Unitwise
+  module Expression
+    class Matcher
+      class << self
+        def atom(method)
+          new(Atom.all, method).alternative
+        end
+
+        def metric_atom(method)
+          new(Atom.all.select(&:metric?), method).alternative
+        end
+
+        def prefix(method)
+          new(Prefix.all, method).alternative
+        end
+      end
+
+      attr_reader :collection, :method
+
+      def initialize(collection, method=:primary_code)
+        @collection = collection
+        @method = method
+      end
+
+      def strings
+        @stings ||= collection.map(&method).flatten.compact.sort do |x,y|
+          y.length <=> x.length
+        end
+      end
+
+      def matchers
+        @matchers ||= strings.map {|s| Parslet::Atoms::Str.new(s) }
+      end
+
+      def alternative
+        @alternative ||= Parslet::Atoms::Alternative.new(*matchers)
+      end
+
+    end
+  end
+end