hilbert 0.0.2700000

data/lib/qlang/exec.rb

@@ -0,0 +1,64 @@
+module Qlang
+  module Exec
+    class Compiler
+      def initialize(args)
+        @args = args
+      end
+
+      def output!
+        ch_compile_type(@args.first)
+        parse_string = parse(@args[1])
+        write!(@args[2], parse_string)
+
+      rescue Exception => e
+        raise e if @options[:trace] || e.is_a?(SystemExit)
+
+        print "#{e.class}: " unless e.class == RuntimeError
+        puts "#{e.message}"
+        puts '  Use --trace for backtrace.'
+        exit 1
+      ensure
+        exit 0
+      end
+
+      private
+
+      def ch_compile_type(lang)
+        case lang
+        when '-rb'
+          Qlang.to_ruby
+        when '-r'
+          Qlang.to_r
+        when '-py'
+          Qlang.to_python
+        else
+          print 'Q support only Ruby and R now.'
+        end
+      end
+
+      def parse(file_path)
+        file = open_file(file_path)
+        input_string = read_file(file)
+        file.close
+        input_string.gsub(/(.*)I love mathematics\.(.*)Q\.E\.D(.*)/m) {
+          "#{$1}#{Kconv.tosjis(Qlang.compile($2))}#{$3}"
+        }
+      end
+
+      def write!(output_path, string)
+        open(output_path, 'w') do |f|
+          f.puts string
+        end
+      end
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        File.open(filename, flag)
+      end
+
+      def read_file(file)
+        file.read
+      end
+    end
+  end
+end

data/lib/qlang/iq.rb

@@ -0,0 +1,45 @@
+require 'dydx'
+include Dydx
+
+module Qlang
+  module Iq
+    class Dydx::Algebra::Formula
+      # FIX:
+      def to_q
+        str = to_s.gsub(/\*\*/, '^').rm(' * ')
+        str.equalize!
+      end
+    end
+
+    def self.execute(code)
+      ruby_code = Q.to_ruby.compile(code.encode('utf-8'))
+      ruby_obj = eval(ruby_code)
+
+      optimize_output(ruby_obj).encode('utf-8')
+    rescue SyntaxError
+      # TODO: emergency
+      case ruby_code
+      when /(\d)+(\w)/
+        execute("#{$1} * #{$2}")
+      end
+    end
+
+    def self.optimize_output(ruby_obj)
+
+      case ruby_obj
+      when Matrix, Vector, Dydx::Algebra::Formula
+        ruby_obj.to_q
+      when Numeric
+        # TODO: I know you wanna way..
+        if    ruby_obj > 10000.0            then 'oo'
+        elsif ruby_obj < -10000.0           then '-oo'
+        elsif ruby_obj.abs < Float::EPSILON then '0.0'
+        else                                     ruby_obj.to_s.equalize!
+        end
+      else
+        str = ruby_obj.to_s
+        str.equalize!
+      end
+    end
+  end
+end

data/lib/qlang/lexer/base.rb

@@ -0,0 +1,107 @@
+require 'strscan'
+require 'qlang/lexer/tokens'
+
+module Qlang
+  module Lexer
+    class Base
+      attr_accessor :lexeds
+      include Tokens
+      class << self
+        attr_reader :token_rule_hash
+
+        def rule(pattern, &token)
+          token ||= proc { :NULL }
+          @token_rule_hash ||= {}
+          @token_rule_hash[pattern] = token.call
+        end
+      end
+
+      def initialize(str)
+        ss = StringScanner.new(str)
+        @lexeds = []
+        until ss.eos?
+          scan_rslt, ss = scan(ss)
+          if scan_rslt
+            @lexeds << scan_rslt unless scan_rslt[:token] == :NULL
+          else
+            fail "I'm so sorry, something wrong. Please feel free to report this."
+          end
+        end
+      end
+
+      def scan(ss)
+        scan_rslt = nil
+        token_rule_hash.each do |pattern, token|
+          if ss.scan(pattern)
+            scan_rslt = {
+              token: token,
+              value: ss[0],
+              els: 4.times.inject([]) { |s,i|s << ss[i+1] }.compact
+            }
+            break
+          end
+        end
+        [scan_rslt, ss]
+      end
+
+      # Accessor
+      ## GET(without side effect)
+      def get_value(num)
+        num = num.to_i
+        @lexeds[num][:value]
+      end
+
+      def get_els(num)
+        num = num.to_i
+        @lexeds[num][:els]
+      end
+
+      def token_str
+        @lexeds.map.with_index { |lexed, i| ":#{lexed[:token]}#{i}" }.join
+      end
+
+      def token_rule_hash
+        self.class.token_rule_hash
+      end
+
+      ## POST(with side effect, without idempotence.)
+      def parsed!(parsed, target)
+        case target
+        when Range
+          parsed_between!((target.first.to_i)..(target.last.to_i), parsed)
+        else
+          parsed_at!(target.to_i, parsed)
+        end
+      end
+
+      # squash!(range, token: :CONT)
+      def squash!(range, opts = { token: :CONT })
+        token = opts[:token]
+        range = (range.first.to_i)..(range.last.to_i)
+        value = values[range].join
+        range.count.times { @lexeds.delete_at(range.first) }
+        @lexeds.insert(range.first, { token: token, value: value })
+      end
+
+      # Legacy Accessor
+      def values
+        @lexeds.map { |lexed| lexed[:value] }
+      end
+
+      private
+
+      def parsed_at!(token_position, parsed)
+        @lexeds.delete_at(token_position)
+        @lexeds.insert(token_position, { token: :R, value: parsed })
+      end
+
+      def parsed_between!(token_range, parsed)
+        start_pos = token_range.first
+        token_range.count.times do
+          @lexeds.delete_at(start_pos)
+        end
+        @lexeds.insert(start_pos, { token: :R, value: parsed })
+      end
+    end
+  end
+end

data/lib/qlang/lexer/formula_lexer.rb

@@ -0,0 +1,20 @@
+module Qlang
+  module Lexer
+    class FormulaLexer < Base
+      rule(/\^/) { :EXP }
+      rule(/#{EMBEDDED_FUNC}/) { :BFUNC }
+      rule(/(pi|[1-9a-z]){2,}/) { :MUL }
+      rule(/(pi|[1-9a-z])/) { :SNGL }
+      rule(/([^\^1-9a-z]|^pi)+/) { :OTHER }
+
+      # rule(/#{OPE}/) { :OPE }
+      # rule(/#{FUNCV}/) { :FUNCV }
+      # rule(/#{VAR}/) { :VAR }
+      # rule(/#{NUM}/) { :NUM }
+      # rule(/#{LPRN}/) { :LPRN }
+      # rule(/#{RPRN}/) { :RPRN }
+
+      # rule(/#{ANYSP}/) {  }
+    end
+  end
+end

data/lib/qlang/lexer/main_lexer.rb

@@ -0,0 +1,34 @@
+#!/bin/env ruby
+# encoding: utf-8
+
+module Qlang
+  module Lexer
+    class MainLexer < Base
+      rule(/(#{FUNCCV})#{ANYSP}#{EQL}#{ANYSP}(#{FORMULA})/) { :def_func }
+      rule(/#{ITGRLSYM}#{ANYSP}#{LPRN}(#{ANYSTR})#{RPRN}#{LBRCT}(#{ANYSTR})#{RBRCT}/) { :integral }
+      rule(/d\/d(#{VAR}) (#{FORMULA})/) { :differential }
+
+      rule(/lim#{LBRCT}(#{VAR})#{RSARW}(#{VARNUM})#{RBRCT} (#{FORMULA})/) { :limit }
+
+      rule(/#{LPRN}(#{NUMS_BY_SP})#{RPRN}/) { :vector }
+      rule(/#{LPRN}(#{NUMS_BY_SP_BY_SCLN_OR_NELN})#{RPRN}t/m) { :tmatrix }
+      rule(/#{LPRN}(#{NUMS_BY_SP_BY_SCLN_OR_NELN})#{RPRN}/m) { :matrix }
+
+      rule(/∑#{LBRCT}(#{VAR})=(#{INT}),#{ANYSP}(#{INT})#{RBRCT} (#{FORMULA})/) { :sigma }
+      rule(/sigma#{LBRCT}(#{VAR})=(#{INT}),#{ANYSP}(#{INT})#{RBRCT} (#{FORMULA})/) { :sigma }
+
+      rule(/#{FUNCCN}/) { :FUNCCN }
+
+      rule(/#{LPRN}/) { :LPRN }
+      rule(/#{RPRN}/) { :RPRN }
+      rule(/#{LBRCS}/) { :LBRCS }
+      rule(/#{RBRCS}/) { :RBRCS }
+
+      rule(/[ \t\f]/)
+
+      rule(/(\r|\n)+/) { :NULL }
+
+      rule(/[^\(\)\{\}(\n\n)]+/) { :CONT }
+    end
+  end
+end

data/lib/qlang/lexer/tokens.rb

@@ -0,0 +1,94 @@
+module Qlang
+  module Lexer
+    module Tokens
+      # NUM
+      INT = /[0-9]+/
+      FLO = /[0-9]+\.[0-9]+/
+      E = /e/
+      PI = /pi/
+      INF = /oo/
+      NUM = /(?:#{FLO}|#{INT}|#{E}|#{PI}|#{INF})/
+
+      # FUNCTION
+      LPRN = /\(/
+      RPRN = /\)/
+      EMBEDDED_FUNC = /(?:sin|cos|tan|log)/
+      USER_FUNC = /[a-zA-Z]/
+      # h(x + y) != h * (x + y)
+      FUNCV = /(?:#{EMBEDDED_FUNC}|#{USER_FUNC})(?=#{LPRN})/
+
+      # VARIABLE
+      VAR = /(?:[a-d]|[f-z])/
+      # VAR_MUL2 = /(?!pi)#{VAR}{2}/
+      # #VAR_MUL3 = /(?!#{EMBEDDED_FUNC})#{VAR}{3}/
+      # # FIX:
+      # VAR_MUL  = /(?!#{EMBEDDED_FUNC})#{VAR_MUL2}/
+
+      # # TERM
+      # TERM = /(#{NUM}|#{VAR_MUL}|#{VAR_MUL})/
+
+      # OPE
+      PLS = /\+/
+      SUB = /-/
+      MUL = /\*/
+      DIV = /\//
+      EXP = /(\*\*|\^)/
+      OPE = /(?:#{PLS}|#{SUB}|#{MUL}|#{DIV}|#{EXP})/
+
+      VARNUM = /(?:#{NUM}|#{VAR})/
+      ANYSP = ' *'
+      ANYSTR = /.+/
+      NONL = /[^\r\n]/
+
+      PRN = /(?:#{LPRN}|#{RPRN})/
+
+      LBRCS = /\{/
+      RBRCS = /\}/
+      BRCS = /(?:#{LBRCS}|#{RBRCS})/
+
+      LBRCT = /\[/
+      RBRCT = /\]/
+      BRCT = /(?:#{LBRCT}|#{RBRCT})/
+
+      CLN = /\:/
+      SCLN = /;/
+      CMA = /\,/
+      EQL = /\=/
+
+      RSARW = '->'
+      LSARW = '<-'
+      RDARW = '=>'
+      LDARW = '<='
+      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}/
+        end
+
+        def self.func_call(args)
+          /#{FUNCV}#{LPRN}#{ANYSP}#{args}#{ANYSP}#{RPRN}/
+        end
+      end
+
+      NUMS_BY_CMA = Util.string_out(NUM, CMA)
+      VARS_BY_CMA = Util.string_out(VAR, CMA)
+      VARNUMS_BY_CMA = Util.string_out(VARNUM, CMA)
+      NUMS_BY_SP = Util.string_out(NUM, SP)
+
+      FUNCCN =  Util.func_call(NUMS_BY_CMA)
+      FUNCCV = Util.func_call(VARS_BY_CMA)
+      FUNCCVN =  Util.func_call(VARNUMS_BY_CMA)
+
+      NUMS_BY_SP_BY_SCLN_OR_NELN = Util.string_out(NUMS_BY_SP, SCLN_OR_NELN)
+
+      FORMULA = /(?:#{OPE}|#{FUNCV}|#{VAR}|#{NUM}|#{PRN}|#{ANYSP})+/
+    end
+  end
+end

data/lib/qlang/lexer.rb

@@ -0,0 +1,11 @@
+require 'qlang/lexer/base'
+require 'qlang/lexer/main_lexer'
+
+module Qlang
+  module Lexer
+    def execute(str)
+      MainLexer.new(str)
+    end
+    module_function :execute
+  end
+end

data/lib/qlang/meta_info.rb

@@ -0,0 +1,27 @@
+# $meta_info indicate what and how to do.
+
+class MetaInfo
+  include Singleton
+  attr_accessor :lang, :opts, :mode
+
+  def _load
+    # compiles into R as default.
+    lang = :r
+  end
+
+  # TODO: YAML.load_file("./lib/qlang/utils/langs.yml")['langs']
+  def langs_hash
+    {
+      r: 'R',
+      ruby: 'Ruby',
+      python: 'Pyhton',
+      haskell: 'Haskell',
+      scala: 'Scala',
+      js: 'Javascript'
+    }
+  end
+
+  def lang_str
+    LANGS_HASH[@lang.to_s]
+  end
+end

data/lib/qlang/parser/base.rb

@@ -0,0 +1,7 @@
+module Qlang
+  module Parser
+    module Base
+      include ::Qlang::Api
+    end
+  end
+end

data/lib/qlang/parser/formula_parser.rb

@@ -0,0 +1,36 @@
+require 'qlang/lexer/formula_lexer'
+
+module Qlang
+  module Parser
+    module FormulaParser
+      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
+            end
+            parsed = ary.join(' * ')
+
+            lexed.parsed!(parsed, $1)
+          else
+            break
+          end
+        end
+        lexed.values.join
+      end
+    end
+  end
+end

data/lib/qlang/parser/func_parser.rb

@@ -0,0 +1,15 @@
+require 'qlang/lexer/tokens'
+module Qlang
+  module Parser
+    module FuncParser
+      include Base
+      include Lexer::Tokens
+      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
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser/integral_parser.rb

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

data/lib/qlang/parser/limit_parser.rb

@@ -0,0 +1,16 @@
+module Qlang
+  module Parser
+    module LimitParser
+      include Base
+      def self.execute(els)
+        var, close_to, formula = els
+
+        LimitApi.execute(
+          FormulaParser.execute(formula),
+          var,
+          close_to
+        )
+      end
+    end
+  end
+end

data/lib/qlang/parser/list_parser.rb

@@ -0,0 +1,12 @@
+module Qlang
+  module Parser
+    module ListParser
+      include Base
+      def execute(lexed)
+        arys = lexed.split(/ *, */).map { |e| e.split(/ *: */).map { |e2| e2.delete(' ') } }
+        ListApi.execute(arys)
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser/matrix_parser.rb

@@ -0,0 +1,17 @@
+module Qlang
+  module Parser
+    module MatrixParser
+      include Base
+      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
+        end
+        MatrixApi.execute(rows)
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser/sigma_parser.rb

@@ -0,0 +1,17 @@
+module Qlang
+  module Parser
+    module SigmaParser
+      include Base
+      def self.execute(els)
+        var, from, to, formula = els
+
+        SigmaApi.execute(
+          FormulaParser.execute(formula),
+          var,
+          from,
+          to
+        )
+      end
+    end
+  end
+end

data/lib/qlang/parser/vector_parser.rb

@@ -0,0 +1,13 @@
+module Qlang
+  module Parser
+    module VectorParser
+      include Base
+      def execute(els)
+        VectorApi.execute(
+          els.first.rm(/\A +/).rm(/ +\z/).split_by_sp
+        )
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/parser.rb

@@ -0,0 +1,101 @@
+require 'qlang/api'
+
+require 'qlang/parser/base'
+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/limit_parser'
+require 'qlang/parser/sigma_parser'
+
+require 'qlang/parser/formula_parser'
+
+module Qlang
+  module Parser
+    include Lexer::Tokens
+    SYM = '\w+'
+    ONEHASH = "#{ANYSP}#{SYM}#{CLN}#{ANYSP}#{VARNUM}#{ANYSP}" # sdf: 234
+    def execute(lexed)
+      time = Time.now
+      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+)/, /:(differential)(\d+)/, /:(limit)(\d+)/, /:(sigma)(\d+)/
+          token_els = lexed.get_els($2)
+
+          parsed =
+            case $1
+            when 'vector'
+              VectorParser.execute(token_els)
+            when 'matrix'
+              MatrixParser.execute(token_els)
+            when 'tmatrix'
+              MatrixParser.execute(token_els, trans: true)
+            when 'limit'
+              LimitParser.execute(token_els)
+            when 'integral'
+              IntegralParser.execute(token_els)
+            when 'def_func'
+              FuncParser.execute(token_els)
+            when 'sigma'
+              SigmaParser.execute(token_els)
+            when 'differential'
+              del_var, formula = token_els
+              "d/d#{del_var}(#{FormulaParser.execute(formula)})"
+            end
+          lexed.parsed!(parsed, $2)
+
+        when /:LPRN(\d+):CONT(\d+):RPRN(\d+)/
+          tokens_range = $1.to_i..$3.to_i
+          token_val =
+
+          lexed.parsed!(
+            lexed.get_value($2).parentheses,
+            tokens_range
+          )
+
+        when /:LBRCS(\d+):CONT(\d+):RBRCS(\d+)/
+          tokens_range = $1.to_i..$3.to_i
+          token_val = lexed.get_value($2)
+
+          cont =
+            case token_val
+            when /#{ONEHASH}(#{CMA}#{ONEHASH})*/
+              ListParser.execute(token_val)
+            else
+              token_val
+            end
+
+          lexed.parsed!(cont, tokens_range)
+
+        when /:FUNCCN(\d+)/
+          token_val = lexed.get_value($1)
+          lexed.parsed!(token_val.parentheses, $1)
+
+        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+)/
+      end
+
+      LangEqualizer.execute(
+        lexed.values.join
+      )
+    end
+    module_function :execute
+
+    # FIXIT
+    class LangEqualizer
+      def self.execute(str)
+        case $meta_info.lang
+        when :ruby
+          str.gsub(/\^/, '**')
+        else
+          str
+        end
+      end
+    end
+  end
+end

data/lib/qlang/utils/langs.yml

@@ -0,0 +1,7 @@
+langs:
+  :r: R
+  :ruby: Ruby
+  :python: Pyhton
+  :haskell: Haskell
+  :scala: Scala
+  :js: Javascript