calculus 0.1.0

data/.gitignore

@@ -0,0 +1,10 @@
+*.bundle
+*.gem
+*.o
+*.so
+.bundle
+Gemfile.lock
+ext/**/Makefile
+ext/**/mkmf.log
+pkg/*
+tmp/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2@calculus --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in calculus.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,41 @@
+== Calculus
+
+Calculus is utility library which allow to parse some subset of latex equations and store them in {Postfix notation}[http://en.wikipedia.org/wiki/Reverse_Polish_notation] It also allows translate it to {Abstract syntax tree}[http://en.wikipedia.org/wiki/Abstract_syntax_tree] and calculate (implemented for simple expressions).
+
+== Installation
+
+    gem install calculus
+
+== Examples
+
+    001:0> require 'calculus'
+    true
+    002:0> exp = Calculus::Expression.new("2 + 3 * x")
+    #<Expression:f46e77a9377ed2d5a9da768496a7e1c20be51bfe postfix_notation=[2, 3, "x", :mul, :plus] variables={"x"=>nil}>
+    003:0> exp.postfix_notation
+    [2, 3, "x", :mul, :plus]
+    004:0> exp.abstract_syntax_tree
+    [:plus, 2, [:mul, 3, "x"]]
+    005:0> exp.variables
+    ["x"]
+    006:0> exp.unbound_variables
+    ["x"]
+    007:0> exp["x"] = 5
+    5
+    008:0> exp.unbound_variables
+    []
+    009:0> exp.calculate
+    17
+
+You can also render expression to PNG image if you have <tt>latex</tt> and <tt>dvipng</tt> installed.
+
+  010:0> Calculus::Expression.new("2 + 3 \\cdot x").to_png
+  "/tmp/d20110512-16457-dhxt71/f46e77a9377ed2d5a9da768496a7e1c20be51bfe.png"
+
+{2 + 3 \cdot x}[http://files.avsej.net/expression.png]
+
+Don't forget to cleanup file after using.
+
+== Hacking
+
+Just fork and pull request.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |test|
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/calculus.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "calculus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "calculus"
+  s.version     = Calculus::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sergey Avseyev"]
+  s.email       = ["sergey.avseyev@gmail.com"]
+  s.homepage    = "http://avsej.net/calculus"
+  s.summary     = %q{A ruby parser for TeX equations}
+  s.description = %q{A ruby parser for TeX equations. It parses equations to postfix (reverse polish) notation and can build abstract syntax tree (AST). Also it can render images via latex.}
+
+  s.rubyforge_project = "calculus"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/calculus.rb

@@ -0,0 +1,10 @@
+require 'calculus/version'
+require 'calculus/parser'
+require 'calculus/latex'
+require 'calculus/expression'
+
+module Calculus
+  class ParserError < Exception; end
+  class UnboundVariableError < Exception; end
+  class CommandNotFoundError < Exception; end
+end

data/lib/calculus/expression.rb

@@ -0,0 +1,102 @@
+require 'digest/sha1'
+
+module Calculus
+
+  class Expression
+    include Latex
+
+    attr_reader :sha1
+    attr_reader :source
+
+    attr_reader :postfix_notation
+    alias :rpn :postfix_notation
+
+    def initialize(source)
+      @postfix_notation = Parser.new(@source = source).parse
+      @variables = extract_variables
+      update_sha1
+    end
+
+    def variables
+      @variables.keys
+    end
+
+    def unbound_variables
+      @variables.keys.select{|k| @variables[k].nil?}
+    end
+
+    def [](name)
+      raise ArgumentError, "No such variable defined: #{name}" unless @variables.keys.include?(name)
+      @variables[name]
+    end
+
+    def []=(name, value)
+      raise ArgumentError, "No such variable defined: #{name}" unless @variables.keys.include?(name)
+      @variables[name] = value
+      update_sha1
+    end
+
+    def traverse(&block)
+      stack = []
+      @postfix_notation.each do |node|
+        case node
+        when Symbol
+          operation, right, left = node, stack.pop, stack.pop
+          stack.push(yield(operation, left, right, stack))
+        when Numeric
+          stack.push(node)
+        when String
+          stack.push(@variables[node] || node)
+        end
+      end
+      stack.pop
+    end
+
+    def calculate
+      raise NotImplementedError, "Equation detected. This class can't calculate equations yet." if equation?
+      raise UnboundVariableError, "Can't calculate. Unbound variables found: #{unbound_variables.join(', ')}" unless unbound_variables.empty?
+
+      traverse do |operation, left, right, stack|
+        case operation
+        when :sqrt  then left ** (1.0 / right) # could cause some rounding errors
+        when :exp   then left ** right
+        when :plus  then left + right
+        when :minus then left - right
+        when :mul   then left * right
+        when :div   then left / right
+        end
+      end
+    end
+
+    def equation?
+      @postfix_notation.include?(:eql)
+    end
+
+    def abstract_syntax_tree
+      traverse do |operation, left, right, stack|
+        [operation, left, right]
+      end
+    end
+    alias :ast :abstract_syntax_tree
+
+    def to_s
+      source
+    end
+
+    def inspect
+      "#<Expression:#{@sha1} postfix_notation=#{@postfix_notation.inspect} variables=#{@variables.inspect}>"
+    end
+
+    protected
+
+    def extract_variables
+      @postfix_notation.select{|node| node.kind_of? String}.inject({}){|h, v| h[v] = nil; h}
+    end
+
+    def update_sha1
+      @sha1 = Digest::SHA1.hexdigest([@postfix_notation, @variables].map(&:inspect).join('-'))
+    end
+
+  end
+
+end

data/lib/calculus/latex.rb

@@ -0,0 +1,47 @@
+require 'tmpdir'
+
+module Calculus
+
+  module Latex
+
+    TEMPLATE = <<-EOT.gsub(/^\s+/, '')
+      \\documentclass{article}
+      \\usepackage{amsmath,amssymb}
+      \\begin{document}
+      \\thispagestyle{empty}
+      $$ # $$
+      \\end{document}
+    EOT
+
+    def to_png(density = 700)
+      raise CommandNotFoundError, "Required commands missing: #{missing_commands.join(', ')} in PATH. (#{ENV['PATH']})" unless missing_commands.empty?
+
+      temp_path = Dir.mktmpdir
+      Dir.chdir(temp_path) do
+        File.open("#{sha1}.tex", 'w') do |f|
+          f.write(TEMPLATE.sub('#', self.to_s))
+        end
+        `latex -interaction=nonstopmode #{sha1}.tex && dvipng -q -T tight -bg White -D #{density.to_i} -o #{sha1}.png #{sha1}.dvi`
+      end
+      return File.join(temp_path, "#{sha1}.png") if $?.exitstatus.zero?
+    ensure
+      File.unlink("#{sha1}.tex") if File.exists?("#{sha1}.tex")
+      File.unlink("#{sha1}.dvi") if File.exists?("#{sha1}.dvi")
+    end
+
+    def missing_commands
+      commands = []
+      commands << "latex" unless can_run?("latex -v")
+      commands << "dvipng" unless can_run?("dvipng -v")
+      commands
+    end
+
+    protected
+
+    def can_run?(command)
+      `#{command} 2>&1`
+      $?.exitstatus.zero?
+    end
+  end
+
+end

data/lib/calculus/parser.rb

@@ -0,0 +1,91 @@
+require 'strscan'
+
+module Calculus
+
+  class Parser < StringScanner
+    attr_accessor :operators
+
+    def initialize(source)
+      @operators = {:sqrt => 3, :exp => 3, :div => 2, :mul => 2, :plus => 1, :minus => 1, :eql => 0}
+
+      super(source)
+    end
+
+    def parse
+      exp = []
+      stack = []
+      while true
+        case token = fetch_token
+        when :open
+          stack.push(token)
+        when :close
+          exp << stack.pop while operators.keys.include?(stack.last)
+          stack.pop if stack.last == :open
+        when :plus, :minus, :mul, :div, :exp, :sqrt, :eql
+          exp << stack.pop while operators.keys.include?(stack.last) && operators[stack.last] >= operators[token]
+          stack.push(token)
+        when Numeric, String
+          exp << token
+        when nil
+          break
+        else
+          raise ArgumentError, "Unexpected symbol: #{token.inspect}"
+        end
+      end
+      exp << stack.pop while stack.last && stack.last != :open
+      raise ArgumentError, "Missing closing parentheses: #{stack.join(', ')}" unless stack.empty?
+      exp
+    end
+
+    def fetch_token
+      skip(/\s+/)
+      return nil if(eos?)
+
+      token = nil
+      scanning = true
+      while(scanning)
+        scanning = false
+        token = case
+                when scan(/=/)
+                  :eql
+                when scan(/\*|\\times|\\cdot/)
+                  :mul
+                when scan(/\\frac\s*(?<num>\{(?:(?>[^{}])|\g<num>)*\})\s*(?<denom>\{(?:(?>[^{}])|\g<denom>)*\})/)
+                  num, denom = [self[1], self[2]].map{|v| v.gsub(/^{|}$/, '')}
+                  string[pos, 0] = "(#{num}) / (#{denom}) "
+                  scanning = true
+                when scan(/\//)
+                  :div
+                when scan(/\+/)
+                  :plus
+                when scan(/\^/)
+                  :exp
+                when scan(/-/)
+                  :minus
+                when scan(/sqrt/)
+                  :sqrt
+                when scan(/\\sqrt\s*(?<deg>\[(?:(?>[^\[\]])|\g<deg>)*\])?\s*(?<rad>\{(?:(?>[^{}])|\g<rad>)*\})/)
+                  deg = (self[1] || "2").gsub(/^\[|\]$/, '')
+                  rad = self[2].gsub(/^{|}$/, '')
+                  string[pos, 0] = "(#{rad}) sqrt (#{deg}) "
+                  scanning = true
+                when scan(/\(|\\left\(/)
+                  :open
+                when scan(/\)|\\right\)/)
+                  :close
+                when scan(/[\-\+]? [0-9]+ ((e[\-\+]?[0-9]+)| (\.[0-9]+(e[\-\+]?[0-9]+)?))/x)
+                  matched.to_f
+                when scan(/[\-\+]?[0-9]+/)
+                  matched.to_i
+                when scan(/([a-z0-9]+(?>_[a-z0-9]+)?)/i)
+                  matched
+                else
+                  raise ParserError, "Invalid character at position #{pos} near '#{peek(20)}'."
+                end
+      end
+
+      return token
+    end
+
+  end
+end

data/lib/calculus/version.rb

@@ -0,0 +1,3 @@
+module Calculus
+  VERSION = "0.1.0"
+end

data/test/expression_test.rb

@@ -0,0 +1,93 @@
+require 'minitest/autorun'
+require 'calculus'
+
+class TestExpression < MiniTest::Unit::TestCase
+
+  def test_that_it_extract_variables_properly
+    assert_equal ["x", "y"], expression("x + 2^x = y").variables
+  end
+
+  def test_that_it_empty_variables_array_if_they_are_absent
+    assert_equal [], expression("4 + 2^3 = 12").variables
+  end
+
+  def test_that_variables_can_be_read_using_square_brackets
+    exp = expression("4 + x^3 = 12")
+    exp.instance_variable_get("@variables")["x"] = 2
+    assert_equal 2, exp["x"]
+  end
+
+  def test_that_variables_can_be_written_using_square_brackets
+    exp = expression("4 + x^3 = 12")
+    exp["x"] = 2
+    assert_equal 2, exp.instance_variable_get("@variables")["x"]
+  end
+
+  def test_that_it_raises_exception_for_unexistent_variable
+    exp = expression("4 + x^3 = 12")
+    assert_raises(ArgumentError) { exp["y"] }
+    assert_raises(ArgumentError) { exp["y"] = 3 }
+  end
+
+  def test_that_it_initializes_variables_with_nils
+    exp = expression("x + 2^x = y")
+    assert_nil exp["x"]
+    assert_nil exp["y"]
+  end
+
+  def test_that_it_gives_access_to_postfix_notation
+    exp = expression("x + 2^x = y")
+    assert_equal ["x", 2, "x", :exp, :plus, "y", :eql], exp.postfix_notation
+    assert_equal ["x", 2, "x", :exp, :plus, "y", :eql], exp.rpn
+  end
+
+  def test_that_it_gives_access_to_abstract_syntax_tree
+    exp = expression("(2 + 3) * 4")
+    assert_equal [:mul, [:plus, 2, 3], 4], exp.abstract_syntax_tree
+    assert_equal [:mul, [:plus, 2, 3], 4], exp.ast
+  end
+
+  def test_that_it_gives_list_of_unbound_variables
+    exp = expression("x + 2^x = y")
+    assert_equal ["x", "y"], exp.unbound_variables
+    exp["x"] = 3
+    assert_equal ["y"], exp.unbound_variables
+    exp["y"] = 2
+    assert_equal [], exp.unbound_variables
+  end
+
+  def test_that_calculate_raises_unbound_variable_error_when_some_variables_missing
+    assert_raises(Calculus::UnboundVariableError) { expression("x + 2 * 3").calculate }
+  end
+
+  def test_that_calculate_raises_not_implemented_error_when_detects_equation
+    assert_raises(NotImplementedError) { expression("x + 2 = 7").calculate }
+  end
+
+  def test_that_it_calclulates_simple_expressions
+    assert_equal 8, expression("2 \\cdot 4").calculate
+    assert_equal 6, expression("2 + 2 * 2").calculate
+    assert_equal 4, expression("\\frac{4}{2} * 2").calculate
+    assert_equal 16, expression("4^2").calculate
+  end
+
+  def test_that_it_substitutes_variables_during_calculation
+    exp = expression("2 + 2 * x")
+    exp["x"] = 2
+    assert_equal 6, exp.calculate
+  end
+
+  def test_that_it_refresh_sha1_sub_when_variables_get_filled
+    exp = expression("2 \\cdot x = 4")
+    old_sha1 = exp.sha1
+    exp["x"] = 2
+    refute_equal old_sha1, exp.sha1
+  end
+
+  protected
+
+  def expression(input)
+    Calculus::Expression.new(input)
+  end
+
+end

data/test/parser_test.rb

@@ -0,0 +1,70 @@
+require 'minitest/autorun'
+require 'calculus'
+
+class TestParser < MiniTest::Unit::TestCase
+
+  def test_that_it_parses_simple_arithmetic
+    assert_equal [1, 2, :plus], parse("1+2")
+  end
+
+  def test_that_it_skips_spaces
+    assert_equal [1, 2, :plus], parse("1 + 2")
+    assert_equal [4, 2, :exp], parse(" 4 ^ 2 ")
+    assert_equal [4, 2, :sqrt], parse("\\sqrt [  2 ] { 4  }")
+    assert_equal [5, 4, :div], parse("\\frac {  5 } { 4  }")
+  end
+
+  def test_that_it_properly_parses_square_root
+    assert_equal [2, 4, 2, :sqrt, :mul], parse("2 * \\sqrt{4}")
+    assert_equal [8, 3, :sqrt], parse("\\sqrt[3]{8}")
+    assert_equal [8, 3, 2, :plus, :sqrt], parse("\\sqrt[3+2]{8}")
+  end
+
+  def test_that_it_properly_parses_fractions
+    assert_equal [8, 3, :div], parse("\\frac{8}{3}")
+    assert_equal [3, 1, :plus, 3, 1, :minus, :div], parse("\\frac{3+1}{3-1}")
+    assert_equal [3, 1, :plus, 3, 1, :minus, 4, :mul, :div], parse("\\frac{3+1}{(3-1)*4}")
+  end
+
+  def test_that_it_honours_priorities
+    assert_equal [3, 2, 2, :mul, :plus], parse("3+2*2")
+    assert_equal [3, 5, 4, :exp, :mul, 2, :plus], parse("3*5^4+2")
+    assert_equal [3, 5, :mul, 4, :exp, 2, :plus], parse("(3*5)^4+2")
+    assert_equal [3, 5, :mul, 2, :sqrt, 2, :plus], parse("\\sqrt{3*5}+2")
+  end
+
+  def test_that_it_allows_parentesis
+    assert_equal [3, 2, :plus, 2, :mul], parse("(3+2)*2")
+    assert_equal [3, 2, :plus, 2, :mul], parse("\\left(3+2\\right)*2")
+  end
+
+  def test_that_it_properly_parses_floats
+    assert_equal [1.2], parse("1.2")
+    assert_equal [1.2e10], parse("1.2e10")
+    assert_equal [1.2e-10], parse("1.2e-10")
+  end
+
+  def test_that_it_allows_nesting
+    assert_equal [8, 2, :sqrt, 3, :div], parse("\\frac{\\sqrt{8}}{3}")
+    assert_equal [4, 8, 3, :div, :sqrt], parse("\\sqrt[\\frac{8}{3}]{4}")
+  end
+
+  def test_that_it_recognizes_equals_sign
+    assert_equal [2, 4, :mul, 2, :div, 16, 2, :sqrt, :eql], parse("2 \\cdot \\frac{4}{2} = \\sqrt{16}")
+  end
+
+  def test_that_it_recognizes_variables
+    assert_equal [2, "x", :mul, 16, :eql], parse("2 \\cdot x = 16")
+    assert_equal [2, "x_i", :mul, 16, :eql], parse("2 \\cdot x_i = 16")
+    assert_equal [2, "x_2", :mul, 16, :eql], parse("2 \\cdot x_2 = 16")
+    assert_equal [2, "x2", :mul, 16, :eql], parse("2 \\cdot x2 = 16")
+    assert_raises(Calculus::ParserError) { assert_equal [2, "x__2", :mul, 16, :eql], parse("2 \\cdot x__2 = 16") }
+  end
+
+  protected
+
+  def parse(input)
+    Calculus::Parser.new(input).parse
+  end
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: calculus
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sergey Avseyev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-12 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: A ruby parser for TeX equations. It parses equations to postfix (reverse polish) notation and can build abstract syntax tree (AST). Also it can render images via latex.
+email: 
+- sergey.avseyev@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- calculus.gemspec
+- lib/calculus.rb
+- lib/calculus/expression.rb
+- lib/calculus/latex.rb
+- lib/calculus/parser.rb
+- lib/calculus/version.rb
+- test/expression_test.rb
+- test/parser_test.rb
+has_rdoc: true
+homepage: http://avsej.net/calculus
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: calculus
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A ruby parser for TeX equations
+test_files: 
+- test/expression_test.rb
+- test/parser_test.rb