latex_eval 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0562d9054359a1d2a318e8dec10943b3a56bb8a
+  data.tar.gz: a1ff0986f7fd46f1c6a8adf4a07656a533b19ece
+SHA512:
+  metadata.gz: 63370a4e0a0f39c47de118b18d695c77b0e10fb62ad38d7507ab0eb2c1991f52c086965826be26c327f8a95cae88b82c35a2a8552dde0fbf8f13d84d8c6d0702
+  data.tar.gz: d4d0b786b24b969ea3adfc9cba2a64c3d632ba4b7db8de44326608e676fff90fc4a5d591f7dd63b067cf935da4aa20120d22b2ae3fd2944b50ad9d8ad7157279

data/README.md

@@ -0,0 +1,86 @@
+# latex\_eval
+
+This gem can be used to safely evaluate simple latex expressions.
+
+For example, if you want to evaluate `\frac{\xi}{2}+3` where `\xi = 3` you can do
+
+    LatexEval.eval('\frac{\xi}{2}+3', {xi: 3})
+
+However, if you are going to be evaluating the expression many times, it is best to save the postfix notation first.
+
+    postfix = LatexEval.postfix_notation('\frac{\xi}{2}+3')
+    LatexEval::PostfixNotation.eval(postfix, {xi: 3})
+
+This gem is made up of 3 classes. `Latex`, `Equation`, and `PostfixNotation`. I will explain their uses.
+
+## Latex
+
+The latex class is used to convert your latex into an equation. For example,
+
+    LatexEval::Latex.new('\frac{\xi}{2}+3').equation
+
+will output `((xi)/(2)+3)`.
+
+Currently, the `equation` method for the `Latex` class supports the following latex expressions:
+
+- capital and lowercase Greek letters (`\alpha`, `\Beta`, etc.)
+- single letter variables (`a`, `b`, ..., `z`)
+- fractions in the form of `\frac{}{}` and `\dfrac{}{}`
+- roots in the form `\sqrt{}` and `\sqrt[]{}`
+- binary operators
+  - multiplication (\*, `\cdot`, `\times`)
+  - division(/)
+  - powers (^)
+  - modulus (%)
+  - addition (+)
+  - subtraction (-)
+- unary operators
+  - positive (+)
+  - negative (-)
+
+## Equation
+
+The equation class is used to convert your equations into postfix notation. For example,
+
+    LatexEval::Equation.new('((xi)/(2)+3)').postfix_notation
+
+will output `[3, :xi, 2, :divide, :add]`.
+
+Currently, the `postfix_notation` method for the `Equation` class can interpret
+
+- brackets
+- binary operators
+  - multiplication (\*)
+  - division(/)
+  - powers (^)
+  - modulus (%)
+  - addition (+)
+  - subtraction (-)
+- unary operators
+  - positive (+)
+  - negative (-)
+
+and will adhere to the generally accepted order of operations.
+
+## PostfixNotation
+
+The postfix equation class is used to safely evaluate postfix notation. For example,
+
+    LatexEval::PostfixNotation.new([3, :xi, 2, :divide, :add]).eval({xi: 3})
+
+will output `4.5`.
+
+The `eval` method accepts one argument, which is a hash of variable values.
+
+Currently, the `eval` method for the `PostfixNotation` class can interpret
+
+- binary operators
+  - :multiply
+  - :divide
+  - :power
+  - :mod
+  - :add
+  - :subtract
+- unary operators
+  - :positive
+  - :negative

data/lib/latex_eval.rb

@@ -0,0 +1,21 @@
+require_relative "./latex_eval/equation.rb"
+require_relative "./latex_eval/postfix_notation.rb"
+require_relative "./latex_eval/latex.rb"
+
+module LatexEval
+  class << self
+
+    def eval(latex, subs = {})
+      parsed_latex = LatexEval::Latex.new(latex).equation
+      parsed_notation = LatexEval::Equation.new(parsed_latex).postfix_notation
+      eval_latex = LatexEval::PostfixNotation.new(parsed_notation)
+
+      return eval_latex.eval(subs)
+    end
+
+    def postfix_notation(latex)
+      equation = LatexEval::Latex.new(latex).equation
+      return LatexEval::Equation.new(equation).postfix_notation
+    end
+  end
+end

data/lib/latex_eval/equation.rb

@@ -0,0 +1,104 @@
+module LatexEval
+  class Equation
+
+    attr_reader :binary_key, :equation, :unary_key
+
+    def initialize(equation)
+      @equation = equation
+      @binary_key = {
+        "+" => {
+          symbol: :add,
+          priority: 0,
+          right_priority: false
+        },
+        "-" => {
+          symbol: :subtract,
+          priority: 0,
+          right_priority: false
+        },
+        "*" => {
+          symbol: :multiply,
+          priority: 1,
+          right_priority: false
+        },
+        "/" => {
+          symbol: :divide,
+          priority: 1,
+          right_priority: false
+        },
+        "%" => {
+          symbol: :mod,
+          priority: 1,
+          right_priority: false
+        },
+        "^" => {
+          symbol: :power,
+          priority: 2,
+          right_priority: true
+        }
+      }
+      @unary_key = {
+        "-" => {
+          symbol: :negative,
+        },
+        "+" => {
+          symbol: :positive,
+        },
+      }
+    end
+
+    def postfix_notation
+      out = []
+      bank = []
+      bracket = []
+      unary = []
+
+      # start with an assumed array
+      bank.push []
+      bracket.push []
+      unary.push []
+
+      equation.gsub(" ", "").split(/([%\)\(\^*+-\/])/).each do |value|
+        if value != "" 
+          if value == "("
+            bank.push []
+            bracket.push []
+            unary.push []
+          elsif value == ")"
+            last = bracket.pop()
+            bracket.last.concat last
+            bracket.last.concat bank.pop().reverse.map { |e| binary_key[e][:symbol] } 
+            bracket.last.concat unary.pop().reverse.map { |e| unary_key[e][:symbol] }
+          elsif unary_key.has_key? value and (bracket.last.empty? || bracket.last.length == bank.last.length)
+            unary.last.push value 
+          elsif binary_key.has_key? value
+            num_popped = 0
+            bank.last.reverse_each do |b|
+              if (binary_key[b][:right_priority] ? binary_key[b][:priority] > binary_key[value][:priority] : binary_key[b][:priority] >= binary_key[value][:priority])
+                num_popped += 1
+              else
+                break
+              end
+            end
+            bracket.last.concat unary.pop().reverse.map { |e| unary_key[e][:symbol] }
+            unary.push []
+            bracket.last.concat bank.last.pop(num_popped).reverse.map { |e| binary_key[e][:symbol] }
+            bank.last.push value
+          else
+            if /[a-zA-Z]+/.match(value)
+              bracket.last.push value.to_sym
+            else
+              bracket.last.push value.to_f
+            end
+          end
+        end
+      end
+
+      out.concat bracket.pop()
+      out.concat unary.pop().reverse.map { |e| unary_key[e][:symbol] }
+      out.concat bank.pop().reverse.map { |e| binary_key[e][:symbol] }
+
+      return out
+    end
+  end
+end

data/lib/latex_eval/latex.rb

@@ -0,0 +1,128 @@
+module LatexEval
+  class Latex
+    attr_reader :latex, :greek_letters
+
+    def initialize(latex)
+      @latex = latex
+      @greek_letters = [
+        'Alpha',
+        'alpha',
+        'Beta',
+        'beta',
+        'Gamma',
+        'gamma',
+        'Delta',
+        'delta',
+        'Epsilon',
+        'epsilon',
+        'varepsilon',
+        'Zeta',
+        'zeta',
+        'Eta',
+        'eta',
+        'Theta',
+        'theta',
+        'vartheta',
+        'Iota',
+        'iota',
+        'Kappa',
+        'kappa',
+        'varkappa',
+        'Lambda',
+        'lambda',
+        'Mu',
+        'mu',
+        'Nu',
+        'nu',
+        'Xi',
+        'xi',
+        'Omicron',
+        'omicron',
+        'Pi',
+        'pi',
+        'varpi',
+        'Rho',
+        'rho',
+        'varrho',
+        'Sigma',
+        'sigma',
+        'varsigma',
+        'Tau',
+        'tau',
+        'Upsilon',
+        'upsilon',
+        'Phi',
+        'phi',
+        'varphi',
+        'Chi',
+        'chi',
+        'Psi',
+        'psi',
+        'Omega',
+        'omega',
+      ]
+    end
+
+    def equation
+      parsed = latex
+
+      parsed.gsub!(/\\left/, "")
+      parsed.gsub!(/\\right/, "")
+
+      # fractions
+      regex = /\\d?frac{(.*)}{(.*)}/
+      while parsed.match(regex)
+        parsed.gsub!(regex, '((\1)/(\2))')
+      end
+
+      # sqrt
+      regex = /\\sqrt{(.*)}/
+      while parsed.match(regex)
+        parsed.gsub!(regex, '((\1)^(1/2))')
+      end
+
+      # nth root
+      regex = /\\sqrt(\[?(.*)(?=\])\]?)?{(.*)}/
+      while parsed.match(regex)
+        parsed.gsub!(regex, '((\3)^(1/(\2)))')
+      end
+
+      # \cdot and \times should be *
+      parsed.gsub!(/\\cdot/, "*")
+      parsed.gsub!(/\\times/, "*")
+
+      # remove remaining curly brackets 
+      parsed.gsub!(/{/, "(")
+      parsed.gsub!(/}/, ")")
+
+      # cleanup variable names and multiplication
+      greek_letters.each do |letter|
+        parsed.gsub!(/(\\#{letter})/, ' \1 ')
+      end
+
+      # cleans up xyz to x*y*z
+      regex = /((?<!\\)\b)([0-9]?[A-Za-z])([A-Za-z])/
+      while parsed.match(regex)
+        parsed.gsub!(regex, '\2*\3')
+      end
+
+      parsed.gsub!(/([0-9])\s+\\([A-Za-z])/, '\1*\2')
+      parsed.gsub!(/([0-9])\s*?([A-Za-z])/, '\1*\2')
+
+      parsed.gsub!(/([A-Za-z])\s+\\([A-Za-z])/, '\1*\2')
+      parsed.gsub!(/([A-Za-z])\s+([A-Za-z])/, '\1*\2')
+
+      parsed.gsub!(/([A-Za-z])\s+([0-9])/, '\1*\2')
+      parsed.gsub!(/([A-Za-z])([0-9])/, '\1*\2')
+
+      parsed.gsub!(/(\))(\()/, '\1*\2')
+
+      parsed.gsub!(/\\/, "")
+
+      # cleanup spaces 
+      parsed.gsub!(" ", "")
+
+      return  parsed
+    end
+  end
+end

data/lib/latex_eval/postfix_notation.rb

@@ -0,0 +1,61 @@
+module LatexEval 
+  class PostfixNotation
+    attr_reader :notation, :operations
+
+    def initialize(notation)
+      @notation = notation
+      @operations = {
+        add: {
+          args: 2,
+          operation: ->(a,b) { a + b },
+        }, 
+        subtract: {
+          args: 2,
+          operation: ->(a,b) { a - b },
+        },
+        multiply: {
+          args: 2,
+          operation: ->(a,b) { a * b },
+        },
+        divide: {
+          args: 2, 
+          operation: ->(a,b) { a / b },
+        },
+        power: {
+          args: 2,
+          operation: ->(a,b) { a ** b },
+        },
+        mod: {
+          args: 2,
+          operation: ->(a,b) { a % b },
+        },
+        negative: {
+          args: 1,
+          operation: ->(a) { -a },
+        },
+        positive: {
+          args: 1,
+          operation: ->(a) { +a },
+        },
+      }
+    end
+
+    def eval(subs = {})
+      stack = []
+
+      notation.each do |elem|
+        if elem.is_a? Symbol
+          if operations.has_key? elem
+            stack.push operations[elem][:operation].call(*stack.pop(operations[elem][:args])).to_f
+          else
+            stack.push subs[elem].to_f
+          end
+        else
+          stack.push elem.to_f
+        end
+      end
+
+      return stack.first
+    end
+  end
+end

data/test/equation_test.rb

@@ -0,0 +1,169 @@
+require 'minitest/autorun'
+require_relative './../lib/latex_eval.rb'
+
+class TestEquation < Minitest::Test
+  def test_that_parser_parses_addition
+    equation = "1 + 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :add]
+  end
+
+  def test_that_parser_parses_subtraction
+    equation = "1 - 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :subtract]
+  end
+
+  def test_that_parser_parses_multiplication
+    equation = "1 * 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :multiply]
+  end
+
+  def test_that_parser_parses_division
+    equation = "1 / 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :divide]
+  end
+
+  def test_that_parser_parses_powers
+    equation = "1 ^ 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :power]
+  end
+
+  def test_that_parser_respects_brackets
+    equation = "(1+2)^3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :add, 3, :power]
+  end
+
+  def test_that_parser_respects_nested_brackets
+    equation = "(1+(2-4))^3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 4, :subtract, :add, 3, :power]
+  end
+
+  def test_that_parser_respects_separate_brackets
+    equation = "(1+(2-4))^(3 * 2)"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 4, :subtract, :add, 3, 2, :multiply, :power]
+  end
+
+  def test_that_parser_respects_separate_brackets_v2
+    equation = "(1-(2-4))^(3 * 2)"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 4, :subtract, :subtract, 3, 2, :multiply, :power]
+  end
+
+  def test_that_parser_disregards_spaces
+    equation = "( 1 + 2 ) ^ 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :add, 3, :power]
+  end
+
+  def test_that_parser_recognizes_single_letter_variables
+    equation = "x + y + z"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [:x, :y, :add, :z, :add]
+  end
+
+  def test_that_parser_recognizes_multi_letter_variables
+    equation = "alpha + beta + gamma"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [:alpha, :beta, :add, :gamma, :add]
+  end
+
+  def test_that_parser_evaluates_multiply_divide_in_order_of_appearance
+    equation = "1 * 2 / 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :multiply, 3, :divide]
+  end
+
+  def test_that_parser_evaluates_add_subtract_in_order_of_appearance
+    equation = "1 + 2 - 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, :add, 3, :subtract]
+  end
+
+  def test_that_powers_are_given_proper_priority
+    equation = "3 ^ 2 ^ 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [3, 2, 2, :power, :power]
+  end
+
+  def test_that_parser_multiplication_priority_over_addition
+    equation = "1 + 2 * 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :multiply, :add]
+  end
+
+  def test_that_parser_multiplication_priority_over_subtraction
+    equation = "1 - 2 * 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :multiply, :subtract]
+  end
+
+  def test_that_parser_division_priority_over_addition
+    equation = "1 + 2 / 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :divide, :add]
+  end
+
+  def test_that_parser_division_priority_over_subtraction
+    equation = "1 - 2 / 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :divide, :subtract]
+  end
+
+  def test_that_parser_power_priority_over_addition
+    equation = "1 + 2 ^ 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :power, :add]
+  end
+
+  def test_that_parser_power_priority_over_subtraction
+    equation = "1 - 2 ^ 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :power, :subtract]
+  end
+
+  def test_that_parser_power_priority_over_multiplication
+    equation = "1 * 2 ^ 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :power, :multiply]
+  end
+
+  def test_that_parser_power_priority_over_division
+    equation = "1 / 2 ^ 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :power, :divide]
+  end
+
+  def test_that_parser_mod_priority_over_addition
+    equation = "1 + 2 % 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :mod, :add]
+  end
+
+  def test_that_parser_mod_priority_over_subtraction
+    equation = "1 - 2 % 3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [1, 2, 3, :mod, :subtract]
+  end
+
+  def test_that_negative_works
+    equation = "- 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :negative]
+  end
+
+  def test_that_positive_works
+    equation = "+ 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :positive]
+  end
+
+  def test_that_negative_works_inside_brackets
+    equation = "(-2)"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :negative]
+  end
+
+  def test_that_negative_works_outside_brackets
+    equation = "-(2)"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :negative]
+  end
+
+  def test_that_negative_works_with_others
+    equation = "-2+3"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :negative, 3, :add]
+  end
+
+  def test_that_negative_works_with_multiple_negatives
+    equation = "--2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, :negative, :negative]
+  end
+
+  def test_that_negative_works_with_multiplication_normal
+    equation = "2 * - 2"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, 2, :negative, :multiply]
+  end
+
+  def test_that_negative_works_with_multiple_negatives_2
+    equation = "2^(-2)"
+    assert_equal LatexEval::Equation.new(equation).postfix_notation, [2, 2, :negative, :power]
+  end
+end

data/test/latex_eval_test.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require_relative './../lib/latex_eval.rb'
+
+class TestLatexEval < Minitest::Test
+  def test_it_all
+    latex = '\frac{1}{2}\cdot3\xi+4' 
+    assert_equal LatexEval.eval(latex, {xi: 2}), 7
+  end
+
+  def test_postfix_notation
+    latex = '1+3*2' 
+    assert_equal LatexEval.postfix_notation(latex), [1, 3, 2, :multiply, :add]
+  end
+end

data/test/latex_test.rb

@@ -0,0 +1,134 @@
+require 'minitest/autorun'
+require_relative './../lib/latex_eval.rb'
+
+class TestLatex < Minitest::Test
+  def test_that_latex_parser_parses_fractions
+    latex = '\frac{1}{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((1)/(2))' 
+  end
+
+  def test_that_latex_parser_parses_fractions_recursively
+    latex = '\frac{\frac{3}{4}}{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((((3)/(4)))/(2))' 
+  end
+
+  def test_that_latex_parser_parses_dfractions
+    latex = '\dfrac{1}{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((1)/(2))' 
+  end
+
+  def test_that_latex_parser_parses_dfractions_recursively
+    latex = '\dfrac{\dfrac{3}{4}}{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((((3)/(4)))/(2))' 
+  end
+
+  def test_that_latex_parser_parses_cdot
+    latex = '1\cdot2'
+    assert_equal LatexEval::Latex.new(latex).equation, '1*2' 
+  end
+
+  def test_that_latex_parser_parses_times
+    latex = '1\times2'
+    assert_equal LatexEval::Latex.new(latex).equation, '1*2' 
+  end
+
+  def test_that_latex_parser_parses_powers
+    latex = '1^{23}'
+    assert_equal LatexEval::Latex.new(latex).equation, '1^(23)' 
+  end
+
+  def test_that_latex_parser_parses_variable_names
+    latex = '\xi'
+    assert_equal LatexEval::Latex.new(latex).equation, 'xi' 
+  end
+
+  def test_that_latex_parser_adds_missing_multiplication_before_variable
+    latex = '2\xi'
+    assert_equal LatexEval::Latex.new(latex).equation, '2*xi' 
+  end
+
+  def test_that_latex_parser_adds_missing_multiplication_after_variable
+    latex = '\xi2'
+    assert_equal LatexEval::Latex.new(latex).equation, 'xi*2' 
+  end
+
+  def test_that_latex_parser_adds_missing_multiplication_between_variable
+    latex = '\alpha\beta'
+    assert_equal LatexEval::Latex.new(latex).equation, 'alpha*beta' 
+  end
+
+  def test_that_latex_parser_adds_missing_multiplication_between_brackets
+    latex = '(1)(2)'
+    assert_equal LatexEval::Latex.new(latex).equation, '(1)*(2)' 
+  end
+
+  def test_that_latex_parser_parses_nth_root
+    latex = '\sqrt[3]{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((2)^(1/(3)))' 
+  end
+
+  def test_that_latex_parser_parses_sqrt
+    latex = '\sqrt{2}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((2)^(1/2))' 
+  end
+
+  def test_works_with_typical_variables
+    latex = '\xi x'
+    assert_equal LatexEval::Latex.new(latex).equation, 'xi*x' 
+  end
+
+  def test_works_with_typical_variable
+    latex = '2x'
+    assert_equal LatexEval::Latex.new(latex).equation, '2*x' 
+  end
+
+  def test_works_with_typical_variable_spaces
+    latex = '2 x'
+    assert_equal LatexEval::Latex.new(latex).equation, '2*x' 
+  end
+
+  def test_works_with_typical_variable_multiple_spaces
+    latex = '2     x'
+    assert_equal LatexEval::Latex.new(latex).equation, '2*x' 
+  end
+
+  def test_works_with_left_and_right
+    latex = '\left(x + 2\right)'
+    assert_equal LatexEval::Latex.new(latex).equation, '(x+2)' 
+  end
+
+  def test_works_with_abs
+    latex = '2 % 3'
+    assert_equal LatexEval::Latex.new(latex).equation, '2%3' 
+  end
+
+  def test_works_with_abs_and_variables
+    latex = 'x % y'
+    assert_equal LatexEval::Latex.new(latex).equation, 'x%y' 
+  end
+
+  def test_works_with_variable_spaces
+    latex = 'x     y'
+    assert_equal LatexEval::Latex.new(latex).equation, 'x*y' 
+  end
+
+  def test_works_with_latex_variables
+    latex = '\xix'
+    assert_equal LatexEval::Latex.new(latex).equation, 'xi*x' 
+  end
+
+  def test_works_with_regular_variables
+    latex = 'xyz'
+    assert_equal LatexEval::Latex.new(latex).equation, 'x*y*z' 
+  end
+
+  def test_works_with_regular_variables_and_weird_numbers
+    latex = 'x*2yz'
+    assert_equal LatexEval::Latex.new(latex).equation, 'x*2*y*z' 
+  end
+
+  def test_works_with_regular_variables_complex
+    latex = '\frac{2xy}{3}'
+    assert_equal LatexEval::Latex.new(latex).equation, '((2*x*y)/(3))' 
+  end
+end

data/test/postfix_notation_test.rb

@@ -0,0 +1,54 @@
+require 'minitest/autorun'
+require_relative './../lib/latex_eval.rb'
+
+class TestPostfixNotation < Minitest::Test
+  def test_that_eval_evals_add
+    parsed = [3, 5, :add]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, 8
+  end
+
+  def test_that_eval_evals_subtract
+    parsed = [3, 5, :subtract]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, -2
+  end
+
+  def test_that_eval_evals_multiply
+    parsed = [3, 5, :multiply]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, 15
+  end
+
+  def test_that_eval_evals_divide
+    parsed = [3, 5, :divide]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, 0.6
+  end
+
+  def test_that_eval_evals_power
+    parsed = [3, 5, :power]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, 243
+  end
+
+  def test_that_eval_evals_variables
+    parsed = [:x, :y, :power]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval({x: 13, y: 3}), 2197
+  end
+
+  def test_that_negatives_work
+    parsed = [-2, -1, :subtract]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, -1
+  end
+
+  def test_that_uniary_negative_works
+    parsed = [-2, -1, :negative, :add]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, -1
+  end
+
+  def test_that_uniary_positive_works
+    parsed = [-2, -1, :positive, :add]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, -3
+  end
+
+  def test_that_modulus_works
+    parsed = [432, 123, :mod]
+    assert_equal LatexEval::PostfixNotation.new(parsed).eval, 63 
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: latex_eval
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josh Dunn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: This gem can be used to parse and then evaluate simple latex expressions.
+email: jdunn45@alumni.uwo.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/latex_eval.rb
+- lib/latex_eval/equation.rb
+- lib/latex_eval/latex.rb
+- lib/latex_eval/postfix_notation.rb
+- test/equation_test.rb
+- test/latex_eval_test.rb
+- test/latex_test.rb
+- test/postfix_notation_test.rb
+homepage: https://rubygems.org/gems/latex_eval
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/joshddunn/latex_eval
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Evaluate simple latex expressions.
+test_files: []