math_engine 0.1.0

data/README.md

@@ -0,0 +1,24 @@
+# MathEngine
+
+MathEngine is a lightweight mathematical expression parser and evaluator. It currently handles addition, subtraction, multiplication and division, but support is planned for other operators and variables, etc.
+
+Install with
+
+	gem install math_engine
+
+## An example: Expressions
+
+	require 'rubygems'
+	require 'math_engine'
+
+	puts "#{MathEngine.new.evaluate("10 * (3 * 2) + (55 - 5) / (2.5 * (3 + 1))")}"
+
+results in an output of
+
+	65.0
+	
+if you missed a closing parenthesis, had an operator where it wasn't meant to be, you might get something like this:
+
+	Unexpected multiplication(*), expected: number or open_parenthesis
+	
+and that is pretty much every feature so far. Please let me know of any bugs or additions that you'd like to see!

data/lib/math_engine.rb

@@ -0,0 +1,5 @@
+class MathEngine
+  def evaluate(expression)
+    MathParser.new(MathLexer.new(expression)).parse.evaluate
+  end
+end

data/lib/math_lexer.rb

@@ -0,0 +1,10 @@
+MathLexer = Lexr.that {
+	ignores /\s/ => :whitespace
+	matches /[-+]?[0-9]*\.?[0-9]+/ => :number, :convert_with => lambda { |v| Float(v) }
+	matches '+' => :addition
+	matches '-' => :subtraction
+	matches '*' => :multiplication
+	matches '/' => :division
+	matches '(' => :open_parenthesis
+	matches ')' => :close_parenthesis
+}

data/lib/math_parser.rb

@@ -0,0 +1,130 @@
+class MathParser
+	def initialize(lexer)
+		@lexer = lexer
+	end
+	
+	def parse
+		#statement = expression <end>
+		#expression = term { ( <addition> | <subtraction> ) term } 
+		#term = factor { ( <multiplication> | <division> ) factor }
+		#factor = <number> | <open_parenthesis> expression <close_parenthesis>
+		statement
+	end
+	
+	private
+	
+	def statement
+	  next!
+		result = expression
+		next!
+		expect_current :end
+		result
+	end
+	
+	def expression
+		left = term
+		result = nil
+		while [:addition, :subtraction].include? current.type
+			node_type = current.type == :addition ? AdditionNode : SubtractionNode
+			next!
+			left = node_type.new(left, term)
+		end
+		ExpressionNode.new(result || left)
+	end
+	
+	def term
+		left = factor
+		result = nil
+		while [:multiplication, :division].include? current.type
+			node_type = current.type == :multiplication ? MultiplicationNode : DivisionNode
+			next!
+			left = node_type.new(left, factor)
+		end
+		result || left
+	end
+	
+	def factor
+		if current.type == :number
+		  result = LiteralNumberNode.new(current.value)
+		  next!
+		  return result
+	  end
+		expect_current :open_parenthesis, "number or open_parenthesis"
+		next!
+		result = expression
+		expect_current :close_parenthesis
+		next!
+		result
+	end
+	
+	private
+	
+	def current
+	  @lexer.current
+  end
+	
+	def next!
+		@lexer.next
+	end
+	
+	def expect_current(type, friendly = nil)
+	  raise ParseError.new("Unexpected #{current}, expected: #{friendly ? friendly : type}") unless current.type == type
+  end
+	
+	class Node
+			attr_reader :left, :right
+			alias :value :left
+
+			def initialize(left, right = nil)
+				@left, @right = left, right
+			end
+
+			def evaluate
+				raise "Evaluate not overridden in #{self.class.name}"
+			end
+		end
+
+		class LiteralNumberNode < Node
+			def evaluate
+				value
+			end
+		end
+
+		class ExpressionNode < Node
+			def evaluate
+				left.evaluate
+			end
+		end
+
+		class AdditionNode < Node
+			def evaluate
+				left.evaluate + right.evaluate
+			end
+		end
+
+		class SubtractionNode < Node
+			def evaluate
+				left.evaluate - right.evaluate
+			end
+		end
+		class MultiplicationNode < Node
+			def evaluate
+				left.evaluate * right.evaluate
+			end
+		end
+		class DivisionNode < Node
+			def evaluate
+				left.evaluate / right.evaluate
+			end
+		end
+		
+	  class ParseError < StandardError
+	    def initialize(message)
+	      @message = message
+      end
+      
+      def to_s
+        @message
+      end
+    end
+end

data/math_engine.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'lexr'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'math_lexer'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'math_parser'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'math_engine'))

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: math_engine
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Baldry
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-24 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: 
+email: michael.baldry@uswitch.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- math_engine.rb
+- README.md
+- lib/math_engine.rb
+- lib/math_lexer.rb
+- lib/math_parser.rb
+has_rdoc: true
+homepage: http://www.forwardtechnology.co.uk
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Evaluates simple mathematical expressions
+test_files: []
+