math_engine 0.1.3 → 0.2.0

data/README.md

@@ -1,11 +1,13 @@
 # MathEngine
 
-MathEngine is a lightweight mathematical expression parser and evaluator. It currently handles addition, subtraction, multiplication, division and the use of variables. 
+MathEngine is a lightweight mathematical expression parser and evaluator. It currently handles addition, subtraction, multiplication, division, exponent, modulus and the use of variables and pre-defined functions.
 
 Install with
 
 	gem install math_engine
 
+The only dependency is on my other gem, lexr[http://github.com/michaelbaldry/lexr], which is really lightweight and has no external dependencies.
+
 ## An example: Expressions
 
 	require 'rubygems'
@@ -25,4 +27,9 @@ if you missed a closing parenthesis, had an operator where it wasn't meant to be
 
 	Unexpected multiplication(*), expected: number, variable name 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!
+and that is pretty much every feature so far. Please let me know of any bugs or additions that you'd like to see!
+
+## License
+
+See the LICENSE file included with the distribution for licensing and
+copyright details.

data/lib/errors.rb

@@ -0,0 +1,41 @@
+class MathEngine
+  class ParseError < StandardError
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+  end
+  
+  class UnknownVariableError < StandardError
+    def initialize(variable_name)
+      @variable_name = variable_name
+    end
+
+    def to_s
+      "Variable '#{@variable_name}' was referenced but does not exist"
+    end
+  end
+  
+  class UnknownFunctionError < StandardError
+    def initialize(function_name)
+      @function_name = function_name
+    end
+
+    def to_s
+      "Function '#{@function_name}' was referenced but does not exist"
+    end
+  end
+  
+  class UnableToModifyConstant < StandardError
+    def initialize(constant_name)
+      @constant_name = constant_name
+    end
+
+    def to_s
+      "Unable to modify value of constant '#{@constant_name}'"
+    end
+  end
+end

data/lib/lexer.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'lexr'
+
+class MathEngine
+  Lexer = Lexr.that {
+  	ignores /\s/ => :whitespace
+  	matches /[a-z][a-z0-9_]*/ => :identifier, :convert_with => lambda { |v| v.to_sym }
+  	matches /[-+]?[0-9]*\.?[0-9]+/ => :number, :convert_with => lambda { |v| Float(v) }
+  	matches ',' => :comma
+  	matches '=' => :assignment
+  	matches '+' => :addition
+  	matches '-' => :subtraction
+  	matches '*' => :multiplication
+  	matches '/' => :division
+  	matches '^' => :exponent
+  	matches '%' => :modulus
+  	matches '(' => :open_parenthesis
+  	matches ')' => :close_parenthesis
+  }
+end

data/lib/math_engine.rb

@@ -1,19 +1,20 @@
-require 'rubygems'
-require 'lexr'
-
-require File.expand_path(File.join(File.dirname(__FILE__), 'math_lexer'))
-require File.expand_path(File.join(File.dirname(__FILE__), 'math_parser'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'errors'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'lexer'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'parser'))
 
 class MathEngine
-  def initialize
+  def initialize()
     @variables = {}
+    @dyn_library = Class.new.new
+    @libraries = [@dyn_library, Math]
   end
   
   def evaluate(expression)
-    MathParser.new(MathLexer.new(expression)).parse.evaluate(self)
+    Parser.new(Lexer.new(expression)).parse.evaluate(self)
   end
   
   def set(variable_name, value)
+    raise UnableToModifyConstant.new(variable_name) if @variables.keys.include? variable_name and variable_name.to_s == variable_name.to_s.upcase
     @variables[variable_name] = value
   end
   
@@ -23,16 +24,32 @@ class MathEngine
   end
   
   def variables
-    @variables.keys
+    @variables.keys.collect { |k| k.to_s }.reject { |v| v.downcase != v }.sort.collect { |k| k.to_sym }
   end
   
-  class UnknownVariableError < StandardError
-    def initialize(variable_name)
-      @variable_name = variable_name
-    end
-    
-    def to_s
-      "Variable '#{@variable_name}' was referenced but does not exist"
+  def constants
+    @variables.keys.collect { |k| k.to_s }.reject { |v| v.upcase != v }.sort.collect { |k| k.to_sym }
+  end
+  
+  def call(name, *parameters)
+    cls = class_for_function(name)
+    raise UnknownFunctionError.new(name) unless cls
+    cls.send name, *parameters
+  end
+  
+  def define(name, func = nil, &block)
+    @dyn_library.class.send :define_method, name.to_sym do |*args|
+      func ? func.call(*args) : block.call(*args)
     end
   end
+  
+  def include_library(library)
+    @libraries << library
+  end
+  
+  private
+  
+  def class_for_function(name)
+    @libraries.detect { |l| l.methods.include? name.to_s }
+  end
 end

data/lib/nodes.rb

@@ -0,0 +1,85 @@
+class MathEngine
+  class Node
+	  attr_reader :left, :right
+  	alias :value :left
+
+  	def initialize(left, right = nil)
+  		@left, @right = left, right
+  	end
+  end
+
+  class LiteralNumberNode < Node
+  	def evaluate(engine)
+  		value
+  	end
+  end
+
+  class ExpressionNode < Node
+  	def evaluate(engine)
+  		left.evaluate(engine)
+  	end
+  end
+
+  class IdentifierNode < Node
+    def evaluate(engine)
+      engine.get value
+    end
+  end
+
+  class AssignmentNode < Node
+  	def evaluate(engine)
+  		result = right.evaluate(engine)
+  		engine.set(left.value, result)
+  		result
+  	end
+  end
+
+  class AdditionNode < Node
+  	def evaluate(engine)
+  		left.evaluate(engine) + right.evaluate(engine)
+  	end
+  end
+
+  class SubtractionNode < Node
+  	def evaluate(engine)
+  		left.evaluate(engine) - right.evaluate(engine)
+  	end
+  end
+  class MultiplicationNode < Node
+  	def evaluate(engine)
+  	  left.evaluate(engine) * right.evaluate(engine)
+  	end
+  end
+  class DivisionNode < Node
+  	def evaluate(engine)
+  		left.evaluate(engine) / right.evaluate(engine)
+  	end
+  end
+  class ExponentNode < Node
+  	def evaluate(engine)
+  		left.evaluate(engine) ** right.evaluate(engine)
+  	end
+  end
+  class ModulusNode < Node
+    def evaluate(engine)
+      left.evaluate(engine) % right.evaluate(engine)
+    end
+  end
+
+  class FunctionCallNode < Node
+    def evaluate(engine)
+      parameters = right ? right.to_a.collect { |p| p.evaluate(engine) } : []
+      engine.call(left, *parameters)
+    end
+  end
+
+  class ParametersNode < Node
+    def evaluate(engine)
+      left.evaluate(engine)
+    end
+
+    def to_a
+      [left] + (right ? right.to_a : [])
+    end
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,128 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'nodes'))
+
+class MathEngine
+  class Parser
+  	def initialize(lexer)
+  		@lexer = lexer
+  	end
+	
+  	def parse
+  		#statement = { <identifier> <assignment> } expression <end>
+  		#expression = term { ( <addition> | <subtraction> ) term }
+  		#term = exp { ( <multiplication> | <division> ) exp }
+  		#exp = factor { ( <exponent> | <modulus> ) factor }
+  		#factor = <call> | <identifier> | <number> | ( <open_parenthesis> expression <close_parenthesis> )
+      #call = <identifier> <open_parenthesis> { call_parameter } <close_parenthesis>
+      #call_parameter = <expression> { <comma> call_parameter }
+  		statement
+  	end
+	
+  	private
+
+  	def statement
+  	  next!
+  	  if current.type == :identifier && peek.type == :assignment
+  	    variable_name = current.value
+  	    next!
+  	    expect_current :assignment
+  	    next!
+  	    result = MathEngine::AssignmentNode.new(MathEngine::IdentifierNode.new(variable_name), expression)
+  	  else
+  		  result = expression
+  		end
+  		next!
+  		expect_current :end
+  		result
+  	end
+	
+  	def expression
+  		left = term
+  		result = nil
+  		while [:addition, :subtraction].include? current.type
+  			node_type = current.type == :addition ? MathEngine::AdditionNode : MathEngine::SubtractionNode
+  			next!
+  			left = node_type.new(left, term)
+  		end
+  		result = MathEngine::ExpressionNode.new(result || left)
+  		result
+  	end
+	
+  	def term
+  		left = exp
+  		result = nil
+  		while [:multiplication, :division].include? current.type
+  			node_type = current.type == :multiplication ? MathEngine::MultiplicationNode : MathEngine::DivisionNode
+  			next!
+  			left = node_type.new(left, exp)
+  		end
+  		result || left
+  	end
+	
+  	def exp
+  	  left = factor
+  		result = nil
+  		while [:exponent, :modulus].include? current.type
+  			node_type = current.type == :exponent ? MathEngine::ExponentNode : MathEngine::ModulusNode
+  			next!
+  			left = node_type.new(left, factor)
+  		end
+  		result || left
+    end
+	
+  	def factor
+  	  if current.type == :number
+  	    result = MathEngine::LiteralNumberNode.new(current.value)
+  	    next!
+  	    return result
+  	  elsif current.type == :identifier
+  	    result = peek.type == :open_parenthesis ? call : MathEngine::IdentifierNode.new(current.value)
+        next!
+        return result
+      end
+    
+  		expect_current :open_parenthesis, "number, variable or open_parenthesis"
+  		next!
+  		result = expression
+  		expect_current :close_parenthesis
+  		next!
+  		result
+  	end
+	
+  	def call
+  	  expect_current :identifier
+  	  function_name = current.value
+  	  next!
+  	  expect_current :open_parenthesis
+  	  next!
+  	  result = MathEngine::FunctionCallNode.new(function_name, current.type == :close_parenthesis ? nil : call_parameter)
+  	  expect_current :close_parenthesis
+  	  result
+    end
+  
+    def call_parameter
+      left = expression
+      right = nil
+      if current.type == :comma
+        next!
+        right = call_parameter
+      end
+      MathEngine::ParametersNode.new(left, right)
+    end
+	
+  	def current
+  	  @lexer.current
+    end
+  
+    def peek
+      @lexer.peek
+    end
+	
+  	def next!
+  		@lexer.next
+  	end
+	
+  	def expect_current(type, friendly = nil)
+  	  raise MathEngine::ParseError.new("Unexpected #{current}, expected: #{friendly ? friendly : type}") unless current.type == type
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: math_engine
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 3
-  version: 0.1.3
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Michael Baldry
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-24 00:00:00 +00:00
+date: 2010-12-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,9 +58,11 @@ extra_rdoc_files:
 - README.md
 files: 
 - README.md
+- lib/errors.rb
+- lib/lexer.rb
 - lib/math_engine.rb
-- lib/math_lexer.rb
-- lib/math_parser.rb
+- lib/nodes.rb
+- lib/parser.rb
 has_rdoc: true
 homepage: http://www.forwardtechnology.co.uk
 licenses: []
@@ -95,6 +97,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Evaluates simple mathematical expressions
+summary: Evaluates mathematical expressions
 test_files: []
 

data/lib/math_lexer.rb

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

data/lib/math_parser.rb

@@ -1,158 +0,0 @@
-class MathParser
-	def initialize(lexer)
-		@lexer = lexer
-	end
-	
-	def parse
-		#statement = { <identifier> <assignment> } expression <end>
-		#expression = term { ( <addition> | <subtraction> ) term } 
-		#term = factor { ( <multiplication> | <division> ) factor }
-		#factor = <identifier> | <number> | <open_parenthesis> expression <close_parenthesis>
-		statement
-	end
-	
-	private
-	
-	def statement
-	  next!
-	  if current.type == :identifier && peek.type == :assignment
-	    variable_name = current.value
-	    next!
-	    expect_current :assignment
-	    next!
-	    result = AssignmentNode.new(IdentifierNode.new(variable_name), expression)
-	  else 
-		  result = expression
-		end
-		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 [:number, :identifier].include? current.type
-	    node_type = current.type == :number ? LiteralNumberNode : IdentifierNode
-	    result = node_type.new(current.value)
-	    next!
-	    return result
-    end
-    
-		expect_current :open_parenthesis, "number, variable or open_parenthesis"
-		next!
-		result = expression
-		expect_current :close_parenthesis
-		next!
-		result
-	end
-	
-	private
-	
-	def current
-	  @lexer.current
-  end
-  
-  def peek
-    @lexer.peek
-  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(engine)
-				raise "Evaluate not overridden in #{self.class.name}"
-			end
-		end
-
-		class LiteralNumberNode < Node
-			def evaluate(engine)
-				value
-			end
-		end
-
-		class ExpressionNode < Node
-			def evaluate(engine)
-				left.evaluate(engine)
-			end
-		end
-		
-		class IdentifierNode < Node
-		  def evaluate(engine)
-		    engine.get value
-	    end
-	  end
-
-		class AssignmentNode < Node
-			def evaluate(engine)
-				result = right.evaluate(engine)
-				engine.set(left.value, result)
-				result
-			end
-		end
-
-		class AdditionNode < Node
-			def evaluate(engine)
-				left.evaluate(engine) + right.evaluate(engine)
-			end
-		end
-
-		class SubtractionNode < Node
-			def evaluate(engine)
-				left.evaluate(engine) - right.evaluate(engine)
-			end
-		end
-		class MultiplicationNode < Node
-			def evaluate(engine)
-				left.evaluate(engine) * right.evaluate(engine)
-			end
-		end
-		class DivisionNode < Node
-			def evaluate(engine)
-				left.evaluate(engine) / right.evaluate(engine)
-			end
-		end
-		
-	  class ParseError < StandardError
-	    def initialize(message)
-	      @message = message
-      end
-      
-      def to_s
-        @message
-      end
-    end
-end