qlang 0.0.27182000 → 0.0.27182100

data/lib/qlang/lexer/tokens.rb

@@ -6,15 +6,18 @@ module Qlang
       FLO = /[0-9]+\.[0-9]+/
       E = /e/
       PI = /pi/
-      NUM = /(#{FLO}|#{INT}|#{E}|#{PI})/
+      NUM = /(?:#{FLO}|#{INT}|#{E}|#{PI})/
 
       # FUNCTION
-      EMBEDDED_FUNC = /(sin|cos|tan|log)/
+      LPRN = /\(/
+      RPRN = /\)/
+      EMBEDDED_FUNC = /(?:sin|cos|tan|log)/
       USER_FUNC = /[a-zA-Z]/
-      FUNCV = /(#{EMBEDDED_FUNC}|#{USER_FUNC})/
+      # h(x + y) != h * (x + y)
+      FUNCV = /(?:#{EMBEDDED_FUNC}|#{USER_FUNC})(?=#{LPRN})/
 
       # VARIABLE
-      VAR = /([a-d]|[f-z])/
+      VAR = /(?:[a-d]|[f-z])/
       #VAR_MUL2 = /(?!pi)#{VAR}{2}/
       # #VAR_MUL3 = /(?!#{EMBEDDED_FUNC})#{VAR}{3}/
       # # FIX:
@@ -30,30 +33,39 @@ module Qlang
       MUL = /\*/
       DIV = /\//
       EXP = /(\*\*|\^)/
-      OPE = /(#{PLS}|#{SUB}|#{MUL}|#{DIV}|#{EXP})/
+      OPE = /(?:#{PLS}|#{SUB}|#{MUL}|#{DIV}|#{EXP})/
 
-      VARNUM = /(#{NUM}|#{VAR})/
+      VARNUM = /(?:#{NUM}|#{VAR})/
       ANYSP = ' *'
       ANYSTR = /.+/
       NONL = /[^\r\n]/
 
-      LPRN = /\(/
-      RPRN = /\)/
-      PRN = /(#{LPRN}|#{RPRN})/
 
-      LBRC = /\{/
-      RBRC = /\}/
-      BRC = /(#{LBRC}|#{RBRC})/
+      PRN = /(?:#{LPRN}|#{RPRN})/
+
+      LBRCS = /\{/
+      RBRCS = /\}/
+      BRCS = /(?:#{LBRCS}|#{RBRCS})/
+
+      LBRCT = /\[/
+      RBRCT = /\]/
+      BRCT = /(?:#{LBRCT}|#{RBRCT})/
 
       CLN = /\:/
       SCLN = /;/
       CMA = /\,/
+      EQL = /\=/
       SP = / /
+      NLIN = /(\r|\n)/
+
+      ITGRLSYM = 'S'
+      # FIXIT
+      SCLN_OR_NELN = /(?:#{SCLN}|#{NLIN})/
 
       # TODO: what is better
       class Util
         def self.string_out(str, partition)
-        /#{ANYSP}#{str}(#{ANYSP}#{partition}#{ANYSP}#{str})*#{ANYSP}/
+        /#{ANYSP}#{str}(?:#{ANYSP}#{partition}#{ANYSP}#{str})*#{ANYSP}/
         end
 
         def self.func_call(args)
@@ -70,9 +82,9 @@ module Qlang
       FUNCCV = Util.func_call(VARS_BY_CMA)
       FUNCCVN =  Util.func_call(VARNUMS_BY_CMA)
 
-      NUMS_BY_SP_BY_SCLN = Util.string_out(NUMS_BY_SP, SCLN)
+      NUMS_BY_SP_BY_SCLN_OR_NELN = Util.string_out(NUMS_BY_SP, SCLN_OR_NELN)
 
-      FORMULA = /(#{OPE}|#{FUNCV}|#{VAR}|#{NUM}|#{PRN}|#{ANYSP})+/
+      FORMULA = /(?:#{OPE}|#{FUNCV}|#{VAR}|#{NUM}|#{PRN}|#{ANYSP})+/
     end
   end
 end

data/lib/qlang/parser.rb

@@ -1,8 +1,5 @@
 require 'qlang/api'
 
-require 'qlang/lexer/cont_lexer'
-require 'qlang/lexer/func_lexer'
-
 require 'qlang/parser/base'
 require 'qlang/parser/matrix_parser'
 require 'qlang/parser/vector_parser'
@@ -18,43 +15,42 @@ module Qlang
     ONEHASH = "#{ANYSP}#{SYM}#{CLN}#{ANYSP}#{VARNUM}#{ANYSP}" # sdf: 234
     def execute(lexed)
       time = Time.now
-      until lexed.token_str =~ /\A(:NLIN\d|:R\d)+\z/
+      until lexed.token_str =~ /\A:(NLIN|R)\d+\z/
         fail "I'm so sorry, something wrong. Please feel free to report this." if Time.now > time + 10
 
         case lexed.token_str
-        when /(:vector)(\d)/, /(:matrix)(\d)/, /(:tmatrix)(\d)/, /(:integral)(\d)/, /(:def_func)(\d)/
-          token_sym = $1.delete(':').to_sym
-          token_position = $2.to_i
-          token_val = lexed.lexeds[token_position][token_sym]
+        when /:(vector)(\d+)/, /:(matrix)(\d+)/, /:(tmatrix)(\d+)/, /:(integral)(\d+)/, /:(def_func)(\d+)/, /:(differential)(\d+)/
+          token_els = lexed[$2][:els]
 
-          parsed = case token_sym
-          when :vector
-            VectorParser.execute(token_val)
-          when :matrix
-            MatrixParser.execute(token_val)
-          when :tmatrix
-            MatrixParser.execute(token_val, trans: true)
-          when :integral
-            IntegralParser.execute(token_val)
-          when :def_func
-            FuncParser.execute(token_val)
+          parsed = case $1
+          when 'vector'
+            VectorParser.execute(token_els)
+          when 'matrix'
+            MatrixParser.execute(token_els)
+          when 'tmatrix'
+            MatrixParser.execute(token_els, trans: true)
+          when 'integral'
+            IntegralParser.execute(token_els)
+          when 'def_func'
+            FuncParser.execute(token_els)
+          when 'differential'
+            del_var, formula = token_els
+            "d/d#{del_var}(#{FormulaParser.execute(formula)})"
           end
-          lexed.parsed!(parsed, token_position)
+          lexed.parsed!(parsed, $2)
 
-        when /:LPRN(\d):CONT\d:RPRN(\d)/
-          tokens_range = $1.to_i..$2.to_i
-          token_val = lexed.lexeds[tokens_range.to_a[1]][:CONT]
+        when /:LPRN(\d+):CONT(\d+):RPRN(\d+)/
+          tokens_range = $1.to_i..$3.to_i
+          token_val = lexed[$2][:CONT]
 
-          cont_lexed = Lexer::ContLexer.new(token_val)
-          cont = cont_lexed.values.join(' ')
-          lexed.parsed!(cont.parentheses, tokens_range)
+          lexed.parsed!(token_val.parentheses, tokens_range)
 
-        when /:LBRC(\d):CONT\d:RBRC(\d)/
-          tokens_range = $1.to_i..$2.to_i
-          token_val = lexed.lexeds[tokens_range.to_a[1]][:CONT]
+        when /:LBRCS(\d+):CONT(\d+):RBRCS(\d+)/
+          tokens_range = $1.to_i..$3.to_i
+          token_val = lexed[$2][:CONT]
 
           cont = case token_val
-            when %r@#{ONEHASH}(#{CMA}#{ONEHASH})*@
+            when /#{ONEHASH}(#{CMA}#{ONEHASH})*/
               ListParser.execute(token_val)
             else
               token_val
@@ -62,22 +58,14 @@ module Qlang
 
           lexed.parsed!(cont, tokens_range)
 
-        when /:eval_func(\d)/
+        when /:FUNCCN(\d+)/
           token_val = lexed.get_value($1)
           lexed.parsed!(token_val.parentheses, $1)
 
-        when /:differential(\d)/
-          token_position = $1.to_i
-          cont = lexed.get_value(token_position)
-          cont =~ /(d\/d[a-zA-Z]) (.*)/
-          cont = "#{$1}(#{FormulaParser.execute($2)})"
-          # FIX: Refactor
-          #cont.gsub!(/(d\/d[a-zA-Z]) (.*)/, "\1(\2)")
-          lexed.parsed!(cont.parentheses, token_position)
-        when /:CONT(\d)/
+        when /:CONT(\d+)/
           lexed.parsed!(lexed.get_value($1), $1)
         end
-        lexed.squash!(($1.to_i)..($1.to_i+1)) if lexed.token_str =~ /(?::CONT|:R)(\d)(?::CONT|:R)(\d)/
+        lexed.squash!(($1.to_i)..($1.to_i+1)) if lexed.token_str =~ /:(?:CONT|R)(\d+):(?:CONT|R)(\d+)/
       end
 
       LangEqualizer.execute(

data/lib/qlang/parser/formula_parser.rb

@@ -1,36 +1,36 @@
+require 'qlang/lexer/formula_lexer'
+
 module Qlang
   module Parser
-    # FIX:
     module FormulaParser
-      def execute(lexed)
-        ss = StringScanner.new(lexed)
-        result = ''
-        until ss.eos?
-          { EXP: /\^/, BFUNC: /sin|cos|tan|log/, MUL: /(pi|[1-9a-z]){2,}/, SNGL: /(pi|[1-9a-z])/, OTHER: /([^\^1-9a-z]|^pi)+/ }.each do |token , rgx|
-            if ss.scan(rgx)
-              item = case token
-              when :EXP
-                $meta_info.lang == :ruby ? '**' : '^'
-              when :MUL
-                sss = StringScanner.new(ss[0])
-                ary = []
-                until sss.eos?
-                  [/pi/, /[1-9a-z]/].each do |rgx2|
-                    ary << sss[0] if sss.scan(rgx2)
-                  end
-                end
-                ary.join(' * ')
-              else
-                ss[0]
+      include Lexer::Tokens
+
+      def self.execute(str)
+        lexed = Lexer::FormulaLexer.new(str)
+        time = Time.now
+        loop do
+          fail "I'm so sorry, something wrong. Please feel free to report this." if Time.now > time + 10
+          case lexed.token_str
+          when /:EXP(\d+)/
+            new_ope = $meta_info.lang == :ruby ? '**' : '^'
+            lexed.parsed!(new_ope, $1)
+          when /:MUL(\d+)/
+            sss = StringScanner.new(lexed.get_value($1))
+            ary = []
+            until sss.eos?
+              [/pi/, /[1-9a-z]/].each do |rgx2|
+                ary << sss[0] if sss.scan(rgx2)
               end
-              result += item
-              break
             end
+            parsed = ary.join(' * ')
+
+            lexed.parsed!(parsed, $1)
+          else
+            break
           end
         end
-        result
+        lexed.values.join
       end
-      module_function :execute
     end
   end
 end

data/lib/qlang/parser/func_parser.rb

@@ -4,8 +4,8 @@ module Qlang
     module FuncParser
       include Base
       include Lexer::Tokens
-      def execute(string)
-        def_func, formula = string.split(/ *= */)
+      def execute(els)
+        def_func, formula = els[0], els[1]
         def_func =~ /(#{USER_FUNC})#{LPRN}#{ANYSP}(#{VARS_BY_CMA})#{ANYSP}#{RPRN}/
         FuncApi.execute($1, $2.split(' *,'), FormulaParser.execute(formula))
       end

data/lib/qlang/parser/integral_parser.rb

@@ -2,8 +2,8 @@ module Qlang
   module Parser
     module IntegralParser
       include Base
-      def execute(string)
-        integrated, range = string.scan(/S *\((.+)\)\[(.+)\]/).first
+      def execute(els)
+        integrated, range = els[0], els[1]
 
         integrated.rm!(' ')
 

data/lib/qlang/parser/matrix_parser.rb

@@ -2,9 +2,9 @@ module Qlang
   module Parser
     module MatrixParser
       include Base
-      def execute(lexed_string, trans: false)
-        lexed_string.rms!(')','(', 't')
-        rows = lexed_string.split(/ *; */).map(&:split_by_sp)
+      def execute(els, opts={trans: false})
+        trans = opts[:trans]
+        rows = els.first.split(/ *(?:;|\n) */).map(&:split_by_sp)
         rows.all? { |row| row.count == rows.first.count }
         if trans
           rows = rows.transpose

data/lib/qlang/parser/vector_parser.rb

@@ -2,10 +2,10 @@ module Qlang
   module Parser
     module VectorParser
       include Base
-      def execute(lexed_string)
-        lexed_string.rms!(/ *\( */, / *\) */)
-        elements = lexed_string.split_by_sp
-        VectorApi.execute(elements)
+      def execute(els)
+        VectorApi.execute(
+          els.first.rm(/\A +/).rm(/ +\z/).split_by_sp
+        )
       end
       module_function :execute
     end

data/lib/qlang/version.rb

@@ -1,3 +1,3 @@
 module Qlang
-  VERSION = "0.0.27182000"
+  VERSION = "0.0.27182100"
 end

data/{q_lang.gemspec → qlang.gemspec}

@@ -8,6 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Qlang::VERSION
   spec.authors       = ['gogotanaka']
   spec.email         = ['mail@tanakakazuki.com']
+  spec.extensions    = ["ext/qlang/extconf.rb"]
   spec.summary       = %q{Enjoy MATH!}
   spec.description   = %q{Enjoy MATH!}
   spec.homepage      = 'http://q-language.org/'
@@ -20,7 +21,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "dydx", '~> 0.1.41421'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest"
 end

data/test/internal/test_tokens.rb

@@ -0,0 +1,36 @@
+require 'minitest_helper'
+
+class TestTokens < MiniTest::Unit::TestCase
+  include Qlang::Lexer::Tokens
+  def setup
+
+  end
+
+  def full_match(rgx, str)
+    assert_equal(0, rgx =~ str)
+    assert_equal(str, $&)
+  end
+
+  def not_match(rgx, str)
+    assert_equal(nil, rgx =~ str)
+  end
+
+  def test_nums
+    full_match(NUM, '1')
+    full_match(NUM, '234987423')
+    full_match(NUM, '23423948.298743')
+    full_match(NUM, 'e')
+    full_match(NUM, 'pi')
+    not_match(NUM, 'a')
+  end
+
+  def test_function
+    full_match(/[fgh]\(\w( ?, ?\w)*\) ?= ?[^\r\n]+/, 'f(x) = xy')
+  end
+
+  def test_differentiate
+    rgx = /d\/d[a-zA-Z] .*/
+    full_match(rgx, 'd/dx sin(x)')
+    full_match(rgx, 'd/dz z^2')
+  end
+end

data/test/interpreter/base.rb

@@ -0,0 +1,17 @@
+require 'qlang/iq'
+
+class TestInterpreterBase < MiniTest::Unit::TestCase
+  # TODO: opposite
+  def assert_iq_equal(input, output)
+    assert_equal(Qlang::Iq.execute(input), output)
+  end
+
+  def assert_def_func(input, output)
+    assert_equal(Qlang::Iq.execute(input), output)
+  end
+
+  def assert_cal_func(input, output)
+    assert_equal(Qlang::Iq.execute(input), output)
+    reset
+  end
+end

data/test/interpreter/test_differential.rb

@@ -0,0 +1,44 @@
+require 'minitest_helper'
+
+class TestDifferential < TestInterpreterBase
+  def setup
+
+  end
+
+  def test_general
+    assert_iq_equal(
+      'd/dx(e ** x)',
+      'e ^ x'
+    )
+
+    assert_iq_equal(
+      'd/dx(x ** 2)',
+      '2x'
+    )
+
+    assert_iq_equal(
+      'd/dx(x * 2)',
+      '2'
+    )
+
+    assert_iq_equal(
+      'd/dx( sin(x) )',
+      'cos( x )'
+    )
+
+    assert_iq_equal(
+      'd/dx(log( x ))',
+      '1 / x'
+    )
+
+    assert_iq_equal(
+      'd/dx cos(x)',
+      '- sin( x )'
+    )
+
+    assert_iq_equal(
+      'd/dx xx',
+      '2x'
+    )
+  end
+end

data/test/interpreter/test_function.rb

@@ -0,0 +1,45 @@
+require 'minitest_helper'
+
+class TestFunction < TestInterpreterBase
+  def setup
+
+  end
+
+  def test_general
+    assert_def_func('f(x, y) = x + y', 'x + y')
+    assert_cal_func('f( 4, 5 )', '9.0')
+
+    assert_def_func('f( x     ,    y) = xy', 'x * y')
+    assert_cal_func('f( 3, 9 )', '27.0')
+
+    assert_def_func('f(x, y) = xy^2', 'x * ( y ** 2 )')
+    assert_cal_func('f( 3, 2 )', '12.0')
+
+    assert_def_func('f(x, y) = xy^2', 'x * ( y ** 2 )')
+    assert_cal_func('df/dx', 'y ^ 2')
+
+    assert_def_func('g(x) = x ^ 2', 'x ** 2')
+    assert_cal_func('g(2)', '4.0')
+
+    assert_def_func('h(x) = e ^ 2', 'e ** 2')
+    assert_cal_func('h(2)', '7.3890560989306495')
+
+    assert_def_func('h(x) = pix', 'pi * x')
+    assert_cal_func('h(3)', '9.42477796076938')
+
+    assert_def_func('h(x) = pie', 'pi * e')
+    assert_cal_func('h(2)', '8.539734222673566')
+
+    assert_def_func('h(x) = ( 1 / ( 2pi ) ^ ( 1 / 2.0 ) ) * e ^ ( - x ^ 2 / 2 )', '( ( 4503599627370496 / 6369051672525773 ) / ( pi ** 0.5 ) ) * ( e ** ( ( - ( x ** 2 ) ) / 2 ) )')
+    assert_cal_func('S( h(x)dx )[-oo..oo]', '1.0')
+
+    assert_def_func('f(x) = sin(x)', 'sin( x )')
+    assert_cal_func('f(pi)', '0.0')
+
+    assert_def_func('f(x) = cos(x)', 'cos( x )')
+    assert_cal_func('f(pi)', '-1.0')
+
+    assert_def_func('f(x) = log(x)', 'log( x )')
+    assert_cal_func('f(e)', '1.0')
+  end
+end