qlang 0.0.14 → 0.0.27

data/lib/qlang/lexer/wrap_lexer.rb

@@ -1,7 +1,16 @@
+require 'pry'
 module Qlang
   module Lexer
     class WrapLexer < Base
-      rule(/\w\(\w( ?, ?\w)*\) ?= ?[^\r\n]+/)  { :FUNC }
+      rule(%r@#{FUNCCV}#{ANYSP}=#{ANYSP}#{NONL}+@) { :def_func }
+      rule(%r@#{FUNCCN}@) { :eval_func }
+      rule(/S#{ANYSP}#{LPRN}#{ANYSTR}#{RPRN}\[#{ANYSTR}\]/) { :integral }
+      rule(/d\/d#{VAR} .*/) { :differential }
+      rule(%r@#{LPRN}#{NUMS_BY_SP}#{RPRN}@) { :vector }
+      rule(%r@#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}t@) { :tmatrix }
+      rule(%r@#{LPRN}#{NUMS_BY_SP_BY_SCLN}#{RPRN}@) { :matrix }
+
+
       rule(/\(/) { :LPRN }
       rule(/\)/) { :RPRN }
       rule(/\{/) { :LBRC }

data/lib/qlang/parser.rb

@@ -8,55 +8,75 @@ require 'qlang/parser/matrix_parser'
 require 'qlang/parser/vector_parser'
 require 'qlang/parser/list_parser'
 require 'qlang/parser/func_parser'
+require 'qlang/parser/integral_parser'
+require 'qlang/parser/formula_parser'
 
 module Qlang
   module Parser
     def execute(lexed)
       time = Time.now
       until lexed.token_str =~ /\A(:NLIN\d|:R\d)+\z/
-        binding.pry if Time.now > time + 10
+        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]
+
+          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)
+          end
+          lexed.parsed!(token_position, parsed)
+
         when /:LPRN\d(:CONT\d):RPRN\d/
           cont_token_with_num = $1
           cont_lexed = Lexer::ContLexer.new(lexed.get_value(cont_token_with_num))
 
-          case cont_lexed.token_str
-          when /(:NUM\d)+(:SCLN\d|:NLIN\d)(:NUM\d)/
-            cont = MatrixParser.execute(cont_lexed)
-            lexed.squash_with_prn(cont_token_with_num, cont)
-          when /(:NUM\d)+/
-            cont = VectorParser.execute(cont_lexed)
-            lexed.squash_with_prn(cont_token_with_num, cont)
-          end
+          cont = "(#{cont_lexed.values.join(' ')})"
+          lexed.squash_with_prn(cont_token_with_num, cont)
 
         when /:LBRC\d(:CONT\d):RBRC\d/
           cont_token_with_num = $1
           cont_lexed = Lexer::ContLexer.new(lexed.get_value(cont_token_with_num))
 
           case cont_lexed.token_str
-          when /(:OTHER\d:CLN\d(:STR\d|:NUM\d|:R\d):CMA)*(:OTHER\d:CLN\d(:STR\d|:NUM\d|:R\d))/
+          when /(:SYM\d:CLN\d(:STR\d|:NUM\d|:R\d):CMA)*(:SYM\d:CLN\d(:STR\d|:NUM\d|:R\d))/
             cont = ListParser.execute(cont_lexed)
-            lexed.squash_with_prn(cont_token_with_num, cont)
+          else
+            cont = "{#{cont_lexed.values.join(' ')}}"
           end
+          lexed.squash_with_prn(cont_token_with_num, cont)
 
-        when /:FUNC\d/
+        when /:eval_func\d/
           cont_token_with_num = $&
-          cont_lexed = Lexer::FuncLexer.new(lexed.get_value(cont_token_with_num))
-
-          case cont_lexed.token_str
-          when /:FDEF\d:EQL\d:OTHER\d/
-            cont = FuncParser.execute(cont_lexed)
-            lexed.ch_value(cont_token_with_num, cont)
-            lexed.ch_token(cont_token_with_num, :R)
-          end
+          cont = lexed.get_value(cont_token_with_num)
+          lexed.squash_with_prn(cont_token_with_num, cont)
 
+        when /:differential\d/
+          cont_token_with_num = $&
+          cont = lexed.get_value(cont_token_with_num)
+          cont =~ /(d\/d[a-zA-Z]) (.*)/
+          cont = "#{$1}(#{FormulaParser.execute($2)})"
+          # FIX: Refactor
+          #cont.gsub!(/(d\/d[a-zA-Z]) (.*)/, "\1(\2)")
+          lexed.squash_with_prn(cont_token_with_num, cont)
         when /:CONT\d/
           lexed.ch_token($&, :R)
         end
 
         lexed.squash_to_cont($1, 2) if lexed.token_str =~ /(:CONT\d|:R\d)(:CONT\d|:R\d)/
       end
+
       lexed.fix_r_txt!
       lexed.values.join
     end

data/lib/qlang/parser/base.rb

@@ -2,19 +2,6 @@ module Qlang
   module Parser
     module Base
       include ::Qlang::Api
-      # TODO:
-      class ::String
-        def rm(str_or_rgx)
-          gsub!(str_or_rgx, '')
-        end
-
-        def rms(*str_or_rgxs)
-          str_or_rgxs.each do |str_or_rgx|
-            rm(str_or_rgx)
-          end
-          self
-        end
-      end
     end
   end
 end

data/lib/qlang/parser/formula_parser.rb

@@ -0,0 +1,36 @@
+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
+                $type == :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]
+              end
+              result += item
+              break
+            end
+          end
+        end
+        result
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser/func_parser.rb

@@ -1,14 +1,13 @@
+require 'qlang/lexer/tokens'
 module Qlang
   module Parser
     module FuncParser
       include Base
-      def execute(lexed)
-        lexed.fix_r_txt!
-        fdef_ary = lexed[0][:FDEF].split('')
-        func_name = fdef_ary.shift
-        args = fdef_ary.join.rms('(', ')', ',', ' ').split('')
-
-        FuncApi.execute(func_name, args, lexed[-1][:OTHER])
+      include Lexer::Tokens
+      def execute(string)
+        def_func, formula = string.split(/ *= */)
+        def_func =~ %r@(#{FUNCV})#{LPRN}#{ANYSP}(#{VARS_BY_CMA})#{ANYSP}#{RPRN}@
+        FuncApi.execute($1, $2.split(' *,'), FormulaParser.execute(formula))
       end
       module_function :execute
     end

data/lib/qlang/parser/integral_parser.rb

@@ -0,0 +1,15 @@
+module Qlang
+  module Parser
+    module IntegralParser
+      include Base
+      def execute(string)
+        integrated, range = string.scan(/S *\((.+)\)\[(.+)\]/).first
+
+        integrated.rm!(' ')
+
+        IntegralApi.execute(FormulaParser.execute(integrated[0..-3]), integrated[-2..-1], range)
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser/matrix_parser.rb

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

data/lib/qlang/parser/vector_parser.rb

@@ -2,8 +2,10 @@ module Qlang
   module Parser
     module VectorParser
       include Base
-      def execute(lexed)
-        VectorApi.execute(lexed.values)
+      def execute(lexed_string)
+        lexed_string.rms!(/ *\( */, / *\) */)
+        elements = lexed_string.split_by_sp
+        VectorApi.execute(elements)
       end
       module_function :execute
     end

data/lib/qlang/version.rb

@@ -1,3 +1,3 @@
 module Qlang
-  VERSION = "0.0.14"
+  VERSION = "0.0.27"
 end

data/q_lang.gemspec

@@ -18,8 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.add_dependency "dydx", '~> 0.1.41421'
+
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "dydx"
 end

data/spec/iq_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Qlang do
+  describe Iq do
+    def self.def_test(name, input, output)
+      it name + '_def' do
+        expect(Iq.execute(input)).to eq(output)
+      end
+    end
+
+    def self.cal_test(name, input, output)
+      it name + '_cal' do
+        expect(Iq.execute(input)).to eq(output)
+        reset
+      end
+    end
+
+    describe 'General' do
+      cal_test('ex1', '2x', '2x')
+      cal_test('ex2', 'x + x', '2x')
+      cal_test('ex3', 'x * y', 'xy')
+    end
+
+    describe 'Matrix' do
+      cal_test('ex1',
+        '(1 2 3; 4 5 6)',
+        '(1 2 3; 4 5 6)'
+      )
+
+      cal_test('ex2',
+        '(1 2 3; 4 5 6) + (1 2 3; 4 5 6)',
+        '(2 4 6; 8 10 12)'
+      )
+
+      cal_test('ex3',
+        '(1 2 3; 4 5 6) - (2 4 1; 8 3 9)',
+        '(-1 -2 2; -4 2 -3)'
+      )
+
+      cal_test('ex4',
+        '(1 2; 3 4) * (1 2; 3 4)',
+        '(7 10; 15 22)'
+      )
+
+      cal_test('ex5',
+        '(1 2; 3 4) ** 2',
+        '(7 10; 15 22)'
+      )
+
+      cal_test('ex6',
+        '(1 2; 3 4) ** 2',
+        '(7 10; 15 22)'
+      )
+
+      cal_test('ex7',
+        '(1 2; 3 4) * (1 2)',
+        '(5 11)'
+      )
+
+      cal_test('ex8',
+        '(1 2 3; 4 5 6)t',
+        '(1 4; 2 5; 3 6)'
+      )
+    end
+
+    describe 'Vector' do
+      it do
+        expect(Iq.execute('(1 2 3)')).to eq('(1 2 3)')
+        expect(Iq.execute('(1 2 3) + (1 2 3)')).to eq('(2 4 6)')
+        expect(Iq.execute('(1  2  3 )  +  ( 1 2 3 )')).to eq('(2 4 6)')
+        expect(Iq.execute('(1 2 3) - (1 2 3) - (1 2 3)')).to eq('(-1 -2 -3)')
+      end
+    end
+
+    describe 'List' do
+      it do
+      end
+    end
+
+    describe 'Diff' do
+      it do
+        expect(Iq.execute('d/dx(e ** x)')).to eq('e ^ x')
+        expect(Iq.execute('d/dx(x ** 2)')).to eq('2x')
+        expect(Iq.execute('d/dx(x * 2)')).to eq('2')
+        expect(Iq.execute('d/dx( sin(x) )')).to eq('cos( x )')
+        expect(Iq.execute('d/dx(log( x ))')).to eq('1 / x')
+      end
+      cal_test('ex1', 'd/dx cos(x)', '- sin( x )')
+      cal_test('ex2', 'd/dx xx', '2x')
+    end
+
+    describe 'Integral' do
+      it do
+        expect(Iq.execute('S( log(x)dx )[0..1]')).to eq('-oo')
+        expect(Iq.execute('S( sin(x)dx )[0..pi]')).to eq('2.0')
+        expect(Iq.execute('S( cos(x)dx )[0..pi]')).to eq('0.0')
+        expect(Iq.execute('S( cos(x)dx )[0..pi]')).to eq('0.0')
+      end
+      cal_test('ex1', 'S(xx dx)[0..1]', '0.33333333')
+      cal_test('ex2', 'S(2pi dx)[0..1]', '6.28318531')
+    end
+
+    describe 'Function' do
+      def_test('ex1', 'f(x, y) = x + y', 'x + y')
+      cal_test('ex1', 'f( 4, 5 )', '9.0')
+
+      def_test('ex2', 'f( x     ,    y) = xy', 'x * y')
+      cal_test('ex2', 'f( 3, 9 )', '27.0')
+
+      def_test('ex3', 'f(x, y) = xy^2', 'x * ( y ** 2 )')
+      cal_test('ex3', 'f( 3, 2 )', '12.0')
+
+      def_test('ex4', 'f(x, y) = xy^2', 'x * ( y ** 2 )')
+      cal_test('ex4', 'df/dx', 'y ^ 2')
+
+      def_test('ex5', 'g(x) = x ^ 2', 'x ** 2')
+      cal_test('ex5', 'g(2)', '4.0')
+
+      def_test('ex6', 'h(x) = e ^ 2', 'e ** 2')
+      cal_test('ex6', 'h(2)', '7.3890560989306495')
+
+      def_test('ex7', 'h(x) = pix', 'pi * x')
+      cal_test('ex7', 'h(3)', '9.42477796076938')
+
+      def_test('ex8', 'h(x) = pie', 'pi * e')
+      cal_test('ex8', 'h(2)', '8.539734222673566')
+
+      def_test('ex9', 'h(x) = ( 1 / ( 2pi ) ^ ( 1 / 2.0 ) ) * e ^ ( - x ^ 2 / 2 )', '( ( 4503599627370496 / 6369051672525773 ) / ( pi ** 0.5 ) ) * ( e ** ( ( - ( x ** 2 ) ) / 2 ) )')
+      cal_test('ex9', 'S( h(x)dx )[-oo..oo]', '1.0')
+
+      def_test('ex10', 'f(x) = sin(x)', 'sin( x )')
+      cal_test('ex10', 'f(pi)', '0.0')
+
+      def_test('ex11', 'f(x) = cos(x)', 'cos( x )')
+      cal_test('ex11', 'f(pi)', '-1.0')
+
+      def_test('ex11', 'f(x) = log(x)', 'log( x )')
+      cal_test('ex11', 'f(e)', '1.0')
+    end
+  end
+end

data/spec/lexer/regular_expressions_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Regular expressions' do
+  def self.should_match(num, rgx, str)
+    it 'ex' + num.to_s do
+      expect(rgx =~ str).to eq(0)
+    end
+  end
+  describe 'function' do
+    should_match(1, /[fgh]\(\w( ?, ?\w)*\) ?= ?[^\r\n]+/, 'f(x) = xy')
+  end
+
+  describe 'differentiate' do
+    rgx = /d\/d[a-zA-Z] .*/
+    should_match(1, rgx, 'd/dx sin(x)')
+    should_match(2, rgx, 'd/dz z^2')
+  end
+end

data/spec/objects/function_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Qlang do
+  describe 'Function' do
+    context 'into R' do
+      it do
+        expect(
+          Q.to_r.compile('f(x, y) = x + y')
+        ).to eq(
+          "f <- function(x, y) x + y"
+        )
+
+        expect(
+          Q.to_r.compile('g(x) = x ^ 2')
+        ).to eq(
+          "g <- function(x) x ^ 2"
+        )
+
+        expect(
+          Q.to_r.compile('g(x) = x ^ (2 + 2)')
+        ).to eq(
+          "g <- function(x) x ^ (2 + 2)"
+        )
+
+        expect(
+          Q.to_r.compile('h(a, b, c) = a ^ 2 + b ^ 2 + c ^ 2')
+        ).to eq(
+          "h <- function(a, b, c) a ^ 2 + b ^ 2 + c ^ 2"
+        )
+      end
+    end
+  end
+end