ExpressionInterpreter 0.0.1

data/lib/expression_interpreter.rb

@@ -0,0 +1,229 @@
+module ExpressionInterpreter
+
+  class Expression
+    def initialize(expression)
+      parser = Parser.new(expression)
+      @operation = parser.operation
+      @variables = parser.variables
+    end
+
+    def evaluate(&var)
+      context = Context.new
+      @variables.each do |variable|
+        context.assign(variable, yield(variable.name))
+      end
+      @operation.evaluate(context)
+    end
+
+    def to_s
+      @operation.to_s
+    end
+  end 
+
+  class Operation
+    def initialize(left_operand, operation, right_operand)
+      @left_operand  = left_operand
+      @operation     = operation
+      @right_operand = right_operand
+    end
+
+    def evaluate(conext)
+      left_eval  = @left_operand.evaluate(conext)
+      right_eval = @right_operand.evaluate(conext)
+      left_eval.send(@operation, right_eval)
+    end
+
+    def to_s
+    "(#{@left_operand}#{@operation}#{@right_operand})"
+    end
+  end
+
+  class CompositeOperation
+    attr_reader :replaced
+
+    def initialize
+      @operands   = []
+      @operations = []
+      @replaced   = "" 
+    end
+
+    def add_operation(operand, operation)
+      @operands   << operand.operation
+      @operations << operation.name
+      @replaced += operand.replaced
+      @replaced += operation.replaced
+    end
+
+    def last_operation(operand)
+      @operands << operand.operation
+      @replaced += operand.replaced
+    end
+
+    def operation
+    %w(* / + -).each do |op_match|
+      i = 0  
+      retry if @operations.detect do |operation|
+        if op_match == operation
+          @operands[i] = Operation.new(@operands[i], @operations[i], @operands[i+1])
+          @operands.delete_at(i+1)
+          @operations.delete_at(i)
+          true
+        else
+          i += 1
+          false
+        end
+      end
+    end
+    @operands[0]
+    end
+
+    def to_s
+    end
+  end
+
+  class Variable
+    attr :name
+    def initialize(name)
+      @name = name.to_sym
+    end
+    def evaluate(conext)
+      conext.look_up(@name)
+    end
+    def to_s
+      @name.to_s
+    end
+  end
+
+  class Constant
+    def initialize(value)
+      @value = value.to_f
+    end
+    def evaluate(context)
+      @value
+    end
+    def to_s
+      @value.to_s
+    end
+  end
+
+  class Context
+    def initialize
+      @var_map = {}
+    end
+    def look_up(name)
+      @var_map[name]
+    end
+    def assign(variable, value)
+      @var_map[variable.name] = value.to_f
+    end
+  end
+
+  class Parser
+    attr_reader :operation, :variables
+
+    def initialize(expression)
+      @variables = []
+      expression.gsub!(/\s/, "")
+      @operation = parse(expression).operation
+    end
+
+    def parse(expression)
+      expression = strip_expression(expression)
+
+      cp = CompositeOperation.new
+      1.times do 
+
+        # Determine left operand
+        operand    = next_operand(expression) 
+        expression = expression[operand.replaced.size..-1]
+
+        # Determine operator
+        case expression
+        when /^([\+|\-|\*|\/])/
+          operator = Operator.new($1, $&)
+          expression.sub!($&, "")
+          cp.add_operation(operand, operator)
+          retry
+        else
+          cp.last_operation(operand)
+        end
+
+      end
+
+      Operand.new(cp.operation, cp.replaced)
+    end
+
+    def next_operand(expression)
+      start_with_open_bracket = /^\(/ 
+      start_with_number       = /^([0-9]+|[0-9]*\.[0-9]+)/
+      start_with_operand      = /^([^(\+|\-|\*|\/)]*)/
+
+      case expression
+      when start_with_open_bracket
+        # The whole expression within the open bracket and
+        # close bracket are the operand
+        replacant = find_expression(expression)
+        operand   = parse(replacant).operation
+      when start_with_number
+        replacant = $&;
+        operand   = Constant.new($1) 
+      when start_with_operand
+        replacant = $&;
+        operand   = Variable.new($1)
+        add_variable(operand)
+      end
+      Operand.new(operand, replacant)
+    end
+
+    def find_expression(exp)
+      pos, bc = 0, 0
+      exp.each_byte do |b|
+        pos += 1
+        bc  += 1 if b == 40
+        bc  -= 1 if b == 41
+        break if bc == 0
+      end
+      exp[0..pos-1] 
+    end
+
+    # Strip open and close brackets belonging to each other
+    # at the begining and end. i.e.: (x+y) -> x+y
+    def strip_expression(expression)  
+      1.times do
+        if expression =~ /^\(/ && expression == find_expression(expression)
+          expression = expression.sub(/^\(/, "").sub(/\)$/, "")
+          retry
+        end 
+      end
+      expression
+    end
+
+    def add_variable(variable)
+      unless @variables.detect {|var| var == variable }
+        @variables << variable
+      end
+    end
+
+  end
+
+  class Operand
+    attr_accessor :operation, :replaced
+    def initialize(operation, replaced)
+      @operation = operation
+      @replaced  = replaced
+    end
+  end
+
+  class Operator
+    attr_accessor :name, :replaced
+    def initialize(name, replaced)
+      @name     = name
+      @replaced = replaced
+    end
+  end
+
+end
+
+
+
+

data/tests/test_parser.rb

@@ -0,0 +1,51 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'expression_interpreter'
+require 'test/unit'
+
+include ExpressionInterpreter
+
+class TestExpressionInterpreter < Test::Unit::TestCase
+
+  def setup
+    @context = {
+      :x1 => 12, 
+      :x2 => 3, 
+      :x3 => 90.0, 
+      :x4 => 3, 
+      :x5 => 10.0}
+   end
+    
+  def test_add
+    exp = Expression.new(" x1 + x2")
+    assert_equal "(x1+x2)", exp.to_s
+    assert_equal 15, exp.evaluate {|v| @context[v] }
+  end
+
+  def test_sub
+    exp = Expression.new("x2 -x3")
+    assert_equal "(x2-x3)", exp.to_s
+    assert_equal -87, exp.evaluate {|v| @context[v] }
+  end
+
+  def test_operator_precedence
+    exp = Expression.new("x1 + x2 * x3")
+    assert_equal "(x1+(x2*x3))", exp.to_s
+    assert_equal 282, exp.evaluate {|v| @context[v] }
+  end
+
+  def test_respect_bracket
+    exp = Expression.new("(x1 + x2) * x3")
+    assert_equal "((x1+x2)*x3)", exp.to_s
+    assert_equal 1350, exp.evaluate {|v| @context[v] }
+  end
+
+  def test_formula1
+    exp = Expression.new("x1 * x2 + x3 * x4 / 10.0")
+    assert_equal "((x1*x2)+((x3*x4)/10.0))", exp.to_s
+    assert_equal 63, exp.evaluate {|v| @context[v] }
+  end
+
+end
+
+

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ExpressionInterpreter
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-09-28 00:00:00 +02:00
+summary: A simple expression interpreter
+require_paths: 
+- lib
+email: s.grijpink@gmail.com
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: expression_parser
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Sjors Grijpink
+files: 
+- tests/test_parser.rb
+- lib/expression_interpreter.rb
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+