minad-evaluator 0.1.3 → 0.1.5

data/README.markdown

@@ -12,8 +12,24 @@ Usage
 
 See the test cases for more examples.
 
+Calculator
+----------
+
+A small calculator program (calc.rb) is provided with this library. You can use
+it as follows:
+
+    $ ./calc.rb
+    > number := 10
+    10
+    > number * 3
+    30
+    > 1 [joule] in [MeV]
+    6241509647120.42 MeV
+
+The calculator loads a few natural constants at startup (calc.startup). For unit support
+my minad-units library is used. Units are denoted in brackets e.g. [meter], [kV] etc
+
 Authors
 -------
 
 Daniel Mendler
-

data/Rakefile

@@ -3,7 +3,7 @@ require 'hoe'
 $:.unshift 'lib'
 require 'evaluator'
 
-Hoe.new 'evaluator', Evaluator::VERSION do |latex|
-  latex.developer 'Daniel Mendler', 'mail@daniel-mendler.de'
+Hoe.new 'evaluator', Evaluator::VERSION do |evaluator|
+  evaluator.developer 'Daniel Mendler', 'mail@daniel-mendler.de'
 end
 

data/lib/evaluator.rb

@@ -1,31 +1,39 @@
 require 'complex'
+begin
+  require 'units'
+rescue LoadError
+end
 
 module Evaluator
   def self.infix(priority, unary = nil, &block) [false, priority, lambda(&block), unary] end
   def self.prefix(&block) [true, 1e5, lambda(&block)] end
 
-  VERSION = "0.1.3"
+  VERSION = '0.1.5'
   OPERATOR = {
-    '||'       => infix(0) {|a,b| a || b },
-    '&&'       => infix(1) {|a,b| a && b },
-    '=='       => infix(2) {|a,b| a == b },
-    '!='       => infix(2) {|a,b| a != b },
-    '<='       => infix(2) {|a,b| a <= b },
-    '>='       => infix(2) {|a,b| a >= b },
-    '<'        => infix(2) {|a,b| a < b },
-    '>'        => infix(2) {|a,b| a > b },
-    '+'        => infix(3, 'plus') {|a,b| a + b },
-    '-'        => infix(3, 'minus') {|a,b| a - b },
-    '>>'       => infix(4) {|a,b| a >> b },
-    '<<'       => infix(4) {|a,b| a << b },
-    '&'        => infix(5) {|a,b| a & b },
-    '|'        => infix(5) {|a,b| a | b },
-    '^'        => infix(5) {|a,b| a ^ b },
-    '*'        => infix(6) {|a,b| a * b },
-    '/'        => infix(6) {|a,b| a / b },
-    '%'        => infix(6) {|a,b| a % b },
-    'div'      => infix(6) {|a,b| a.div b },
-    '**'       => infix(7) {|a,b| a ** b },
+    'in'       => infix(0) do |a,b|
+      raise(RuntimeError, 'Unit support not available') if !a.respond_to? :in
+      a.in(b)
+    end,
+    '||'       => infix(1) {|a,b| a || b },
+    '&&'       => infix(2) {|a,b| a && b },
+    '=='       => infix(3) {|a,b| a == b },
+    '!='       => infix(3) {|a,b| a != b },
+    '<='       => infix(3) {|a,b| a <= b },
+    '>='       => infix(3) {|a,b| a >= b },
+    '<'        => infix(3) {|a,b| a < b },
+    '>'        => infix(3) {|a,b| a > b },
+    '+'        => infix(4, 'plus') {|a,b| a + b },
+    '-'        => infix(4, 'minus') {|a,b| a - b },
+    '>>'       => infix(5) {|a,b| a >> b },
+    '<<'       => infix(5) {|a,b| a << b },
+    '&'        => infix(6) {|a,b| a & b },
+    '|'        => infix(6) {|a,b| a | b },
+    '^'        => infix(6) {|a,b| a ^ b },
+    '*'        => infix(7) {|a,b| a * b },
+    '/'        => infix(7) {|a,b| a / b },
+    '%'        => infix(7) {|a,b| a % b },
+    'div'      => infix(7) {|a,b| a.div b },
+    '**'       => infix(8) {|a,b| a ** b },
     'gcd'      => prefix   {|x,y| x.gcd(y) },
     'lcm'      => prefix   {|x,y| x.lcm(y) },
     'sin'      => prefix   {|x| Math.sin(x) },
@@ -69,6 +77,7 @@ module Evaluator
     'reverse'  => prefix   {|x| x.reverse },
     'index'    => prefix   {|x,y| x.index(y) },
     'rindex'   => prefix   {|x,y| x.rindex(y) },
+    '='        => '==',
     'or'       => '||',
     'and'      => '&&',
     'mod'      => '%',
@@ -89,7 +98,7 @@ module Evaluator
     'nil'   => nil,
     'e'     => Math::E,
     'pi'    => Math::PI,
-    'i'     => Complex::I
+    'i'     => Complex::I,
   }
   STRING = /^(?:'(?:\\'|[^'])*'|"(?:\\"|[^"])*")$/
   REAL   = /^(?:(?:\d*\.\d+|\d+\.\d*)(?:[eE][-+]?\d+)?|\d+[eE][-+]?\d+)$/
@@ -97,48 +106,64 @@ module Evaluator
   OCT    = /^0[0-7]+$/
   DEC    = /^\d+$/
   SYMBOL = /^[a-zA-Z_][\w_]*$/
-  VALUE_TOKENS = [STRING, REAL, HEX, OCT, DEC, SYMBOL].map {|x| x.source[1..-2] }
+  UNIT   = /^\[[^\]]+\]$/
+  VALUE_TOKENS = [UNIT, STRING, REAL, HEX, OCT, DEC, SYMBOL].map {|x| x.source[1..-2] }
   OPERATOR_TOKENS = OPERATOR.keys.flatten.sort { |a,b| b.length <=> a.length}.map { |x| Regexp.quote(x) }
   TOKENIZER = Regexp.new((VALUE_TOKENS + OPERATOR_TOKENS + ['\\(', '\\)', ',']).join('|'))
 
   def self.eval(expr, vars = {})
-    vars = Hash[*vars.map {|k,v| [k.to_s.downcase, v] }.flatten].merge(CONSTANTS)
+    vars = Hash[*vars.merge(CONSTANTS).map {|k,v| [k.to_s.downcase, v] }.flatten]
     stack, result, unary = [], [], true
     expr.to_s.scan(TOKENIZER).each do |tok|
       if tok == '('
         stack << '('
+        unary = true
       elsif tok == ')'
         exec(result, stack.pop) while !stack.empty? && stack.last != '('
-        raise(SyntaxError, "Unexpected token )") if stack.empty?
+        raise(SyntaxError, 'Unexpected token )') if stack.empty?
         stack.pop
+        unary = false
       elsif tok == ','
         exec(result, stack.pop) while !stack.empty? && stack.last != '('
+        unary = true
       elsif operator = OPERATOR[tok.downcase]
+        # Check for alias
         tok = String === operator ? operator : tok.downcase
+        operator = OPERATOR[tok]
         if operator[0]
+          # Prefix operator
           stack << tok
         elsif unary && operator[3]
+          # Alternative prefix operator
           stack << operator[3]
         else
+          # Infix operator
           exec(result, stack.pop) while !stack.empty? && stack.last != '(' && OPERATOR[stack.last][1] >= operator[1]
           stack << tok
         end
+        unary = true
       else
-        result << case tok
-                  when STRING then tok[1..-2].gsub(/\\"/, '"').gsub(/\\'/, "'")
-                  when REAL   then tok.to_f
-                  when HEX    then tok.to_i(16)
-                  when OCT    then tok.to_i(8)
-                  when DEC    then tok.to_i(10)
-                  when SYMBOL
-                    tok.downcase!
-                    raise(NameError, "Symbol #{tok} is undefined") if !vars.include?(tok)
-                    vars[tok]
-                  end
+        val = case tok
+              when UNIT
+                if tok.respond_to? :to_unit
+                  tok[1..-2].to_unit
+                else
+                  raise(RuntimeError, 'Unit support not available')
+                end
+              when STRING then tok[1..-2].gsub(/\\"/, '"').gsub(/\\'/, "'")
+              when REAL   then tok.to_f
+              when HEX    then tok.to_i(16)
+              when OCT    then tok.to_i(8)
+              when DEC    then tok.to_i(10)
+              when SYMBOL
+                tok.downcase!
+                raise(NameError, "Symbol #{tok} is undefined") if !vars.include?(tok)
+                vars[tok]
+              end
+        stack << '*' if !unary
+        result << val
         unary = false
-        next
       end
-      unary = true
     end
     exec(result, stack.pop) while !stack.empty?
     result.last
@@ -146,9 +171,9 @@ module Evaluator
 
   def self.exec(result, op)
     raise(SyntaxError, "Unexpected token #{op}") if !OPERATOR.include?(op)
-    op = OPERATOR[op][2]
-    raise(SyntaxError, "Not enough operands for #{op}") if result.size < op.arity
-    result << op[*result.slice!(-op.arity, op.arity)]
+    fn = OPERATOR[op][2]
+    raise(SyntaxError, "Not enough operands for #{op}") if result.size < fn.arity
+    result << fn[*result.slice!(-fn.arity, fn.arity)]
   end
 
   private_class_method :infix, :prefix, :exec

data/test/test_evaluator.rb

@@ -30,6 +30,8 @@ class TestEvaluator < Test::Unit::TestCase
 
     assert_equal 3, Evaluator('1+2')
     assert_equal 'xyz', Evaluator('"x"+"yz"')
+    assert_equal 'a1b', Evaluator("'a'+string 1+'b'")
+    assert_equal 'a1b', Evaluator("'a'+string(1)+'b'")
 
     assert_equal 3, Evaluator('5-2')
     assert_equal(-1, Evaluator('3-4'))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: minad-evaluator
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors: 
 - Daniel Mendler