evaluator 0.1.5

data/Manifest.txt

@@ -0,0 +1,5 @@
+lib/evaluator.rb
+test/test_evaluator.rb
+README.markdown
+Rakefile
+Manifest.txt

data/README.markdown

@@ -0,0 +1,35 @@
+README
+======
+
+Evaluator is a mathematical expression evaluator for infix notation. It supports variables and functions.
+
+Usage
+-----
+
+    require 'evaluator'
+    puts Evaluator('1+1')
+    puts Evaluator('sin pi')
+
+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

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

data/lib/evaluator.rb

@@ -0,0 +1,192 @@
+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.5'
+  OPERATOR = {
+    '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) },
+    'cos'      => prefix   {|x| Math.cos(x) },
+    'tan'      => prefix   {|x| Math.tan(x) },
+    'sinh'     => prefix   {|x| Math.sinh(x) },
+    'cosh'     => prefix   {|x| Math.cosh(x) },
+    'tanh'     => prefix   {|x| Math.tanh(x) },
+    'asin'     => prefix   {|x| Math.asin(x) },
+    'acos'     => prefix   {|x| Math.acos(x) },
+    'atan'     => prefix   {|x| Math.atan(x) },
+    'asinh'    => prefix   {|x| Math.asinh(x) },
+    'acosh'    => prefix   {|x| Math.acosh(x) },
+    'atanh'    => prefix   {|x| Math.atanh(x) },
+    'sqrt'     => prefix   {|x| Math.sqrt(x) },
+    'log'      => prefix   {|x| Math.log(x) },
+    'log10'    => prefix   {|x| Math.log10(x) },
+    'log2'     => prefix   {|x| Math.log(x)/Math.log(2) },
+    'exp'      => prefix   {|x| Math.exp(x) },
+    'erf'      => prefix   {|x| Math.erf(x) },
+    'erfc'     => prefix   {|x| Math.erfc(x) },
+    'floor'    => prefix   {|x| x.floor },
+    'ceil'     => prefix   {|x| x.ceil },
+    'string'   => prefix   {|x| x.to_s },
+    'int'      => prefix   {|x| x.to_i },
+    'float'    => prefix   {|x| x.to_f },
+    'rand'     => prefix   {|| rand },
+    'conj'     => prefix   {|x| x.conj },
+    'im'       => prefix   {|x| x.imag },
+    're'       => prefix   {|x| x.real },
+    'round'    => prefix   {|x| x.round },
+    'abs'      => prefix   {|x| x.abs },
+    'minus'    => prefix   {|x| -x },
+    'plus'     => prefix   {|x| x },
+    '!'        => prefix   {|x| !x },
+    '~'        => prefix   {|x| ~x },
+    'substr'   => prefix   {|x,a,b| x.slice(a,b) },
+    'len'      => prefix   {|x| x.length },
+    'tolower'  => prefix   {|x| x.downcase },
+    'toupper'  => prefix   {|x| x.upcase },
+    'strip'    => prefix   {|x| x.strip },
+    'reverse'  => prefix   {|x| x.reverse },
+    'index'    => prefix   {|x,y| x.index(y) },
+    'rindex'   => prefix   {|x,y| x.rindex(y) },
+    '='        => '==',
+    'or'       => '||',
+    'and'      => '&&',
+    'mod'      => '%',
+    'ln'       => 'log',
+    'imag'     => 'im',
+    'real'     => 're',
+    'count'    => 'len',
+    'size'     => 'len',
+    'length'   => 'len',
+    'trim'     => 'strip',
+    'downcase' => 'tolower',
+    'upcase'   => 'toupper',
+    'slice'    => 'substr',
+    'arcsin'   => 'asin',
+    'arccos'   => 'acos',
+    'arctan'   => 'atan',
+    'arcsinh'  => 'asinh',
+    'arccosh'  => 'asinh',
+    'arctanh'  => 'atanh',
+  }
+  CONSTANTS = {
+    'true'  => true,
+    'false' => false,
+    'nil'   => nil,
+    'e'     => Math::E,
+    'pi'    => Math::PI,
+    'i'     => Complex::I,
+  }
+  STRING = /^(?:'(?:\\'|[^'])*'|"(?:\\"|[^"])*")$/
+  REAL   = /^(?:(?:\d*\.\d+|\d+\.\d*)(?:[eE][-+]?\d+)?|\d+[eE][-+]?\d+)$/
+  HEX    = /^0[xX][\dA-Fa-f]+$/
+  OCT    = /^0[0-7]+$/
+  DEC    = /^\d+$/
+  SYMBOL = /^[a-zA-Z_][\w_]*$/
+  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.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?
+        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]
+          stack << '*' if !unary
+          # 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
+        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
+      end
+    end
+    exec(result, stack.pop) while !stack.empty?
+    result.last
+  end
+
+  def self.exec(result, op)
+    raise(SyntaxError, "Unexpected token #{op}") if !OPERATOR.include?(op)
+    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
+end
+
+def Evaluator(expr, vars = {})
+  Evaluator.eval(expr, vars)
+end

data/test/test_evaluator.rb

@@ -0,0 +1,169 @@
+require 'test/unit'
+require 'evaluator'
+
+class TestEvaluator < Test::Unit::TestCase
+  def test_binary_operators
+    assert_equal 42, Evaluator('42 || false')
+    assert_equal true, Evaluator('false || nil || true')
+    assert_equal 42, Evaluator('42 or false')
+    assert_equal true, Evaluator('false or nil or true')
+
+    assert_equal 42, Evaluator('true && 42')
+    assert_equal nil, Evaluator('nil && 1')
+    assert_equal 42, Evaluator('true and 42')
+    assert_equal nil, Evaluator('nil and 1')
+
+    assert Evaluator('1+1==2')
+    assert Evaluator("'abc' == 'a'+'b'+'c'")
+
+    assert Evaluator('1+1 != 3')
+    assert Evaluator("'xxx' != 'a'+'b'+'c'")
+
+    assert Evaluator('1<=1')
+    assert Evaluator('1<=2')
+    assert Evaluator('1>=1')
+    assert Evaluator('2>=1')
+    assert(!Evaluator('1<1'))
+    assert Evaluator('1<2')
+    assert(!Evaluator('1>1'))
+    assert Evaluator('2>1')
+
+    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'))
+
+    assert_equal 12, Evaluator('3*4')
+    assert_equal 'ababab', Evaluator('"ab"*3')
+
+    assert_equal 3, Evaluator('12/4')
+
+    assert_equal 10, Evaluator('103. div 10.')
+
+    assert_equal 3, Evaluator('7 mod 4')
+    assert_equal 3, Evaluator('7 % 4')
+
+    assert_equal 1024, Evaluator('2 ** 10')
+
+    assert_equal 8, Evaluator('2 << 2')
+    assert_equal 32, Evaluator('256 >> 3')
+
+    assert_equal 2, Evaluator('6 & 2')
+    assert_equal 7, Evaluator('1 | 2 | 4')
+    assert_equal 1, Evaluator('9 ^ 8')
+  end
+
+  def test_unary_operators
+    assert_equal(-1, Evaluator('-1'))
+    assert_equal(-2, Evaluator('-(1+1)'))
+    assert_equal(-42, Evaluator('---42'))
+    assert_equal 42, Evaluator('----42')
+    assert_equal(-9, Evaluator('3*-3'))
+    assert_equal(9, Evaluator('3*+3'))
+  end
+
+  def test_precendence
+    assert_equal 16, Evaluator('1+3*5')
+    assert_equal 16, Evaluator('3*5+1')
+    assert_equal 23, Evaluator('3*5+2**3')
+  end
+
+  def test_constants
+    assert_equal Math::PI, Evaluator('PI')
+    assert_equal Math::E, Evaluator('E')
+    assert_equal Complex::I, Evaluator('I')
+    assert_equal true, Evaluator('trUe')
+    assert_equal false, Evaluator('fAlSe')
+    assert_equal nil, Evaluator('niL')
+  end
+
+  def test_numeric_functions
+    assert_equal 13, Evaluator('gcd(26, 39)')
+    assert_equal 78, Evaluator('lcm(26, 39)')
+    assert_equal Math.cos(42), Evaluator('cos 42')
+    assert_equal Math.sin(42), Evaluator('sin 42')
+    assert_equal Math.cos(42), Evaluator('cos 42')
+    assert_equal Math.tan(42), Evaluator('tan 42')
+    assert_equal Math.sinh(42), Evaluator('sinh 42')
+    assert_equal Math.cosh(42), Evaluator('cosh 42')
+    assert_equal Math.tanh(42), Evaluator('tanh 42')
+    assert_equal Math.asin(0.5), Evaluator('asin .5')
+    assert_equal Math.acos(0.5), Evaluator('acos .5')
+    assert_equal Math.atan(0.5), Evaluator('atan .5')
+    assert_equal Math.asinh(0.5), Evaluator('asinh .5')
+    assert_equal Math.atanh(0.5), Evaluator('atanh .5')
+    assert_equal Math.sqrt(42) + 1, Evaluator('sqrt 42 + 1')
+    assert_equal Math.log(42) + 3, Evaluator('log 42 + 3')
+    assert_equal Math.log(42) + 3, Evaluator('ln 42 + 3')
+    assert_equal Math.log10(42) + 3, Evaluator('log10 42 + 3')
+    assert_equal Math.log(42)/Math.log(2) + 3, Evaluator('log2 42 + 3')
+    assert_equal 3 * Math.exp(42), Evaluator('3 * exp 42')
+    assert_equal Math.erf(2), Evaluator('erf 2')
+    assert_equal Math.erfc(2), Evaluator('erfc 2')
+    assert_equal 42, Evaluator('floor 42.3')
+    assert_equal 42, Evaluator('ceil 41.6')
+    assert_equal 3.5, Evaluator('float("3.5")')
+    assert_equal "3.5", Evaluator('string(3.5)')
+    assert_equal 3, Evaluator('int("3.5")')
+    assert_equal 3, Evaluator('int(3.6)')
+    srand(42); x = rand; srand(42)
+    assert_equal x, Evaluator('rand')
+    assert_equal Complex(1,-2), Evaluator('conj(1+2*i)')
+    assert_equal 2, Evaluator('Im(1+2*i)')
+    assert_equal 1, Evaluator('Re(1+2*i)')
+    assert_equal 3, Evaluator('round(3.4)')
+    assert_equal 4, Evaluator('round(3.5)')
+    assert_equal 6, Evaluator('abs -6')
+    assert_equal 3, Evaluator('plus 3')
+    assert_equal(-3, Evaluator('minus 3'))
+    assert_equal false, Evaluator('!3')
+    assert_equal ~3, Evaluator('~3')
+  end
+
+  def test_string_functions
+    assert_equal 'bcd', Evaluator('substr("abcde", 1, 3)')
+    assert_equal 4, Evaluator('len("abcd")')
+    assert_equal 'abc', Evaluator('strip "  abc "')
+    assert_equal 'cba', Evaluator('reverse "abc"')
+    assert_equal 2, Evaluator('index("abcdefg", "cde")')
+    assert_equal 7, Evaluator('rindex("abcdefgcdef", "cde")')
+  end
+
+  def test_variables
+    assert_equal 14, Evaluator('a+b*c', :a => 2, :b => 3, :c => 4)
+    assert_equal 14, Evaluator('a+b*C', 'A' => 2, 'b' => 3, :c => 4)
+    assert_equal 14, Evaluator('alpha+beta*GAMMA', 'ALPHA' => 2, 'bEtA' => 3, 'gamma' => 4)
+  end
+
+  def test_errors
+    assert_raise(SyntaxError) { Evaluator('(((((((((((((3+3))') }
+    assert_raise(SyntaxError) { Evaluator('1+2)') }
+    assert_raise(SyntaxError) { Evaluator('1+2+3+') }
+    assert_raise(SyntaxError) { Evaluator('1 + floor') }
+    assert_raise(NameError) { Evaluator('42*a+3') }
+    assert_raise(NameError) { Evaluator('abc10') }
+    assert_raise(NameError) { Evaluator('abc10d') }
+  end
+
+  def test_numbers
+    assert_equal 0xABCDEF123, Evaluator('0xABCDEF123')
+    assert_equal 01234, Evaluator('01234')
+    assert_equal 234, Evaluator('234 ')
+    assert_equal 0.123, Evaluator('.123')
+    assert_equal 0.123, Evaluator('0.123')
+    assert_equal 123.0, Evaluator('123.')
+    assert_equal 123e-42, Evaluator('123e-42')
+    assert_equal 0.123e-42, Evaluator('.123e-42')
+    assert_equal 2.123e-42, Evaluator('2.123e-42')
+  end
+
+  def test_strings
+    assert_equal "abc'a", Evaluator('"abc\'a"')
+    assert_equal 'abc"a', Evaluator('"abc\"a"')
+    assert_equal 'abc"a', Evaluator("'abc\"a'")
+    assert_equal "abc'a", Evaluator("'abc\\'a'")
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: evaluator
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Daniel Mendler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-13 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: 
+email: 
+- mail@daniel-mendler.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- lib/evaluator.rb
+- test/test_evaluator.rb
+- README.markdown
+- Rakefile
+- Manifest.txt
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: evaluator
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Mathematical expression evaluator
+test_files: 
+- test/test_evaluator.rb