hilbert 0.0.2700001 → 0.0.2700100

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fd42993b7f3a7468a22b3a27c87106933b2d103
-  data.tar.gz: 63692355f00bae1ba2f6e64b18dc68430246d82b
+  metadata.gz: 9a0a3fec8ea8685b98cb92d396c58fb3467b85cf
+  data.tar.gz: 521413e76c6b6512e462695a6603d697da6b1a60
 SHA512:
-  metadata.gz: a10b5ce2eb9dc7a5ed093136b0a93f9c71b9efc6c942abe95664344127a7dc6641c7f4785504211d3acbb2cb3e5e3a8a540c0d252331223fb4c419dded3c0e52
-  data.tar.gz: 5ba9c0c6320dc87989ef4979d0ab89c783006843b0cd9db6bd881710a46c1c374225b2a788253ff5aa5e60591f7312d5c2dc179565db241acbf040f605659787
+  metadata.gz: 490d8872bf5cc5c9efea975fe3d596981080844229024916adaf35bbe607831a2f431b331490a91fd4dff83582ca836ff4ac19870b57713b9392bea46a70b4ee
+  data.tar.gz: 154c250c7a531e80b939bcc1ed8e382489ff1a9068240ea4118e5da29e7f7c01a071c7228157472e262d63bafc6bd72fac4b83eb29e0bff386b81950f1abd224

data/.coveralls.yml

@@ -1,2 +1,2 @@
-repo_token: ZdXKADwEPNW5PJkIaC76yjqq4w04dIpuZ
+repo_token: vkYcufANxPOOehtDBT4iHTX1xcWieP3px
 service_name: travis-ci

data/README.md

@@ -1,6 +1,6 @@
 # Hilbert
 
-[![Gem Version](https://badge.fury.io/rb/hilbert.svg)](http://badge.fury.io/rb/hilbert) [![Build Status](https://travis-ci.org/gogotanaka/Q.svg?branch=master)](https://travis-ci.org/gogotanaka/Q) [![Coverage Status](https://coveralls.io/repos/gogotanaka/Q/badge.png?branch=master)](https://coveralls.io/r/gogotanaka/Q?branch=master) [![Code Climate](https://codeclimate.com/github/gogotanaka/Q/badges/gpa.svg)](https://codeclimate.com/github/gogotanaka/Q) [![Dependency Status](https://gemnasium.com/gogotanaka/Q.svg)](https://gemnasium.com/gogotanaka/Q)
+[![Gem Version](https://badge.fury.io/rb/hilbert.svg)](http://badge.fury.io/rb/hilbert) [![Build Status](https://travis-ci.org/gogotanaka/Hilbert.svg?branch=master)](https://travis-ci.org/gogotanaka/Hilbert) [![Coverage Status](https://coveralls.io/repos/gogotanaka/Hilbert/badge.png?branch=master)](https://coveralls.io/r/gogotanaka/Hilbert?branch=master) [![Code Climate](https://codeclimate.com/github/gogotanaka/Hilbert/badges/gpa.svg)](https://codeclimate.com/github/gogotanaka/Hilbert) [![Dependency Status](https://gemnasium.com/gogotanaka/Hilbert.svg)](https://gemnasium.com/gogotanaka/Hilbert)
 
 ## Do you know the one best language in this world?
 
@@ -103,7 +103,7 @@ Install hilbert gem.
 ## Interpreter
 
     $ hilbert -i
-    Hilbert:->
+    Enjoy! ->
 
 ## Use as native language
 

data/bin/hilbert

@@ -2,17 +2,17 @@
 
 require 'hilbert'
 
-# Q command line
+# Hilbert command line
 require 'hilbert/exec'
 
-# Q interpreter
+# Hilbert interpreter
 require 'hilbert/iq'
 
 # TODO: There are vanch of todo ..
 case ARGV.first
 when '-i'
   loop do
-    print 'Q:-> '
+    print 'Enjoy! -> '
     begin
       input = $stdin.gets
       output = Hilbert::Iq.execute(input)

data/core/Q/Lexer.hs

@@ -1,9 +1,9 @@
 {- |
-Module      : Language.Q
+Module      : Language.Hilbert
 Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
 Licence     : MIT
 
 q-language.org.
 -}
 
-module Q.Lexer where
+module Hilbert.Lexer where

data/core/Q/Parser.hs

@@ -1,9 +1,9 @@
 {- |
-Module      : Language.Q
+Module      : Language.Hilbert
 Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
 Licence     : MIT
 
 q-language.org.
 -}
 
-module Q.Parser where
+module Hilbert.Parser where

data/core/Q.hs

@@ -1,19 +1,19 @@
 {- |
-Module      : Language.Q
+Module      : Language.Hilbert
 Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
 Licence     : MIT
 
 q-language.org.
 -}
 
-module Q
-       ( module Q.Lexer
-       , module Q.Parser
+module Hilbert
+       ( module Hilbert.Lexer
+       , module Hilbert.Parser
        , version
        ) where
 
 
-import Q.Lexer
-import Q.Parser
+import Hilbert.Lexer
+import Hilbert.Parser
 
 import Data.Version

data/ext/hilbert/hilbert.c

@@ -51,15 +51,15 @@ execute(VALUE self, VALUE a, VALUE b, VALUE n)
 void
 Init_hilbert(void)
 {
-  VALUE rb_mQMatrix = rb_define_class("QMatrix", rb_cObject);
-  rb_define_method(rb_mQMatrix, "execute", execute, 3);
-  rb_define_method(rb_mQMatrix, "func", rb_func, 1);
+  VALUE rb_mHilbertMatrix = rb_define_class("HilbertMatrix", rb_cObject);
+  rb_define_method(rb_mHilbertMatrix, "execute", execute, 3);
+  rb_define_method(rb_mHilbertMatrix, "func", rb_func, 1);
 }
 
-// VALUE rb_mQMatrix;
+// VALUE rb_mHilbertMatrix;
 
 // void
 // Init_q_matrix(void)
 // {
-//   rb_mQMatrix = rb_define_module("QMatrix");
+//   rb_mHilbertMatrix = rb_define_module("HilbertMatrix");
 // }

data/ext/hilbert/hilbert.h

@@ -1,6 +1,6 @@
-#ifndef QLANG_H
-#define QLANG_H 1
+#ifndef HilbertLANG_H
+#define HilbertLANG_H 1
 
 #include "ruby.h"
 
-#endif /* QLANG_H */
+#endif /* HilbertLANG_H */

data/hilbert.gemspec

@@ -19,7 +19,7 @@ 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_dependency 'dydx', '~> 0.2.7000000'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/legacy_rspec/objects/list_spec.rb

@@ -4,25 +4,25 @@ describe Hilbert do
   describe 'List' do
     it do
       # expect(
-      #   Q.to_r.compile('{name: "Gogotanaka", age:  21, birth: (1992 8 10) }')
+      #   Hilbert.to_r.compile('{name: "Gogotanaka", age:  21, birth: (1992 8 10) }')
       # ).to eq(
       #   "list(name=\"Gogotanaka\", age=21, birth=c(1992, 8, 10))"
       # )
 
       expect(
-        Q.to_r.compile('{key1: 234234, key2: 387342 }')
+        Hilbert.to_r.compile('{key1: 234234, key2: 387342 }')
       ).to eq(
         'list(key1=234234, key2=387342)'
       )
 
       expect(
-        Q.to_r.compile('{key1:234234,key2:387342,key3:38733242}')
+        Hilbert.to_r.compile('{key1:234234,key2:387342,key3:38733242}')
       ).to eq(
         'list(key1=234234, key2=387342, key3=38733242)'
       )
 
       # expect(
-      #   Q.to_r.compile('{key1:(1 3 2; 8 2 3),key2:387342,key3:38733242}')
+      #   Hilbert.to_r.compile('{key1:(1 3 2; 8 2 3),key2:387342,key3:38733242}')
       # ).to eq(
       #   "list(key1=matrix(c(1, 3, 2, 8, 2, 3), 2, 3, byrow = TRUE), key2=387342, key3=38733242)"
       # )

data/legacy_rspec/objects/matrix_spec.rb

@@ -5,25 +5,25 @@ describe Hilbert do
     context 'into R' do
       it do
         expect(
-          Q.to_r.compile('(1 2 3; 4 5 6)')
+          Hilbert.to_r.compile('(1 2 3; 4 5 6)')
         ).to eq(
           'matrix(c(1, 2, 3, 4, 5, 6), 2, 3, byrow = TRUE)'
         )
 
         expect(
-          Q.to_r.compile('(1 2 3 ; 4 5 6)')
+          Hilbert.to_r.compile('(1 2 3 ; 4 5 6)')
         ).to eq(
           'matrix(c(1, 2, 3, 4, 5, 6), 2, 3, byrow = TRUE)'
         )
 
         expect(
-          Q.to_r.compile('(1 2 3 ; 4 5 6; 7 8 9)')
+          Hilbert.to_r.compile('(1 2 3 ; 4 5 6; 7 8 9)')
         ).to eq(
           'matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9), 3, 3, byrow = TRUE)'
         )
 
         expect(
-          Q.to_r.compile('(1;2;3)')
+          Hilbert.to_r.compile('(1;2;3)')
         ).to eq(
           'matrix(c(1, 2, 3), 3, 1, byrow = TRUE)'
         )
@@ -33,19 +33,19 @@ describe Hilbert do
     context 'into Ruby' do
       it do
         expect(
-          Q.to_ruby.compile('(1 2 3; 4 5 6)')
+          Hilbert.to_ruby.compile('(1 2 3; 4 5 6)')
         ).to eq(
           'Matrix[[1, 2, 3], [4, 5, 6]]'
         )
 
         expect(
-          Q.to_ruby.compile('(1 2 3 ; 4 5 6; 7 8 9)')
+          Hilbert.to_ruby.compile('(1 2 3 ; 4 5 6; 7 8 9)')
         ).to eq(
           'Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]'
         )
 
         expect(
-          Q.to_ruby.compile('(1;2;3)')
+          Hilbert.to_ruby.compile('(1;2;3)')
         ).to eq(
           'Matrix[[1], [2], [3]]'
         )

data/legacy_rspec/objects/vector_spec.rb

@@ -5,19 +5,19 @@ describe Hilbert do
     context 'into R' do
       it do
         expect(
-          Q.to_r.compile('(1 2 3)')
+          Hilbert.to_r.compile('(1 2 3)')
         ).to eq(
           'c(1, 2, 3)'
         )
 
         expect(
-          Q.to_r.compile('(1 2 3 4 5 6)')
+          Hilbert.to_r.compile('(1 2 3 4 5 6)')
         ).to eq(
           'c(1, 2, 3, 4, 5, 6)'
         )
 
         expect(
-          Q.to_r.compile('(1   2    3  4      5   6)')
+          Hilbert.to_r.compile('(1   2    3  4      5   6)')
         ).to eq(
           'c(1, 2, 3, 4, 5, 6)'
         )
@@ -27,7 +27,7 @@ describe Hilbert do
     context 'into Ruby' do
       it do
         expect(
-          Q.to_ruby.compile('(1 2 3)')
+          Hilbert.to_ruby.compile('(1 2 3)')
         ).to eq(
           'Vector[1, 2, 3]'
         )
@@ -37,7 +37,7 @@ describe Hilbert do
     context 'into Python' do
       it do
         expect(
-          Q.to_python.compile('(1 2 3)')
+          Hilbert.to_python.compile('(1 2 3)')
         ).to eq(
           'array([1, 2, 3])'
         )

data/lib/hilbert/api/limit_api.rb

@@ -13,6 +13,9 @@ module Hilbert
             "temp_cal_f(#{var}) <= #{formula};
              temp_cal_f(#{close_to} + Float::EPSILON ** 20)"
           end
+        when :inter
+          Dydx::API.store_func(eval(var), eval(formula), :tmp)
+          Dydx::API.eval_func(eval(close_to) + Float::EPSILON ** 20, :tmp)
         else
           fail "List is not implemented for #{$meta_info.lang_str}"
         end

data/lib/hilbert/exec.rb

@@ -32,7 +32,7 @@ module Hilbert
         when '-py'
           Hilbert.to_python
         else
-          print 'Q support only Ruby and R now.'
+          print 'Hilbert support only Ruby and R now.'
         end
       end
 
@@ -40,7 +40,7 @@ module Hilbert
         file = open_file(file_path)
         input_string = read_file(file)
         file.close
-        input_string.gsub(/(.*)I love mathematics\.(.*)Q\.E\.D(.*)/m) {
+        input_string.gsub(/(.*)I love mathematics\.(.*)Hilbert\.E\.D(.*)/m) {
           "#{$1}#{Kconv.tosjis(Hilbert.compile($2))}#{$3}"
         }
       end

data/lib/hilbert/iq.rb

@@ -12,7 +12,7 @@ module Hilbert
     end
 
     def self.execute(code)
-      ruby_code = Q.to_ruby.compile(code.encode('utf-8'))
+      ruby_code = Hilbert.to_ruby.compile(code.encode('utf-8'))
       ruby_obj = eval(ruby_code)
 
       optimize_output(ruby_obj).encode('utf-8')

data/lib/hilbert/lexer/base.rb

@@ -14,6 +14,14 @@ module Hilbert
           @token_rule_hash ||= {}
           @token_rule_hash[pattern] = token.call
         end
+        
+        def clear!
+          @token_rule_hash = {}
+        end
+
+        def execute(str)
+          new(str).lexeds
+        end
       end
 
       def initialize(str)

data/lib/hilbert/lexer/main_lexer.rb

@@ -1,34 +1,44 @@
-#!/bin/env ruby
-# encoding: utf-8
-
 module Hilbert
   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 }
-
+      # TODO: So far so good, but...
+      rule(/postulate zfc_analysis/) { :POST_ZFC }
+      rule(/#{EVALOGIC}/) { :EVALOGIC }
+      rule(/#{DEFLOGIC}/) { :DEFLOGIC }
       rule(/[ \t\f]/)
 
       rule(/(\r|\n)+/) { :NULL }
 
       rule(/[^\(\)\{\}(\n\n)]+/) { :CONT }
+      class << self
+        include Tokens
+        def zfc_analysis!
+          clear!
+          rule(/postulate zfc_analysis/) { :POST_ZFC }
+          rule(/#{EVALOGIC}/) { :EVALOGIC }
+          rule(/#{DEFLOGIC}/) { :DEFLOGIC }
+          rule(/(#{FUNCCV})#{ANYSP}#{EQL}#{ANYSP}(#{FORMULA})/) { :DEF_FUNC }
+          rule(/#{INTE_SYM}#{ANYSP}#{LPRN}(#{ANYSTR})#{RPRN}#{LBRCT}(#{ANYSTR})#{RBRCT}/) { :INTEGRAL }
+          rule(/#{DIFF_SYM}(#{VAR}) (#{FORMULA})/) { :DIFFERENTIAL }
+          rule(/#{LIM_SYM}#{LBRCT}(#{VAR})#{RSARW}(#{VARNUM})#{RBRCT} (#{FORMULA})/) { :LIMIT }
+          rule(/#{SGM_SYM}#{LBRCT}(#{VAR})#{EQL}(#{INT})#{CMA}#{ANYSP}(#{INT})#{RBRCT} (#{FORMULA})/) { :SIGMA }
+
+          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(/#{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
   end
 end

data/lib/hilbert/lexer/tokens.rb

@@ -1,3 +1,6 @@
+#!/bin/env ruby
+# encoding: utf-8
+
 module Hilbert
   module Lexer
     module Tokens
@@ -27,6 +30,12 @@ module Hilbert
       # # TERM
       # TERM = /(#{NUM}|#{VAR_MUL}|#{VAR_MUL})/
 
+      # SYM
+      LIM_SYM = /lim/
+      INTE_SYM = /S/
+      DIFF_SYM = /d\/d/
+      SGM_SYM = /(?:∑|sigma)/
+
       # OPE
       PLS = /\+/
       SUB = /-/
@@ -59,10 +68,21 @@ module Hilbert
       LSARW = '<-'
       RDARW = '=>'
       LDARW = '<='
-      SP = / /
+      SPC = / /
+      SPCS = / +/
       NLIN = /(\r|\n)/
 
-      ITGRLSYM = 'S'
+      # World
+      ## FIXIT
+      DEFLOGIC = /\A.*[A-RT-Z].*\z/
+      EVALOGIC = /\A.*[A-RT-Z].*\?\z/
+      PROVAR = /[A-RT-Z]/
+      CONJ = /\&/
+      DISJ = /\|/
+      NEGA = /\~/
+      COND = /\->/
+      BICO = /<\->/
+
       # FIXIT
       SCLN_OR_NELN = /(?:#{SCLN}|#{NLIN})/
 
@@ -80,7 +100,7 @@ module Hilbert
       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)
+      NUMS_BY_SP = Util.string_out(NUM, SPC)
 
       FUNCCN =  Util.func_call(NUMS_BY_CMA)
       FUNCCV = Util.func_call(VARS_BY_CMA)

data/lib/hilbert/lexer/world_lexer.rb

@@ -0,0 +1,15 @@
+module Hilbert
+  module Lexer
+    class WorldLexer < Base
+      rule(/#{PROVAR}/) { :PROVAR }
+      rule(/#{CONJ}/) { :CONJ }
+      rule(/#{DISJ}/) { :DISJ }
+      rule(/#{NEGA}/) { :NEGA }
+      rule(/#{COND}/) { :COND }
+      rule(/#{BICO}/) { :BICO }
+      rule(/#{LPRN}/) { :LPRN }
+      rule(/#{RPRN}/) { :RPRN }
+      rule(/#{SPCS}/) { :SPCS }
+    end
+  end
+end

data/lib/hilbert/parser/world_parser.rb

@@ -0,0 +1,43 @@
+module Hilbert
+  module Parser
+    class WorldParser
+      @@parsed_ary = []
+      @@stage
+      class << self
+        def execute(lexeds)
+          clear!
+
+          lexeds.each do |lexed|
+            parsed =  case lexed[:token]
+                      when :DISJ   then ' + '
+                      when :CONJ   then ' * '
+                      when :COND   then ' >= '
+                      when :BICO   then ' <=> '
+                      when :PROVAR then "$world.atom(:#{lexed[:value]})"
+                      when :NEGA   then " ~"
+                      else              lexed[:value]
+                      end
+
+            push(parsed)
+          end
+        end
+
+        def push(parsed)
+          if parsed
+            @@parsed_ary << parsed
+          else
+            @@stage << lexed
+          end
+        end
+
+        def parsed_srt
+          @@parsed_ary.join
+        end
+
+        def clear!
+          @@parsed_ary = []
+        end
+      end
+    end
+  end
+end

data/lib/hilbert/parser.rb

@@ -8,13 +8,16 @@ require 'hilbert/parser/func_parser'
 require 'hilbert/parser/integral_parser'
 require 'hilbert/parser/limit_parser'
 require 'hilbert/parser/sigma_parser'
+require 'hilbert/parser/world_parser'
 
 require 'hilbert/parser/formula_parser'
+require 'hilbert/lexer/world_lexer'
 
 module Hilbert
   module Parser
     include Lexer::Tokens
     SYM = '\w+'
+
     ONEHASH = "#{ANYSP}#{SYM}#{CLN}#{ANYSP}#{VARNUM}#{ANYSP}" # sdf: 234
     def execute(lexed)
       time = Time.now
@@ -22,18 +25,36 @@ module Hilbert
         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+)/
+        when /:(POST_ZFC)(\d+)/
+          Hilbert::Lexer::MainLexer.zfc_analysis!
+          lexed.parsed!('', $2)
+        when /:(DEFLOGIC)(\d+)/
+          value = lexed.get_value($1)
+          lexeds = Lexer::WorldLexer.execute(value)
+          Parser::WorldParser.execute(lexeds)
+          $world << eval(Parser::WorldParser.parsed_srt)
+          rslt = %|"Defined: #{value} is TRUE"|
+          lexed.parsed!(rslt, $2)
+
+        when /:(EVALOGIC)(\d+)/
+          value = lexed.get_value($1).delete('?')
+          lexeds = Lexer::WorldLexer.execute(value)
+          Parser::WorldParser.execute(lexeds)
+          rslt = $world.impl eval(Parser::WorldParser.parsed_srt), value
+          lexed.parsed!(rslt, $2)
+
+        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'   then VectorParser.execute(token_els)
-                   when 'matrix'   then MatrixParser.execute(token_els)
-                   when 'tmatrix'  then MatrixParser.execute(token_els, trans: true)
-                   when 'limit'    then LimitParser.execute(token_els)
-                   when 'integral' then IntegralParser.execute(token_els)
-                   when 'def_func' then FuncParser.execute(token_els)
-                   when 'sigma'    then SigmaParser.execute(token_els)
-                   when 'differential'
+                   when 'VECTOR'   then VectorParser.execute(token_els)
+                   when 'MATRIX'   then MatrixParser.execute(token_els)
+                   when 'TMATRIX'  then MatrixParser.execute(token_els, trans: true)
+                   when 'LIMIT'    then LimitParser.execute(token_els)
+                   when 'INTEGRAL' then IntegralParser.execute(token_els)
+                   when 'DEF_FUNC' then FuncParser.execute(token_els)
+                   when 'SIGMA'    then SigmaParser.execute(token_els)
+                   when 'DIFFERENTIAL'
                      del_var, formula = token_els
                      "d/d#{del_var}(#{FormulaParser.execute(formula)})"
           end

data/lib/hilbert/version.rb

@@ -1,3 +1,3 @@
 module Hilbert
-  VERSION = '0.0.2700001'
+  VERSION = '0.0.2700100'
 end

data/lib/hilbert/world/base.rb

@@ -0,0 +1,6 @@
+module Hilbert
+  module World
+    class Base
+    end
+  end
+end

data/lib/hilbert/world/propositional_logic.rb

@@ -0,0 +1,174 @@
+#!/bin/env ruby
+# encoding: utf-8
+
+module Hilbert
+  module World
+    module PropositionalLogic
+      module Operator
+        def ~@
+          if    is_neg?  then p
+          elsif is_form? then vars.map { |a|~a }.inject(reope)
+          else                NEG.new(self)
+          end
+        end
+
+        def *(q)
+          case q
+          when Taut  then self
+          when UTaut then $utout
+          when self  then self
+          else
+            if neg?(q) then $utout
+            else            FORM.new([self, q], :*)
+            end
+          end
+        end
+
+        def +(q)
+          case q
+          when Taut  then $tout
+          when UTaut then self
+          when self  then self
+          else
+            if neg?(q) then $tout
+            else            FORM.new([self, q], :+)
+            end
+          end
+        end
+
+        def >=(q)
+          (~self + q)
+        end
+
+        def <=>(q)
+          (self >= q) * (q >= self)
+        end
+      end
+
+      module Utils
+        def neg?(p)
+          (is_a?(NEG) && self.p == p) ||
+          (p.is_a?(NEG) && p.p == self)
+        end
+
+        def is_neg?
+          is_a?(NEG)
+        end
+
+        def is_form?(ope=true)
+          return is_a?(FORM) if ope === true
+          is_a?(FORM) && @ope == ope
+        end
+
+        def is_or?
+          is_form?(:+)
+        end
+
+        def is_and?
+          is_form?(:*)
+        end
+
+        def include?(p)
+          false
+        end
+      end
+
+      module Base; include Operator; include Utils end
+
+      # Tautology
+      class Taut
+        include Base
+        def ~@;   $utout end
+        def +(q); $tout  end
+        def *(q); q      end
+        def !@;   $tout  end
+        def to_s; 'TRUE' end
+      end
+      $tout = Taut.new
+
+      # Non Tautology
+      class UTaut
+        include Base
+        def ~@;   $tout   end
+        def +(q); q       end
+        def *(q); $utout  end
+        def !@;   $utout  end
+        def to_s; 'FALSE' end
+      end
+      $utout = UTaut.new
+
+      class Atom
+        include Base
+        attr_accessor :p
+        def initialize(p); @p = p  end
+        def to_s;          @p.to_s end
+        def !@;            self    end
+        def deep;          1       end
+      end
+      $atoms = []
+
+      class NEG
+        include Base
+        attr_accessor :p
+        def initialize(p); @p = p     end
+        def to_s;          "~#{@p}"   end
+        def !@;             ~(!p)     end
+        def deep;          p.deep+1   end
+      end
+
+
+      class FORM
+        include Base
+        attr_accessor :vars, :ope
+        def initialize(vars, ope)
+          vars = vars.map { |var| var.is_form?(ope) ? var.vars : var }.flatten
+          @vars, @ope = vars, ope
+        end
+
+        def include?(p)
+          vars.include?(p)
+        end
+
+        def to_s
+          str = vars.each.with_index.inject('(') do |str, (p, i)|
+            str = str + "#{p}#{i < vars.count-1 ? loope : ')'}"
+            str
+          end
+        end
+
+        def loope
+          @ope == :* ? '&' : '|'
+        end
+
+        def reope
+          is_and? ? :+ : :*
+        end
+
+        def are_there_neg?
+          pvars = vars.reject { |var| var.is_neg? }
+          nvars = vars.select { |var| var.is_neg? }
+          pvars.any? { |pvar|
+            nvars.any? { |nvar| nvar.neg?(pvar) }
+          }
+        end
+
+        def !@
+          if is_or?
+            if and_form = vars.find { |var| var.is_and? }
+              and_form.vars.map { |a| a + FORM.new((vars - [and_form]), :+) }.inject(:*)
+            elsif are_there_neg?
+              $tout
+            else
+              vars.map{|a|!a}.inject(@ope)
+            end
+          elsif is_and? && are_there_neg?
+            $utout
+          else
+            vars.map{|a|!a}.inject(@ope)
+          end
+        end
+        def deep;          [p.deep, q.deep].max+1;     end
+      end
+    end
+  end
+end

data/lib/hilbert/world.rb

@@ -0,0 +1,44 @@
+require 'hilbert/world/base'
+require 'hilbert/world/propositional_logic'
+
+module Hilbert
+  module World
+    class Entity
+      @@propositions = []
+      class << self
+        def tautology
+          @@propositions
+        end
+
+        def <<(logic_form)
+          @@propositions << logic_form
+        end
+
+        def impl(logic_form, logic_str)
+          # HOTFIX:
+          return %|"Evaluate: #{logic_str} is UNDEFINED"| if @@propositions.empty?
+          str = (!!!!!!!(@@propositions.inject(:*) >= logic_form)).to_s
+          case str
+          when 'TRUE'
+            %|"Evaluate: #{logic_str} is TRUE"|
+          when 'FALSE'
+            %|"Evaluate: #{logic_str} is FALSE"|
+          else
+            %|"Evaluate: #{logic_str} is UNDEFINED"|
+          end
+        end
+
+        def atom(sym)
+          unless sym.to_s == sym.to_s.upcase && sym.to_s.length == 1
+            raise 'Proposltionla variable should be capital character'
+          end
+          eval "$#{sym} ||= PropositionalLogic::Atom.new(:#{sym})"
+        end
+
+        def clear!
+          @@propositions = []
+        end
+      end
+    end
+  end
+end

data/lib/hilbert.rb

@@ -5,17 +5,18 @@ require 'singleton'
 require 'yaml'
 
 $:.unshift(File.dirname(__FILE__))
-# Q core
+# Hilbert core
 require 'hilbert/meta_info'
 require 'hilbert/utils/ruby_ext'
 require 'hilbert/lexer'
 require 'hilbert/parser'
+require 'hilbert/world'
 
 module Hilbert
   $meta_info = MetaInfo.instance
+  $world     = World::Entity
 
   class << self
-
     def compile(str)
       lexed = Lexer.execute(str)
       Kconv.tosjis(Parser.execute(lexed))
@@ -28,10 +29,6 @@ module Hilbert
         Hilbert
       end
     end
-
   end
 
 end
-
-# Make alias as Q
-Q = Hilbert

data/test/interpreter/test_propositional_logic.rb

@@ -0,0 +1,54 @@
+require 'minitest_helper'
+
+class TestPropositionalLogic < TestInterpreterBase
+  def setup
+    $world.clear!
+  end
+
+  # TODO: opposite
+  def assert_iq_equal(output, input)
+    assert_equal(output, Hilbert::Iq.execute(input))
+  end
+
+  def test_general
+    assert_iq_equal('Defined: A is TRUE', 'A')
+    assert_iq_equal('Evaluate: A is TRUE', 'A?')
+    assert_iq_equal('Evaluate: B is UNDEFINED', 'B?')
+    assert_iq_equal('Defined: A->B is TRUE', "A->B")
+    assert_iq_equal('Evaluate: B is TRUE', 'B?')
+  end
+
+  def test_syllogisms
+    assert_iq_equal('Evaluate: A is UNDEFINED', 'A?')
+    assert_iq_equal('Evaluate: A -> C  is UNDEFINED', 'A -> C ?')
+    assert_iq_equal('Defined: A -> B is TRUE', 'A -> B')
+    assert_iq_equal('Defined: B -> C is TRUE', 'B -> C')
+    assert_iq_equal('Evaluate: A -> C  is TRUE', 'A -> C ?')
+  end
+
+  def test_paradox?
+    assert_iq_equal('Defined: A is TRUE', 'A')
+    assert_iq_equal('Defined: ~A is TRUE', '~A')
+  end
+    # assert_iq_equal('Defined: P(1) is true', "P(1)")
+    # assert_iq_equal('Evaluate: P(1) is true', 'P?(1)')
+    # assert_iq_equal('Evaluate: P(2) is undefined', 'P?(2)')
+    # assert_iq_equal('Evaluate: Q(1) is undefined', 'Q?(1)')
+    # assert_equal(
+    #   "Defined: A[x] P(x) -> A[x] Q(x) is true",
+    #   $world.truth.def_impli(['P', :all, true], ['Q', :all, true])
+    # )
+    # assert_iq_equal('Evaluate: Q(1) is true', 'Q?(1)')
+    #
+    # assert_iq_equal('Evaluate: Q(2) is undefined', 'Q?(2)')
+    #
+    # $world.truth.reset!
+    # assert_iq_equal("Defined: Human('gogo1') is true", "Human('gogo1')")
+    # assert_equal(
+    #   "\"Defined: Human(\\'gogo1\\') -> WillDie(\\'gogo1\\') is true\"",
+    #   $world.truth.def_impli(['Human', 'gogo1', true], ['WillDie', 'gogo1', true])
+    # )
+    # assert_iq_equal("Evaluate: WillDie('gogo1') is true", "WillDie?('gogo1')")
+    # assert_iq_equal("Evaluate: WillDie('gogo2') is undefined", "WillDie?('gogo2')")
+    # assert_iq_equal('Evaluate: Q(x) is true', 'Q?(x)')
+end

data/test/langs/test_r.rb

@@ -5,7 +5,7 @@ class TestR < TestInterpreterBase
   end
 
   def assert_r_compl_eq(output, input)
-    assert_equal(output, Q.to_r.compile(input))
+    assert_equal(output, Hilbert.to_r.compile(input))
   end
 
   def test_function

data/test/minitest_helper.rb

@@ -1,3 +1,6 @@
+require 'coveralls'
+Coveralls.wear!
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'hilbert'
 
@@ -6,3 +9,4 @@ require 'pp'
 require 'pry'
 
 require 'interpreter/base'
+Hilbert::Iq.execute('postulate zfc_analysis')

data/test/q_matrix/test_q_matrix.rb

@@ -1,13 +1,13 @@
 require 'minitest_helper'
 # require 'hilbert/hilbert'
 
-class TestQMatrix < TestInterpreterBase
+class TestHilbertMatrix < TestInterpreterBase
   def setup
   end
 
   def test_main
-    # assert_equal(50.0, QMatrix.new.func(10))
+    # assert_equal(50.0, HilbertMatrix.new.func(10))
 
-    # assert_equal(8.0, QMatrix.new.execute(0, 2, 100))
+    # assert_equal(8.0, HilbertMatrix.new.execute(0, 2, 100))
   end
 end

data/test/{test_qlang.rb → test_hilbert.rb}

@@ -5,12 +5,11 @@ class TestHilbert < MiniTest::Unit::TestCase
   end
 
   def assert_to_ruby(input, output)
-    assert_equal(Q.to_ruby.compile(input), output)
+    assert_equal(Hilbert.to_ruby.compile(input), output)
   end
 
   def test_basis
     refute_nil ::Hilbert::VERSION
-    assert_equal(Hilbert, Q)
   end
 
   def test_demo_code
@@ -21,4 +20,3 @@ class TestHilbert < MiniTest::Unit::TestCase
     assert_equal(Vector[1, 2, 3].to_q, '(1 2 3)')
   end
 end
-

data/test/world/test_lexer.rb

@@ -0,0 +1,21 @@
+require 'minitest_helper'
+
+class TestLexer < MiniTest::Unit::TestCase
+  def test_general
+    lexeds = Hilbert::Lexer::WorldLexer.execute('(A -> B) <-> (C|D)&(E&~R)')
+    assert_equal(22, lexeds.count)
+    Hilbert::Parser::WorldParser.execute(lexeds)
+    assert_equal(
+      "($world.atom(:A)  >=  $world.atom(:B))  <=>  ($world.atom(:C) + $world.atom(:D)) * ($world.atom(:E) *  ~$world.atom(:R))",
+      Hilbert::Parser::WorldParser.parsed_srt
+    )
+
+
+    lexeds = Hilbert::Lexer::WorldLexer.execute('(A & (A -> B)) -> B')
+    Hilbert::Parser::WorldParser.execute(lexeds)
+    assert_equal(
+       "($world.atom(:A)  *  ($world.atom(:A)  >=  $world.atom(:B)))  >=  $world.atom(:B)",
+      Hilbert::Parser::WorldParser.parsed_srt
+    )
+  end
+end

data/test/world/test_prop_logic.rb

@@ -0,0 +1,67 @@
+class TestPropLogic < MiniTest::Unit::TestCase
+  # Fixit:
+  $p = $world.atom(:P)
+  $q = $world.atom(:Q)
+  $r = $world.atom(:R)
+  def setup
+
+  end
+  def assert_to_s(exp, obj)
+    assert_equal(exp, ((!!!!!!!obj).to_s))
+  end
+
+  def test_utils
+    assert_equal(true, $p.neg?(~$p))
+    assert_equal(true, (~$p).neg?($p))
+    assert_equal(false, ($p).neg?($p))
+    assert_equal(false, ($p).neg?($p))
+    assert_equal(true, ($p + $q).include?($p))
+    assert_equal(true, ($p + $q).include?($q))
+  end
+
+  def test_0_1
+    assert_to_s("TRUE", $p + $tout)
+    assert_to_s("TRUE", $tout + $p)
+    assert_to_s("P", $p + $utout)
+    assert_to_s("P", $utout + $p)
+    assert_to_s("TRUE", $p + ~$p)
+    assert_to_s("TRUE", ~$p + $p)
+
+    assert_to_s("P", $p * $tout)
+    assert_to_s("P", $tout * $p)
+    assert_to_s("FALSE", $p * $utout)
+    assert_to_s("FALSE", $utout * $p)
+    assert_to_s("FALSE", $p * ~$p)
+    assert_to_s("FALSE", ~$p * $p)
+  end
+
+  def test_basis
+    assert_to_s("P", $p)
+    assert_to_s("(P|Q)", $p + $q)
+    assert_to_s("(P&Q)", $p * $q)
+    assert_to_s("~P", ~$p)
+    assert_to_s("(~P|Q)", $p >= $q)
+    assert_to_s("((~P|Q)&(~Q|P))", $p <=> $q)
+  end
+
+  def test_main
+    assert_to_s("(~P&~Q)", ~($p + $q))
+    assert_to_s("(~P|~Q)", ~($p * $q))
+    assert_to_s("P", ~(~$p))
+    assert_to_s("((Q|P)&(R|P))", $p + ($q * $r))
+    assert_to_s("(P&Q&R)", $p * ($q * $r))
+    assert_to_s("(P&(~P|Q))", $p * ($p >= $q))
+  end
+
+  def test_tautology
+    assert_to_s("TRUE", ~(~$p) >= $p)
+    assert_to_s("TRUE", ($p * ($p >= $q)) >= $q)
+    assert_to_s("TRUE", (($p >= $q) * ($q >= $r)) >= ($p >= $r))
+    assert_to_s("TRUE", (~$p * ($p + $q)) >= ($q))
+    assert_to_s("TRUE", (($p >= $q) * ($q >= $r) * $p) >= ($r))
+  end
+
+  def test_no_tautology
+    assert_to_s("FALSE", $p * $q * ~$p)
+  end
+end

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: hilbert
 version: !ruby/object:Gem::Version
-  version: 0.0.2700001
+  version: 0.0.2700100
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dydx
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41421
+        version: 0.2.7000000
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41421
+        version: 0.2.7000000
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Enjoy MATH!
@@ -89,10 +89,10 @@ extensions:
 - ext/hilbert/extconf.rb
 extra_rdoc_files: []
 files:
-- .coveralls.yml
-- .gitignore
-- .rubocop.yml
-- .travis.yml
+- ".coveralls.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -132,6 +132,7 @@ files:
 - lib/hilbert/lexer/formula_lexer.rb
 - lib/hilbert/lexer/main_lexer.rb
 - lib/hilbert/lexer/tokens.rb
+- lib/hilbert/lexer/world_lexer.rb
 - lib/hilbert/meta_info.rb
 - lib/hilbert/parser.rb
 - lib/hilbert/parser/base.rb
@@ -143,9 +144,13 @@ files:
 - lib/hilbert/parser/matrix_parser.rb
 - lib/hilbert/parser/sigma_parser.rb
 - lib/hilbert/parser/vector_parser.rb
+- lib/hilbert/parser/world_parser.rb
 - lib/hilbert/utils/langs.yml
 - lib/hilbert/utils/ruby_ext.rb
 - lib/hilbert/version.rb
+- lib/hilbert/world.rb
+- lib/hilbert/world/base.rb
+- lib/hilbert/world/propositional_logic.rb
 - test/internal/test_tokens.rb
 - test/interpreter/base.rb
 - test/interpreter/test_differential.rb
@@ -154,13 +159,16 @@ files:
 - test/interpreter/test_integral.rb
 - test/interpreter/test_limit.rb
 - test/interpreter/test_matrix.rb
+- test/interpreter/test_propositional_logic.rb
 - test/interpreter/test_sigma.rb
 - test/interpreter/test_vector.rb
 - test/langs/test_r.rb
 - test/langs/test_ruby.rb
 - test/minitest_helper.rb
 - test/q_matrix/test_q_matrix.rb
-- test/test_qlang.rb
+- test/test_hilbert.rb
+- test/world/test_lexer.rb
+- test/world/test_prop_logic.rb
 homepage: http://q-language.org/
 licenses:
 - MIT
@@ -171,17 +179,17 @@ 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.0.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Enjoy MATH!
@@ -194,10 +202,13 @@ test_files:
 - test/interpreter/test_integral.rb
 - test/interpreter/test_limit.rb
 - test/interpreter/test_matrix.rb
+- test/interpreter/test_propositional_logic.rb
 - test/interpreter/test_sigma.rb
 - test/interpreter/test_vector.rb
 - test/langs/test_r.rb
 - test/langs/test_ruby.rb
 - test/minitest_helper.rb
 - test/q_matrix/test_q_matrix.rb
-- test/test_qlang.rb
+- test/test_hilbert.rb
+- test/world/test_lexer.rb
+- test/world/test_prop_logic.rb