rley 0.5.05 → 0.5.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5fdf5f08878706a50fe9b024c7ffed95b3cb08fd
-  data.tar.gz: 92265adccb7cb660b56ac2b060aee4a5facdd777
+  metadata.gz: 330046979feed860a18faeb226de2c2aab9ca8ca
+  data.tar.gz: 3e8b7ee124edb3db95f6c95c56754a71375dd703
 SHA512:
-  metadata.gz: 936959f76b1b2dc9fe6db68e4a0372f6aa421ea143876421c0ee90ab95852f71dad9fc166d80269af070fe84dfcbdef3848cb29be321e474afd40dae9e3bce59
-  data.tar.gz: 4e2f8a16366d4771e6d8506d3333adc40329c01a21952ee2002d432a5d0205c6ab6658b96d245bd4688227c6cf2c053fa66a57a9bdbeaeca4ef4969425b21457
+  metadata.gz: 518f9fb02230a1953c71ac4334cfa71d4c72c3f9e94b546a7dd164a32aa67d0ab2769563cd5cd72b46891cbce08fe9d4319f6645de7db8bd2ddb5d8fab67034a
+  data.tar.gz: b468cda9c0d4c0e49537f0fc4cdac5882ea21ee176810c0d529fda1f080e13428f73a328607afff640f51ded1de8c83e4a5715da008d4295a276064d78490ca5

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.5.06 / 2017-11-08
+* [CHANGE] Demo calculator in `examples/general/calc_iter2` does much than the basic arithmetic operators, it now  
+support trigonometric functions and their inverse, square root, exponential and natural logarithm functions!.
+* [CHANGE] Internal module re-organization. New module `Base`, module `Tokens` renamed to `Lexical`.
+* [CHANGE] Improved YARD Documentation for 10+ classes.
+
 ### 0.5.05 / 2017-11-04
 * [FIX] Method `GFGParsing#call_rule` didn't handle properly the case of nullable symbols appearing in more than one production rule.
 * [New] New calculator example. In addition to the basic arithmetic operators (+, -, *, /) it accepts the unary minus

data/examples/NLP/mini_en_demo.rb

@@ -63,7 +63,7 @@ def tokenizer(aTextToParse, aGrammar)
     term_name = Lexicon[word]
     raise StandardError, "Word '#{word}' not found in lexicon" if term_name.nil?
     terminal = aGrammar.name2symbol[term_name]
-    Rley::Tokens::Token.new(word, terminal)
+    Rley::Lexical::Token.new(word, terminal)
   end
   
   return tokens

data/examples/data_formats/JSON/json_lexer.rb

@@ -51,7 +51,7 @@ class JSONLexer
         when '{', '}', '[', ']', ',', ':'
           type_name = @@lexeme2name[curr_ch]
           token_type = name2symbol[type_name]
-          token = Rley::Tokens::Token.new(curr_ch, token_type)
+          token = Rley::Lexical::Token.new(curr_ch, token_type)
 
         when /[ftn]/ # First letter of keywords
           @scanner.pos = scanner.pos - 1 # Simulate putback
@@ -61,7 +61,7 @@ class JSONLexer
             raise ScanError.new("Invalid keyword: #{invalid_keyw}")
           else
             token_type = name2symbol[keyw]
-            token = Rley::Tokens::Token.new(keyw, token_type)
+            token = Rley::Lexical::Token.new(keyw, token_type)
           end
 
         # LITERALS
@@ -71,13 +71,13 @@ class JSONLexer
           err_msg = 'No closing quotes (") found'
           raise ScanError.new(err_msg) if end_delimiter.nil?
           token_type = name2symbol['string']
-          token = Rley::Tokens::Token.new(value, token_type)
+          token = Rley::Lexical::Token.new(value, token_type)
 
         when /[-0-9]/ # Start character of number literal found
           @scanner.pos = scanner.pos - 1 # Simulate putback
           value = scanner.scan(/-?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/)
           token_type = name2symbol['number']
-          token = Rley::Tokens::Token.new(value, token_type)
+          token = Rley::Lexical::Token.new(value, token_type)
 
         else # Unknown token
           erroneous = curr_ch.nil? ? '' : curr_ch

data/examples/general/calc_iter1/calc_lexer.rb

@@ -71,7 +71,7 @@ class CalcLexer
   
   def build_token(aSymbolName, aLexeme)
     token_type = name2symbol[aSymbolName]
-    return Rley::Tokens::Token.new(aLexeme, token_type)    
+    return Rley::Lexical::Token.new(aLexeme, token_type)    
   end
 
   def skip_whitespaces()

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -12,10 +12,13 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
     # Lexical ambiguity: minus sign represents two very concepts:
     # The unary negation operator on one hand, the binary substraction operator
     'MINUS' => { 'add_operator_1' =>  Rley::PTree::TerminalNode,
-                 'factor_2' => CalcNegateNode,
+                 'simple_factor_2' => CalcNegateNode,
                  'sign_1' => CalcNegateNode
                },
-    'NUMBER' => CalcNumberNode
+    'NUMBER' => CalcNumberNode,
+    'PI' => CalcConstantNode,
+    'E' => CalcConstantNode,
+    'RESERVED' => CalcReservedNode
   }.freeze
 
   protected
@@ -87,32 +90,49 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
 
       when 'term_1' # rule 'term' => %w[term mul_operator factor]
         reduce_term_1(aProduction, aRange, theTokens, theChildren)
-        
+
       when 'factor_0' # rule 'factor' => 'simple_factor'
         return_first_child(aRange, theTokens, theChildren)
-        
-      when 'factor_1' # rule 'factor' => %w[simple_factor POWER simple_factor]
-        reduce_factor_1(aProduction, aRange, theTokens, theChildren)        
 
-      when 'simple_factor_0' # rule 'simple_factor' => %[sign NUMBER]
+      when 'factor_1' # rule 'factor' => %w[factor POWER simple_factor]
+        reduce_factor_1(aProduction, aRange, theTokens, theChildren)
+
+      when 'simple_factor_0' # rule 'simple_factor' => %[sign scalar]
         reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'simple_factor_1' # rule 'simple_factor' => %w[LPAREN expression RPAREN]
-        return_second_child(aRange, theTokens, theChildren)
-        
-      when 'simple_factor_2' # rule 'simple_factor' => %w[MINUS LPAREN expression RPAREN]
+      when 'simple_factor_1'  # rule 'simple_factor' => %w[unary_function in_parenthesis]
+        reduce_simple_factor_1(aProduction, aRange, theTokens, theChildren)
+
+      when 'simple_factor_2' # rule 'simple_factor' => %w[MINUS in_parenthesis]
         reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
-      
+
+      when 'simple_factor_3' # rule 'simple_factor' => 'in_parenthesis'
+        return_first_child(aRange, theTokens, theChildren)
 
       when 'sign_0' # rule 'sign' => 'PLUS'
-         return_first_child(aRange, theTokens, theChildren)
+        return_first_child(aRange, theTokens, theChildren)
 
       when 'sign_1' # rule 'sign' => 'MINUS'
-         return_first_child(aRange, theTokens, theChildren)
+        return_first_child(aRange, theTokens, theChildren)
 
-      when 'sign_2'
+      when 'sign_2' # rule 'sign' => []
         return_epsilon(aRange, theTokens, theChildren)
 
+      when 'scalar_0' # rule 'scalar' => 'NUMBER'
+          return_first_child(aRange, theTokens, theChildren)
+
+      when 'scalar_1' # rule 'scalar' => 'PI'
+        return_first_child(aRange, theTokens, theChildren)
+
+      when 'scalar_2' # rule 'scalar' => 'E'
+        return_first_child(aRange, theTokens, theChildren)
+          
+      when 'unary_function_0' # rule 'unary_function' => 'RESERVED'
+        return_first_child(aRange, theTokens, theChildren)
+      
+      when 'in_parenthesis_0' # rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
+        return_second_child(aRange, theTokens, theChildren)      
+
       when 'add_operator_0' # rule 'add_operator' => 'PLUS'
         reduce_add_operator_0(aProduction, aRange, theTokens, theChildren)
 
@@ -120,7 +140,7 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
         reduce_add_operator_1(aProduction, aRange, theTokens, theChildren)
 
       when 'mul_operator_0' # rule 'mul_operator' => 'STAR'
-         reduce_mul_operator_0(aProduction, aRange, theTokens, theChildren)
+        reduce_mul_operator_0(aProduction, aRange, theTokens, theChildren)
 
       when 'mul_operator_1' # rule 'mul_operator' =>  'DIVIDE'
          reduce_mul_operator_1(aProduction, aRange, theTokens, theChildren)
@@ -148,17 +168,17 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
   def reduce_term_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
   end
-  
+
   # rule 'factor' => %w[simple_factor POWER simple_factor]]
   def reduce_factor_1(aProduction, aRange, theTokens, theChildren)
     result = PowerNode.new(theChildren[1].symbol, aRange)
     result.children << theChildren[0]
     result.children << theChildren[2]
-    
+
     return result
-  end  
+  end
 
-  # rule 'simple_factor' => %[sign NUMBER]
+  # rule 'simple_factor' => %[sign scalar]
   def reduce_simple_factor_0(aProduction, aRange, theTokens, theChildren)
     first_child = theChildren[0]
     result = if first_child.kind_of?(CalcNegateNode)
@@ -169,11 +189,19 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
 
     return result
   end
-  
-  # rule 'simple_factor' => %w[MINUS LPAREN expression RPAREN] 
+
+  # rule 'simple_factor' => %w[unary_function in_parenthesis]
+  def reduce_simple_factor_1(aProduction, aRange, theTokens, theChildren)
+    func = CalcUnaryFunction.new(theChildren[0].symbol, aRange.low)
+    func.func_name = theChildren[0].value
+    func.children << theChildren[1]
+    return func
+  end
+
+  # rule 'simple_factor' => %w[MINUS in_parenthesis]
   def reduce_simple_factor_2(aProduction, aRange, theTokens, theChildren)
     negation = CalcNegateNode.new(theChildren[0].symbol, aRange.low)
-    negation.children << theChildren[2]
+    negation.children << theChildren[1]
     return negation
   end
 

data/examples/general/calc_iter2/calc_ast_nodes.rb

@@ -47,10 +47,25 @@ class CalcNumberNode < CalcTerminalNode
   end
 end
 
+class CalcConstantNode < CalcNumberNode
+  @@constants2val = {
+    'PI' => Math::PI,
+    'E' => Math::E
+  }
+
+  def init_value(aConstantName)
+    self.value = @@constants2val[aConstantName]
+  end
+end
+
+class CalcReservedNode < CalcTerminalNode
+
+end
+
 class CalcCompositeNode
   attr_accessor(:children)
   attr_accessor(:symbol)
-  attr_accessor(:aPosition)
+  attr_accessor(:position)
 
   def initialize(aSymbol, aPosition)
     @symbol = aSymbol
@@ -75,16 +90,22 @@ class CalcUnaryOpNode < CalcCompositeNode
   alias members children
 end # class
 
-class CalcNegateNode < CalcUnaryOpNode
-  def initialize(aSymbol, aPosition)
-    super(aSymbol,aPosition)
-  end
-  
+class CalcNegateNode < CalcUnaryOpNode  
   def interpret()
     return -(children[0].interpret)
   end
 end # class
 
+class CalcUnaryFunction < CalcCompositeNode
+  attr_accessor(:func_name)
+  
+  def interpret()
+    argument = children[0].interpret
+    internal_name = @func_name == 'ln' ? 'log' : @func_name
+    return Math.send(internal_name.to_sym, argument)
+  end  
+end
+
 class CalcBinaryOpNode < CalcCompositeNode
   def initialize(aSymbol, aRange)
     super(aSymbol, aRange)

data/examples/general/calc_iter2/calc_demo.rb

@@ -33,8 +33,9 @@ Command-line symtax:
   where:
     the arithmetic expression is enclosed between double quotes (")
 
-  Example:
+  Examples:
   ruby #{my_name} "2 * 3 + (1 + 3 ** 2)"
+  ruby #{my_name} "cos(PI/2) + sqrt(1 + 1)"
 END_MSG
   puts msg
   exit(1)

data/examples/general/calc_iter2/calc_grammar.rb

@@ -5,22 +5,31 @@ require 'rley' # Load the gem
 # Define a grammar for basic arithmetical expressions
 builder = Rley::Syntax::GrammarBuilder.new do
   add_terminals('NUMBER')
-  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters
   add_terminals('PLUS', 'MINUS') # For '+', '-' operators or sign
   add_terminals('STAR', 'DIVIDE', 'POWER') # For '*', '/', '**' operators
+  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters  
+  add_terminals('PI', 'E') # For numeric constants
+  add_terminals('RESERVED') # Reserved identifiers
+
   rule 'expression' => %w[simple_expression]
   rule 'simple_expression' => 'term'
   rule 'simple_expression' => %w[simple_expression add_operator term]
   rule 'term' => 'factor'
   rule 'term' => %w[term mul_operator factor]
   rule 'factor' => 'simple_factor'
-  rule 'factor' => %w[simple_factor POWER simple_factor]
-  rule 'simple_factor' => %w[sign NUMBER]
-  rule 'simple_factor' => %w[LPAREN expression RPAREN]
-  rule 'simple_factor' => %w[MINUS LPAREN expression RPAREN]  
+  rule 'factor' => %w[factor POWER simple_factor]
+  rule 'simple_factor' => %w[sign scalar]
+  rule 'simple_factor' => %w[unary_function in_parenthesis]
+  rule 'simple_factor' => %w[MINUS in_parenthesis]
+  rule 'simple_factor' => 'in_parenthesis'  
   rule 'sign' => 'PLUS'
   rule 'sign' => 'MINUS'
   rule 'sign' => []
+  rule 'scalar' => 'NUMBER'
+  rule 'scalar' => 'PI'
+  rule 'scalar' => 'E'  
+  rule 'unary_function' => 'RESERVED'
+  rule 'in_parenthesis' => %w[LPAREN expression RPAREN]
   rule 'add_operator' => 'PLUS'
   rule 'add_operator' => 'MINUS'
   rule 'mul_operator' => 'STAR'

data/examples/general/calc_iter2/calc_lexer.rb

@@ -3,7 +3,6 @@
 require 'strscan'
 require 'rley' # Load the gem
 
-
 class CalcLexer
   attr_reader(:scanner)
   attr_reader(:lineno)
@@ -17,8 +16,16 @@ class CalcLexer
     '-' => 'MINUS',
     '*' => 'STAR',
     '/' => 'DIVIDE',
-    '**' => 'POWER'
+    '**' => 'POWER',
+    'PI' => 'PI',
+    'E' => 'E'
   }.freeze
+  
+  @@unary_functions = [
+    'sin', 'cos', 'tan',
+    'asin', 'acos', 'atan',
+    'sqrt', 'exp', 'ln'
+  ].freeze
 
   class ScanError < StandardError; end
 
@@ -29,6 +36,7 @@ class CalcLexer
   end
 
   def tokens()
+    @unary_f_pattern = Regexp.new(@@unary_functions.join('|'))
     tok_sequence = []
     until @scanner.eos?
       token = _next_token
@@ -50,11 +58,12 @@ class CalcLexer
     if '()+-/'.include? curr_ch
       # Single character token
       token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-      
     elsif (lexeme = scanner.scan(/\*\*/))
       token = build_token(@@lexeme2name[lexeme], lexeme)
-    elsif (lexeme = scanner.scan(/\*/))
+    elsif (lexeme = scanner.scan(/\*|PI|E/))
       token = build_token(@@lexeme2name[lexeme], lexeme)
+    elsif (lexeme = scanner.scan(@unary_f_pattern))
+      token = build_token('RESERVED', lexeme)  
     elsif (lexeme = scanner.scan(/[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/))
       token = build_token('NUMBER', lexeme)
     else # Unknown token
@@ -69,7 +78,7 @@ class CalcLexer
   
   def build_token(aSymbolName, aLexeme)
     token_type = name2symbol[aSymbolName]
-    return Rley::Tokens::Token.new(aLexeme, token_type)    
+    return Rley::Lexical::Token.new(aLexeme, token_type)    
   end
 
   def skip_whitespaces()

data/examples/general/calc_iter2/spec/calculator_spec.rb

@@ -23,17 +23,17 @@ describe 'Calculator' do
 
     return result
   end
-  
+
   def print_cst(aParseResult)
     # Generate a parse tree from the parse result
     ptree = aParseResult.parse_tree
-  
+
     # Let's create a parse tree visitor
     visitor = Rley::ParseTreeVisitor.new(ptree)
 
     # Now output formatted parse tree
     renderer = Rley::Formatter::Asciitree.new($stdout)
-    renderer.render(visitor)  
+    renderer.render(visitor)
   end
 
   def build_ast(aParseResult)
@@ -48,55 +48,112 @@ describe 'Calculator' do
     ast = build_ast(parsing)
     return expect(ast.interpret)
   end
-  
+
   context 'Parsing valid expressions' do
-    it 'should evaluate simple number literals' do
+    it 'should evaluate simple integer literals' do
       expect_expr('2').to eq(2)
     end
-   
-    it 'should evaluate positive number literals' do
+
+    it 'should evaluate simple floating-point literals' do
+      expect_expr('3.1').to eq(3.1)
+    end
+
+    it 'should evaluate positive integer literals' do
       expect_expr('+2').to eq(2)
       expect_expr('+ 2').to eq(2)
     end
 
-    it 'should evaluate negative number literals' do  
+    it 'should evaluate positive floating-point literals' do
+      expect_expr('+3.1').to eq(3.1)
+      expect_expr('+ 3.1').to eq(3.1)
+    end
+
+    it 'should evaluate negative integer literals' do
       expect_expr('-2').to eq(-2)
       expect_expr('- 2').to eq(-2)
-    end  
+    end
+
+    it 'should evaluate negative floating-point literals' do
+      expect_expr('-3.1').to eq(-3.1)
+      expect_expr('- 3.1').to eq(-3.1)
+    end
 
-    it 'should evaluate addition' do
+    it 'should evaluate the pi constant' do
+      expect_expr('PI').to eq(3.141592653589793)
+    end
+    
+    it 'should evaluate the negated pi constant' do
+      expect_expr('-PI').to eq(-3.141592653589793)
+    end    
+
+    it "should evaluate Neper's e constant" do
+      expect_expr('E').to eq(2.718281828459045)
+    end
+    
+    it "should evaluate negated Neper's e constant" do
+      expect_expr('-E').to eq(-2.718281828459045)
+    end    
+
+    it 'should evaluate integer addition' do
       expect_expr('2 + 2').to eq(4)
     end
 
-    it 'should evaluate subtraction' do
-      expect_expr('2.1 - 2').to be_within(0.000000000000001).of(0.1)
+    it 'should evaluate floating-point addition' do
+      expect_expr('2.0 + 3.1').to eq(5.1)
     end
 
-    it 'handles negative numbers' do
+    it 'should evaluate integer subtraction' do
+      expect_expr('2 - 3').to eq(-1)
+    end
+
+    it 'should evaluate floating-point subtraction' do
+      expect_expr('3.1 - 2').to eq(1.1)
+    end
+
+    it 'should handle negation of negative numbers' do
        expect_expr('3--2').to eq(5)
-    end  
-   
-    it 'should evaluate division' do
-      expect_expr('10.5 / 5').to eq(2.1)
     end
 
-    it 'should evaluate multiplication' do
+    it 'should evaluate integer multiplication' do
+      expect_expr('2 * 3').to eq(6)
+    end
+
+    it 'should evaluate floating-point multiplication' do
       expect_expr('2 * 3.1').to eq(6.2)
     end
 
-    it 'should evaluate exponentiation' do
+    it 'should evaluate division of integers' do
+      expect_expr('5 / 2').to eq(2.5)
+    end
+
+    it 'should evaluate floating-point division' do
+      expect_expr('10.5 / 5').to eq(2.1)
+    end
+
+    it 'should evaluate integer exponent' do
       expect_expr('5 ** (3 - 1)').to eq(25)
+    end
+
+    it 'should evaluate floating-point exponent' do
       expect_expr('25 ** 0.5').to eq(5)
-    end  
+    end
+
+    it 'should evaluate negative exponent' do
+      expect_expr('5 ** -2').to eq(0.04)
+    end
+
+    it 'should handle nested exponentiations' do
+      expect_expr('2 ** 2**2)').to eq(16)
+    end
 
     it 'should change sign of expression in parentheses' do
       expect_expr('- (2 * 5)').to eq(-10)
     end
-    
+
     it 'should evaluate parentheses' do
       expect_expr('2 * (2.1 + 1)').to eq(6.2)
-    end  
-   
+    end
+
     it 'should evaluate regardless of whitespace' do
       expect_expr("2*(1+\t1)").to eq(4)
     end
@@ -108,6 +165,66 @@ describe 'Calculator' do
     it 'should evaluate multiple levels of parentheses' do
       expect_expr('2*(1/(1+3))').to eq(0.5)
     end
+    
+    # Some special functions
+    it 'should evaluate square root of expressions' do
+      expect_expr('sqrt(1 + 1)').to eq(Math.sqrt(2))
+    end 
+
+    it 'should evaluate exponential of expressions' do
+      expect_expr('exp(-1)').to eq(1/Math::E)    
+      expect_expr('exp(0)').to eq(1)
+      expect_expr('exp(1)').to eq(Math::E)
+      expect_expr('exp(2)').to be_within(0.0000000001).of(Math::E * Math::E)
+    end
+
+    it 'should evaluate natural logarithm of expressions' do
+      expect_expr('ln(1/E)').to eq(-1)    
+      expect_expr('ln(1)').to eq(0)    
+      expect_expr('ln(E)').to eq(1)
+      expect_expr('ln(E * E)').to eq(2)
+    end     
+ 
+    # Trigonometric functions
+    
+    it 'should compute the sinus of an expression' do
+      expect_expr('sin(0)').to eq(0)
+      expect_expr('sin(PI/6)').to be_within(0.0000000001).of(0.5)
+      expect_expr('sin(PI/2)').to eq(1)
+    end
+    
+    it 'should compute the cosinus of an expression' do
+      expect_expr('cos(0)').to eq(1)
+      expect_expr('cos(PI/3)').to be_within(0.0000000001).of(0.5)
+      expect_expr('cos(PI/2)').to be_within(0.0000000001).of(0)
+    end 
+
+    it 'should compute the tangent of an expression' do
+      expect_expr('tan(0)').to eq(0)
+      expect_expr('tan(PI/4)').to be_within(0.0000000001).of(1)
+      expect_expr('tan(5*PI/12)').to be_within(0.0000000001).of(2 + Math.sqrt(3))
+    end    
+ 
+    # Inverse trigonometric functions
+    
+    it 'should compute the arcsinus of an expression' do
+      expect_expr('asin(0)').to eq(0)
+      expect_expr('asin(0.5)').to be_within(0.0000000001).of(Math::PI/6)
+      expect_expr('asin(1)').to eq(Math::PI/2)
+    end
+    
+    it 'should compute the arccosinus of an expression' do
+      expect_expr('acos(1)').to eq(0)
+      expect_expr('acos(0.5)').to be_within(0.0000000001).of(Math::PI/3)
+      expect_expr('acos(0)').to be_within(0.0000000001).of(Math::PI/2)
+    end 
+
+    it 'should compute the tangent of an expression' do
+      expect_expr('atan(0)').to eq(0)
+      expect_expr('atan(1)').to be_within(0.0000000001).of(Math::PI/4)
+      expect_expr('atan(2 + sqrt(3))').to be_within(0.0000000001).of(5*Math::PI/12)
+    end    
+  
   end # context
 end # describe
 # End of file