minad-evaluator 0.1

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,19 @@
+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.
+
+Authors
+-------
+
+Daniel Mendler
+

data/Rakefile

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

data/lib/evaluator.rb

@@ -0,0 +1,159 @@
+require 'complex'
+
+module Evaluator
+
+  VERSION = "0.1"
+  INTEGER = /\d+/
+  REAL = /(?:\d*\.\d+(?:[eE][-+]?\d+)?|\d+[eE][-+]?\d+)/
+  STRING = /'(?:[^']|\\')+'|"(?:[^"]|\\")+"/
+  SYMBOL = /[\w_]+/
+  FUNCTIONS = {
+    'sin' => 1, 'cos' => 1, 'tan' => 1, 'sinh' => 1, 'cosh' => 1, 'tanh' => 1, 'asin' => 1, 'acos' => 1, 'atan' => 1,
+    'asinh' => 1, 'atanh' => 1, 'sqrt' => 1, 'log' => 1, 'ln' => 1, 'log10' => 1, 'log2' => 1, 'exp' => 1,
+    'floor' => 1, 'ceil' => 1, 'string' => 1, 'int' => 1, 'float' => 1, 'rand' => 0, 'conj' => 1, 'im' => 1, 're' => 1, 'round' => 1,
+    'abs' => 1, 'minus' => 1, 'plus' => 1, 'not' => 1 }
+  OPERATOR = [ %w(|| or), %w(&& and), %w(== != <= >= < >), %w(+ -),
+             %w(<< >>), %w(& | ^), %w(* / % div mod), %w(**), %w(!) ]
+  UNARY = {
+    '+' => 'plus',
+    '-' => 'minus',
+    '!' => 'not'
+  }
+  CONSTANTS = {
+    'true'  => true,
+    'false' => false,
+    'nil'   => nil,
+    'e'     => Math::E,
+    'pi'    => Math::PI,
+    'i'     => Complex::I
+  }
+
+  OP = {}
+  (OPERATOR + [FUNCTIONS.keys]).each_with_index do |ops,i|
+    ops.each { |op| OP[op] = i }
+  end
+
+  TOKENIZER = Regexp.new("#{REAL.source}|#{INTEGER.source}|#{STRING.source}|#{SYMBOL.source}|\\(|\\)|,|" +
+                         (OPERATOR + FUNCTIONS.keys).flatten.sort { |a,b| b.length <=> a.length}.map { |op| Regexp.quote(op) }.join('|'))
+
+  def self.eval(expr, vars = {})
+    table = CONSTANTS.dup
+    vars.each_pair {|k,v| table[k.to_s.downcase] = v }
+    tokens = expr.scan(TOKENIZER)
+    stack, post = [], []
+    prev = nil
+    tokens.each do |tok|
+      if tok == '('
+        stack << '('
+      elsif tok == ')'
+        op(post, stack.pop) while !stack.empty? && stack.last != '('
+        raise(SyntaxError, "Unexpected token )") if stack.empty?
+        stack.pop
+      elsif tok == ','
+        op(post, stack.pop) while !stack.empty? && stack.last != '('
+      elsif FUNCTIONS.include?(tok.downcase)
+        stack << tok.downcase
+      elsif OP.include?(tok)
+        if (prev == nil || OP.include?(prev)) && UNARY.include?(tok)
+          stack << UNARY[tok]
+        else
+          op(post, stack.pop) while !stack.empty? && stack.last != '(' && OP[stack.last] >= OP[tok]
+          stack << tok
+        end
+      elsif tok =~ STRING
+        post << tok[1..-2]
+      elsif tok =~ REAL
+        post << tok.to_f
+      elsif tok =~ INTEGER
+        post << tok.to_i
+      else
+        tok.downcase!
+        raise(NameError, "Symbol #{tok} is undefined") if !table.include?(tok)
+        post << table[tok]
+      end
+      prev = tok
+    end
+    op(post, stack.pop) while !stack.empty?
+    post[0]
+  end
+
+  def self.op(stack, op)
+    stack << \
+    if FUNCTIONS.include?(op)
+      args = FUNCTIONS[op]
+      raise(SyntaxError, "Not enough operands on the stack") if stack.size < args
+      a = stack.slice!(-args, args)
+      case op
+      when 'sin'    then Math.sin(a[0])
+      when 'cos'    then Math.cos(a[0])
+      when 'tan'    then Math.tan(a[0])
+      when 'sinh'   then Math.sinh(a[0])
+      when 'cosh'   then Math.cosh(a[0])
+      when 'tanh'   then Math.tanh(a[0])
+      when 'asin'   then Math.asin(a[0])
+      when 'acos'   then Math.acos(a[0])
+      when 'atan'   then Math.atan(a[0])
+      when 'asinh'  then Math.asinh(a[0])
+      when 'atanh'  then Math.atanh(a[0])
+      when 'sqrt'   then Math.sqrt(a[0])
+      when 'log'    then Math.log(a[0])
+      when 'ln'     then Math.log(a[0])
+      when 'log10'  then Math.log10(a[0])
+      when 'log2'   then Math.log(a[0])/Math.log(2)
+      when 'exp'    then Math.exp(a[0])
+      when 'floor'  then a[0].floor
+      when 'ceil'   then a[0].ceil
+      when 'string' then a[0].to_s
+      when 'float'  then a[0].to_f
+      when 'int'    then a[0].to_i
+      when 'rand'   then rand
+      when 'conj'   then a[0].conj
+      when 'im'     then a[0].imag
+      when 're'     then a[0].real
+      when 'round'  then a[0].round
+      when 'abs'    then a[0].abs
+      when 'plus'   then a[0]
+      when 'minus'  then -a[0]
+      when 'not'    then !a[0]
+      end
+    else
+      raise(SyntaxError, "Not enough operands on the stack") if stack.size < 2
+      b = stack.pop
+      a = stack.pop
+      case op
+      when '||'  then a || b
+      when 'or'  then a || b
+      when '&&'  then a && b
+      when 'and' then a && b
+      when '=='  then a == b
+      when '!='  then a != b
+      when '<='  then a <= b
+      when '>='  then a >= b
+      when '<'   then a < b
+      when '>'   then a > b
+      when '+'   then a + b
+      when '-'   then a - b
+      when '*'   then a * b
+      when '/'   then a / b
+      when 'div' then a.div(b)
+      when '%'   then a % b
+      when 'mod' then a % b
+      when '**'  then a ** b
+      when '<<'  then a << b
+      when '>>'  then a >> b
+      when '&'   then a & b
+      when '|'   then a | b
+      when '^'   then a ^ b
+      else
+        raise(SyntaxError, "Unexpected token #{op}")
+      end
+    end
+  end
+
+  private_class_method :op
+
+end
+
+def Evaluator(expr, vars = {})
+  Evaluator.eval(expr, vars)
+end

data/test/test_evaluator.rb

@@ -0,0 +1,123 @@
+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 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_functions
+    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 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('not 3')
+  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
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: minad-evaluator
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Daniel Mendler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-13 00:00:00 -07: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.2.0
+signing_key: 
+specification_version: 2
+summary: Mathematical expression evaluator
+test_files: 
+- test/test_evaluator.rb