math_engine 0.2.0 → 0.6.0

data/README.md

@@ -6,7 +6,7 @@ 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.
+The only dependency is [lexr](http://github.com/michaelbaldry/lexr), which is really lightweight and has no external dependencies.
 
 ## An example: Expressions
 
@@ -22,14 +22,40 @@ results in an output of
 
 	65.0
 	70.0
+
+extending is easy using functions, you can add single functions using MathEngine.define
+	
+	engine.context.define :add_em do |x, y|
+		x + y
+	end
+	
+or you can write all your functions in a class and add the class
+
+	class SomeFunctions
+		def add_em(x, y)
+			x + y
+		end
+	end
+
+	engine.context.include_library SomeFunctions.new
 	
+and calling them with
+
+	engine.evaluate("1 + 1 + add_em(2, 2)")
+	
+All functions are pulled in from the built in Math class by default, so all the standard ruby math functions are available (cos, sin, tan etc)
+
 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, 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!
 
+## Contributors
+
+Mario de la Ossa (mdelaossa): Handling of complex numbers and upgraded to work with 1.9.X
+
 ## License
 
 See the LICENSE file included with the distribution for licensing and
-copyright details.
+copyright details.

data/lib/context.rb

@@ -0,0 +1,63 @@
+class MathEngine
+  class Context
+    DEFAULT_OPTIONS = {case_sensitive: true}
+    
+    def initialize(opts = {})
+      @opts = DEFAULT_OPTIONS.merge(opts)
+      @variables = {}
+      @dynamic_library = Class.new.new
+      @libraries = [@dynamic_library, Math]
+    end
+    
+    def get(variable_name)
+      @variables[key variable_name]
+    end
+    
+    def set(variable_name, value)
+      raise MathEngine::UnableToModifyConstantError.new(key variable_name) if constant?(key variable_name) && 
+                                                                              get(variable_name)
+                                                                              
+      @variables[key variable_name] = value
+    end
+    
+    def define(function_name, func = nil, &block)
+      @dynamic_library.class.send :define_method, function_name.to_sym do |*args|
+        func ? func.call(*args) : block.call(*args)
+      end
+    end
+    
+    def call(function_name, *args)
+      library = library_for_function(function_name)
+      raise UnknownFunctionError.new(function_name) unless library
+      library.send(function_name, *args)
+    end
+    
+    def include_library(library)
+      @libraries << library
+    end
+    
+    def constants
+      @variables.keys.select { |variable_name| constant?(variable_name) }
+    end
+    
+    def variables
+      @variables.keys - constants
+    end
+    
+    private
+    
+    def constant?(variable_name)
+      variable_name.upcase == variable_name
+    end
+    
+    def key(variable_name)
+      return variable_name if @opts[:case_sensitive]
+      result = @variables.keys.select { |key| key.downcase == variable_name.downcase }.first
+      result || variable_name
+    end
+    
+    def library_for_function(function_name)
+      @libraries.detect { |l| l.methods.include? function_name.to_sym }
+    end
+  end
+end

data/lib/errors.rb

@@ -29,7 +29,7 @@ class MathEngine
     end
   end
   
-  class UnableToModifyConstant < StandardError
+  class UnableToModifyConstantError < StandardError
     def initialize(constant_name)
       @constant_name = constant_name
     end
@@ -38,4 +38,19 @@ class MathEngine
       "Unable to modify value of constant '#{@constant_name}'"
     end
   end
+  
+  class UnknownEvaluatorError < StandardError
+    def initialize(evaluator_name, expected_const)
+      @evaluator_name = evaluator_name
+      @expected_const = expected_const
+    end
+    
+    def to_s
+      "Unable to find an evaluator called #{@evaluator_name}(#{@expected_const})"
+    end
+    
+    def ==(other)
+      self.to_s == other.to_s
+    end
+  end
 end

data/lib/evaluators/calculate.rb

@@ -0,0 +1,60 @@
+class MathEngine
+  module Evaluators
+    class Calculate
+      def initialize(context)
+        @context = context
+      end
+    
+      def literal_number(node)
+        node.value
+      end
+    
+      def expression(node)
+        node.left.evaluate(self)
+      end
+    
+      def identifier(node)
+        @context.get node.value
+      end
+    
+      def assignment(node)
+        result = node.right.evaluate(self)
+        @context.set(node.left.value, result)
+        result
+      end
+    
+      def addition(node)
+        node.left.evaluate(self) + node.right.evaluate(self)
+      end
+    
+      def subtraction(node)
+        node.left.evaluate(self) - node.right.evaluate(self)
+      end
+    
+      def multiplication(node)
+        node.left.evaluate(self) * node.right.evaluate(self)
+      end
+
+      def division(node)
+        node.left.evaluate(self) / node.right.evaluate(self)
+      end
+
+      def exponent(node)
+        node.left.evaluate(self) ** node.right.evaluate(self)
+      end
+    
+      def modulus(node)
+        node.left.evaluate(self) % node.right.evaluate(self)
+      end
+
+      def function_call(node)
+        parameters = node.right ? node.right.to_a.collect { |p| p.evaluate(self) } : []
+        @context.call(node.left, *parameters)
+      end
+    
+      def parameters(node)
+        node.left.evaluate(self)
+      end
+    end
+  end
+end

data/lib/evaluators/finders.rb

@@ -0,0 +1,9 @@
+class MathEngine
+  module Evaluators
+    def self.find_by_name(name)
+      class_name = name.to_s.sub(%r{^[a-z\d]}) { $&.upcase }
+      class_name.gsub!(%r{(?:_|(\/))([a-z\d]*)}) { "#{$1}#{$2.capitalize}" }
+      MathEngine::Evaluators.const_get(class_name) rescue raise MathEngine::UnknownEvaluatorError.new(name, "MathEngine::Evaluators::#{class_name}")
+    end
+  end
+end

data/lib/lexer.rb

@@ -1,20 +1,26 @@
-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
+    ignores /\s/ => :whitespace
+    
+    legal_place_for_binary_operator = lambda { |prev| [:addition, 
+                                                       :subtraction, 
+                                                       :multiplication, 
+                                                       :division,
+                                                       :open_parenthesis,
+                                                       :start].include? prev.type }
+    
+    matches ',' => :comma
+    matches '=' => :assignment
+    matches '+' => :addition, :unless => legal_place_for_binary_operator
+    matches '-' => :subtraction, :unless => legal_place_for_binary_operator
+    matches '*' => :multiplication, :unless => legal_place_for_binary_operator
+    matches '/' => :division, :unless => legal_place_for_binary_operator
+    matches '^' => :exponent, :unless => legal_place_for_binary_operator
+    matches '%' => :modulus, :unless => legal_place_for_binary_operator
+    matches '(' => :open_parenthesis
+    matches ')' => :close_parenthesis
+    
+    matches /([-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-2]?\d{1,2})?[r]?|[-+]?((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-2]?\d{1,2})?)?[i]|[-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-2]?\d{1,2})?[r]?[-+]((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-2]?\d{1,2})?)?[i])/ => :number, :convert_with => lambda { |v| BigDecimal(v) }
+    matches /[a-z][a-z0-9_]*/i => :identifier, :convert_with => lambda { |v| v.to_sym }
   }
-end
+end

data/lib/math_engine.rb

@@ -1,55 +1,29 @@
-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'))
+#require "mathn"
+require "bigdecimal"
+
+require_relative "errors"
+require_relative "lexer"
+require_relative "parser"
+require_relative "context"
+
+require_relative "evaluators/finders"
+require_relative "evaluators/calculate"
 
 class MathEngine
-  def initialize()
-    @variables = {}
-    @dyn_library = Class.new.new
-    @libraries = [@dyn_library, Math]
-  end
-  
-  def evaluate(expression)
-    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
-  
-  def get(variable_name)
-    raise UnknownVariableError.new(variable_name) unless @variables.keys.include? variable_name
-    @variables[variable_name]
-  end
-  
-  def variables
-    @variables.keys.collect { |k| k.to_s }.reject { |v| v.downcase != v }.sort.collect { |k| k.to_sym }
-  end
-  
-  def constants
-    @variables.keys.collect { |k| k.to_s }.reject { |v| v.upcase != v }.sort.collect { |k| k.to_sym }
-  end
+  DEFAULT_OPTIONS = {evaluator: :calculate,
+                     case_sensitive: true}
   
-  def call(name, *parameters)
-    cls = class_for_function(name)
-    raise UnknownFunctionError.new(name) unless cls
-    cls.send name, *parameters
+  def initialize(opts = {})
+    @opts = DEFAULT_OPTIONS.merge(opts)
+    @opts[:context] = Context.new(@opts) unless @opts[:context]
   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
+  def evaluate(expression)
+    evaluator = MathEngine::Evaluators.find_by_name(@opts[:evaluator]).new(context)
+    Parser.new(Lexer.new(expression)).parse.evaluate(evaluator)
   end
   
-  private
-  
-  def class_for_function(name)
-    @libraries.detect { |l| l.methods.include? name.to_s }
+  def context
+    @opts[:context]
   end
-end
+end

data/lib/nodes.rb

@@ -1,83 +1,40 @@
 class MathEngine
   class Node
-	  attr_reader :left, :right
-  	alias :value :left
+    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
+    def initialize(left, right = nil)
+      @left, @right = left, right
+    end
+    
+    def evaluate(evaluator)
+      evaluator.send(method_name, self)
+    end
+    
+    private
+    
+    def method_name
+      class_name = self.class.name[0..-5]
+      class_name = class_name[class_name.rindex("::")+2..-1] if class_name.rindex("::")
+      method_name = class_name.gsub(%r{([A-Z\d]+)([A-Z][a-z])},'\1_\2').gsub(%r{([a-z\d])([A-Z])},'\1_\2').downcase  
     end
   end
 
-  class AssignmentNode < Node
-  	def evaluate(engine)
-  		result = right.evaluate(engine)
-  		engine.set(left.value, result)
-  		result
-  	end
-  end
+  class LiteralNumberNode < Node ; end
+  class ExpressionNode < Node ; end
+  class IdentifierNode < Node ; end
+  class AssignmentNode < Node ; end
 
-  class AdditionNode < Node
-  	def evaluate(engine)
-  		left.evaluate(engine) + right.evaluate(engine)
-  	end
-  end
+  class AdditionNode < Node ; end
+  class SubtractionNode < Node ; end
+  class MultiplicationNode < Node ; end
+  class DivisionNode < Node ; end
+  class ExponentNode < Node ; end
+  class ModulusNode < Node ; 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 FunctionCallNode < Node ; end
 
   class ParametersNode < Node
-    def evaluate(engine)
-      left.evaluate(engine)
-    end
-
     def to_a
       [left] + (right ? right.to_a : [])
     end

data/lib/parser.rb

@@ -2,101 +2,101 @@ 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> )
+    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
+      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 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
+    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)
+    
+    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
+      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
@@ -108,21 +108,21 @@ class MathEngine
       end
       MathEngine::ParametersNode.new(left, right)
     end
-	
-  	def current
-  	  @lexer.current
+
+    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
+
+    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,102 +1,91 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: math_engine
-version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 0
-  version: 0.2.0
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Michael Baldry
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-02 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: lexr
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 0
-        - 2
-        - 2
-        version: 0.2.2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: 
-email: michael.baldry@uswitch.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Lightweight matematical expression parser that is easy to extend
+email: michael@brightbits.co.uk
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
-files: 
+files:
 - README.md
+- lib/context.rb
 - lib/errors.rb
+- lib/evaluators/calculate.rb
+- lib/evaluators/finders.rb
 - lib/lexer.rb
 - lib/math_engine.rb
 - lib/nodes.rb
 - lib/parser.rb
-has_rdoc: true
-homepage: http://www.forwardtechnology.co.uk
+homepage: http://www.brightbits.co.uk
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.md
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 4003661917995291831
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Evaluates mathematical expressions
+summary: Lightweight mathematical expression parser
 test_files: []
-