simpleexpression 0.0.1

data/History.txt

@@ -0,0 +1,6 @@
+== 0.0.1 2007-10-12
+
+* 1 major enhancement:
+  * Initial public release
+* Much unit testing
+  * Test expression parsing but only a tiny bit of optimization

data/License.txt

@@ -0,0 +1,2 @@
+This software is released into the public domain in 2007 by Noah Gibbs.
+It may be used, modified or redistributed in any way whatsoever.

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/expressionparser.rb
+lib/simpleexpression.rb
+lib/simpleexpression/version.rb
+log/debug.log
+script/destroy
+script/destroy.cmd
+script/generate
+script/generate.cmd
+script/txt2html
+script/txt2html.cmd
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_simpleexpression.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1,7 @@
+The SimpleExpression library is designed to allow simple manipulations of
+algebraic quantities like "3x + 4" or "7xy * sin(z)".  In its initial form
+it can parse and evaluate such expressions, and may eventually become more
+capable.
+
+It's designed to be hooked into a numeric integrator, though that will
+be through a different gem rather than the SimpleExpression gem.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,71 @@
+require 'simpleexpression/version'
+
+AUTHOR = 'Noah Gibbs'  # can also be an array of Authors
+EMAIL = "angelbob@users.sourceforge.net"
+DESCRIPTION = "simple algebraic expressions library"
+GEM_NAME = 'simpleexpression' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'diffeq' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Simpleexpression::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'simpleexpression documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\\n\\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'simpleexpression'

data/lib/expressionparser.rb

@@ -0,0 +1,407 @@
+#
+# SimpleExpression library
+# Copyright (C) 2007 Noah Gibbs
+#
+# This library is in the public domain, and may be redistributed in any
+# way.
+#
+
+class EPNode < Array
+  private
+
+  def self.prveval(obj, vars, do_raise=true)
+    return :NoInfo if obj == :NoInfo
+    if SimpleExpression.number?(obj)
+      return obj
+    end
+    if obj.kind_of?(String)
+      return vars[obj] if vars[obj]
+      raise "Unknown variable '#{obj}'!" if do_raise
+      return :NoInfo
+    end
+    obj.eval(vars)
+  end
+
+  public
+
+  def eval(vars = {})
+    args = self[1..-1].collect { |arg| EPNode.prveval(arg, vars) }
+    op = self[0]
+
+    op = "**" if op == "^"  # exponentiation uses different op in ruby
+
+    if SimpleExpression.operator?(op)
+      if self.length == 2
+        return (op == "-" ? -args[0] : args[0])
+      elsif self.length == 3
+        return (args[0]).send(op, args[1])
+      else
+	raise "Unexpected number of arguments to #{op}!"
+      end
+    end
+
+    if SimpleExpression.function?(op)
+      return Math.send(op, args[0])
+    end
+
+    return vars[op] if vars[op] and self.length == 1
+
+    raise "Unknown expression in EPNode##eval!"
+  end
+
+  # For now, just do constant folding
+  def optimize(vars = {})
+    args = self[1..-1].collect { |arg| EPNode.prveval(arg, vars, false) }
+    if args.any? { |arg| arg == :NoInfo }
+      opt = [ nil ] * args.length
+      args.each_with_index do |arg, index|
+	opt[index] = args[index]
+	opt[index] = self[index + 1] if args[index] == :NoInfo
+      end
+      return EPNode.new(opt)
+    end
+
+    self.eval(vars)
+  end
+end
+
+class SimpleExpression
+
+  NUMBER_REGEXP = /^([-+0-9.]+(e[-+]?[0-9]+)?)(.*)$/
+  OPERATORS = "-+/*()[]{}^"
+  OPERATOR_REGEXP = Regexp.new("[#{Regexp.escape(OPERATORS)}]")
+  FUNCLIST = ["sin", "cos", "tan"]
+  PAREN_LIST = ["(", "[", "{"]
+
+  def self.number?(quantity)
+    return true if quantity.kind_of?(Float)
+    return true if quantity.kind_of?(Fixnum)
+    return true if quantity.kind_of?(Bignum)
+    false
+  end
+
+  def self.operator?(string)
+    (string =~ OPERATOR_REGEXP) ? true : false
+  end
+
+  def self.function?(string)
+    FUNCLIST.include?(string)
+  end
+
+  def self.vars_from_parse_tree(tree)
+    var_table = {}
+
+    token_iter(tree) do |item|
+      var_table[item] = 1 if SimpleExpression.legal_variable_name?(item) and
+        not SimpleExpression.function?(item)
+    end
+
+    return var_table.keys
+  end
+
+  def expression_from_string(string)
+    raise "Not a string!" unless string.kind_of?(String)
+
+    tokens = SimpleExpression.tokenize(string)
+
+    tokens = SimpleExpression.group_parens(tokens, "(", ")")
+    tokens = SimpleExpression.group_parens(tokens, "[", "]")
+    tokens = SimpleExpression.group_parens(tokens, "{", "}")
+
+    tokens = SimpleExpression.group_functions(tokens, FUNCLIST,
+					      PAREN_LIST)
+    tokens = SimpleExpression.group_right_left(tokens, ["^"])
+    tokens = SimpleExpression.group_unary(tokens, ["-", "+"])
+    tokens = SimpleExpression.group_operands(tokens)
+    tokens = SimpleExpression.group_left_right(tokens, ["*", "/"])
+    tokens = SimpleExpression.group_left_right(tokens, ["+", "-"])
+    tokens = SimpleExpression.unwrap_parens(tokens, PAREN_LIST)
+
+    # If the outer layer is a single element array around an array,
+    # upwrap it.
+    if tokens.kind_of?(Array) and tokens.length == 1 and
+	tokens[0].kind_of?(Array)
+      tokens = tokens[0]
+    end
+
+    #print "+++ Parsed: #{pretty_print_parse_tree(tokens)}\n"
+
+    raise "Can't completely parse expression '#{string}'!" unless
+      SimpleExpression.fully_parsed?(tokens)
+
+    tokens
+  end
+
+  def self.tokenize(expression)
+    tokenlist = []
+    current = ""
+
+    raise "Not a string!" unless expression.kind_of?(String)
+
+    if not expression or expression == ""
+      return []
+    end
+
+    while expression != ""
+      # Cut out whitespace
+      if /\s/.match(expression[0..0])
+	expression.sub!(/^\s+/, "")
+	next
+      end
+
+      # Grab a variable name
+      if expression[0..0] =~ /[A-Za-z]/
+	matchobj = /^([A-Za-z][-_A-Za-z0-9]*)(.*)$/.match(expression)
+
+	raise "Can't parse variable name in expression!" unless matchobj
+	unless SimpleExpression.legal_variable_name?(matchobj[1])
+	  raise "Illegal var name"
+	end
+
+	tokenlist += [ matchobj[1] ]
+	expression = matchobj[2]
+	next
+      end
+
+      # Grab an operator symbol
+      if expression[0..0] =~ OPERATOR_REGEXP
+	tokenlist += [ expression[0..0] ]
+	expression = expression [1, expression.size]
+	next
+      end
+
+      # Grab a number
+      if expression[0..0] =~ /[-+0-9.]/
+	matchobj = NUMBER_REGEXP.match(expression)
+	unless matchobj
+	  raise "Can't parse number in expression!"
+	end
+	num = matchobj[1].to_f()
+	tokenlist += [ num ]
+	expression = matchobj[3]
+	next
+      end
+
+      raise "Untokenizable expression '#{expression}'!\n"
+    end
+
+    tokenlist
+  end
+
+  # If the argument is an array containing arrays, this will call the
+  # function in question (which takes and returns an array) on each
+  # subarray, then on the top-level array with the replaced subarrays.
+  #
+  def self.grouping_iter(tokens, &myproc)
+    return [] if tokens.nil? or tokens.empty?
+    tokenclass = tokens.class
+
+    newtokens = tokens.collect do |token|
+      token.kind_of?(Array) ? grouping_iter(token, &myproc) : token
+    end
+
+    # Preserve EPNode-ness
+    tokenclass.new(myproc.call(tokenclass.new(newtokens)))
+  end
+
+  # Iterate over every token, changing nothing and returning nil.
+  #
+  def self.token_iter(tokens)
+    return if tokens.nil? or tokens.empty?
+
+    grouping_iter(tokens) do |tokens|
+      tokens.each do |token|
+	yield(token)
+      end
+    end
+
+    nil
+  end
+
+  # The full_grouping_pass function iterates over the entire parse
+  # tree, examining unparsed sections and testing (with grouptestproc)
+  # to see if they can be partially parsed.  If so, tokenchangeproc is
+  # used to determine the new token string after replacement.
+  #
+  def self.full_grouping_pass(tokens, grouptestproc, tokenchangeproc,
+	         indexchangeproc = lambda { |tokens, index| index + 1 } )
+    return [] if tokens.nil? or tokens.empty?
+
+    finaltokens = grouping_iter(tokens, &lambda { |tokens|
+      return [] if tokens == []
+      return tokens if parsed?(tokens)
+
+      newtokens = [ ]
+      index = 0
+
+      while index < tokens.length
+	if grouptestproc.call(tokens, index)
+	  newtokens = tokenchangeproc.call(tokens, newtokens, index)
+	  index = indexchangeproc.call(tokens, index)
+	else
+	  newtokens += [ tokens[index] ]
+	end
+
+	index += 1
+      end
+
+      newtokens
+    }) # end lambda and function call
+
+    finaltokens
+  end
+
+  def self.group_parens(tokens, open_paren, close_paren)
+    group_stack = []
+    savedindex = -1
+    savedtokens = nil
+
+    newtokens = full_grouping_pass(tokens,
+		       proc { |tokens, index|
+			 if savedindex >= index and group_stack != []
+			   raise "Unmatched '#{open_paren}' in '#{tokens}' " +
+			     "in group_parens!"
+			 end
+			 savedindex = index
+
+			 return true if tokens[index] == open_paren
+			 return true if tokens[index] == close_paren
+			 false
+		       },
+		       proc { |tokens, newtokens, index|
+			 if tokens[index] == open_paren
+			   group_stack += [ newtokens ]
+			   return []
+			 end
+			 if tokens[index] == close_paren
+			   if group_stack == []
+			     raise "Unmatched '#{close_paren}' parsing " +
+			       "'#{tokens}' in group_parens!"
+			   end
+			   rettokens = group_stack[-1] +
+			     [ EPNode.new([open_paren] + [ newtokens ]) ]
+			   group_stack = group_stack[0..-2]
+
+			   rettokens
+			 end
+		       },
+		       proc { |tokens, index| index }
+    )  # end full_grouping_pass()
+
+    if group_stack != []
+      raise "Unmatched '#{open_paren}' in '#{tokens}' in group_parens!\n"
+    end
+
+    newtokens
+  end
+
+  def self.unwrap_parens(tokens, paren_list)
+    grouping_iter(tokens) do |tokens|
+      if tokens.length > 1 and paren_list.include?(tokens[0])
+	[ tokens[0] ] + tokens[1]
+      else
+	tokens
+      end
+    end
+  end
+
+  def self.group_functions(tokens, funclist, parenlist)
+    full_grouping_pass(tokens,
+		       # test if we should group as function
+		       proc { |tokens, index|
+			 return false if index == (tokens.length - 1)
+			 function?(tokens[index]) and
+			   tokens[index+1].kind_of?(Array) and
+			   parenlist.include?(tokens[index + 1][0])
+		       },
+		       proc { |tokens, newtokens, index|
+			 newtokens + [ EPNode.new([ tokens[index],
+						    tokens[index + 1] ]) ]
+		       })
+  end
+
+  def self.group_unary(tokens, oplist)
+    full_grouping_pass(tokens,
+		       # test if we should group unary minus or plus
+		       proc { |tokens, index|
+			 return false if index == (tokens.length - 1)
+			 oplist.include?(tokens[index]) and
+			   operand?(tokens[index + 1]) and
+			   (index == 0 or not operand?(tokens[index - 1]))
+		       },
+		       proc { |tokens, newtokens, index|
+			 newtokens + [ EPNode.new([ tokens[index],
+						    tokens[index + 1] ]) ]
+		       })
+  end
+
+  def self.group_operands(tokens)
+    full_grouping_pass(tokens,
+		       # test if we should group two terms adjacent
+		       proc { |tokens, index|
+			 return false if index == (tokens.length - 1)
+			 operand?(tokens[index]) and
+			   operand?(tokens[index + 1])
+		       },
+		       proc { |tokens, newtokens, index|
+			 newtokens + [ EPNode.new([ "*", tokens[index],
+						    tokens[index + 1] ]) ]
+		       })
+  end
+
+  def self.parse_tree_reverse(tokens, oplist)
+    grouping_iter(tokens) do |list|
+      operator?(list[0]) ? [ list[0] ] + list[1..-1].reverse : list.reverse()
+    end
+  end
+
+  def self.group_right_left(tokens, oplist)
+    return [] if tokens.nil? or tokens.empty?
+
+    newtokens = parse_tree_reverse(tokens, oplist)
+
+    grouped_tokens = group_left_right(newtokens, oplist)
+
+    finaltokens = parse_tree_reverse(grouped_tokens, oplist)
+  end
+
+  def self.operand?(token)
+    token.kind_of?(Array) or
+      SimpleExpression.number?(token) or
+      (SimpleExpression.legal_variable_name?(token) and
+       not SimpleExpression.function?(token))
+  end
+
+  def self.group_left_right(tokens, oplist)
+    full_grouping_pass(tokens,
+		       # test if we should group around a binary op
+		       proc { |tokens, index|
+			 return false if index == 0
+			 return false if index == (tokens.length - 1)
+			 oplist.include?(tokens[index]) and
+			   operand?(tokens[index-1]) and
+			   operand?(tokens[index + 1])
+		       },
+		       proc { |tokens, newtokens, index|
+			 popped_token = newtokens[-1]
+			 newtokens = newtokens[0..-2]
+			 newtokens + [ EPNode.new([ tokens[index],
+						    popped_token,
+						    tokens[index+1] ]) ]
+		       })
+  end
+
+  def self.parsed?(tokens)
+    return true if tokens.nil? or tokens.empty?
+    return true if tokens.length == 1
+    return true if tokens.kind_of?(EPNode)
+
+    false
+  end
+
+  def self.fully_parsed?(tree)
+    parsed?(tree) and
+      tree.select{|item| item.kind_of?(Array) }.all?{|arr| fully_parsed?(arr)}
+  end
+
+end # class SimpleExpression