lambda_gem 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lambda_gem.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 angelos
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# LambdaGem
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lambda_gem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lambda_gem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/git_settings.txt

@@ -0,0 +1,7 @@
+
+bitbucket remote:
+
+bitbucket_lambda_gem
+
+
+git remote add bitbucket_lambda_gem https://akxs14@bitbucket.org/akxs14/lambda-gem.git

data/lambda_gem.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "lambda_gem"
+  gem.version       = LambdaGem::VERSION
+  gem.authors       = ["angelos"]
+  gem.email         = ["angelos.kapsimanis@gmail.com"]
+  gem.description   = "Lambda expressions support"
+  gem.summary       = "The current gem provides a lambda 
+                      calculus implementation with the possibility
+                      to define any arbitrary operator with any
+                      functionality"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec", "~> 2.6"
+end

data/lib/dictionary.rb

@@ -0,0 +1,59 @@
+# Description:
+#   A dictionary structure containing the functionality
+#   of the available operators. 
+module LambdaGem
+
+  class Dictionary
+    attr_reader :operator_priority
+
+    def initialize dict=nil
+      if dict.nil?
+        @operator_dict, @operator_priority = Hash.new, Hash.new
+        @operator_priority.default(-1)
+        populate_default_dict
+        populate_default_priorities
+      else
+        @operator_dict = dict
+      end
+    end
+
+    def count
+      @operator_dict.count
+    end
+
+    def [] operator
+      @operator_dict[operator]
+    end
+
+    def contains? operator
+      @operator_dict.include? operator
+    end
+
+    def add_operator symbol, block, priority
+      @operator_dict[symbol] = block
+      @operator_priority[symbol] = priority
+    end
+
+    private
+      def populate_default_dict
+        @operator_dict["="] = lambda { |a, b| a = b }        
+        @operator_dict["and"] = lambda { |a,b| a and b }
+        @operator_dict["or"]  = lambda { |a,b| a or b }
+        @operator_dict["+"]  = lambda { |a,b| a + b }
+        @operator_dict["-"]  = lambda { |a,b| a - b }
+        @operator_dict["*"]  = lambda { |a,b| a * b }
+        @operator_dict["/"]  = lambda { |a,b| a / b }       
+      end
+
+      def populate_default_priorities
+        @operator_priority["and"] = 1
+        @operator_priority["or"]  = 1
+        @operator_priority["+"]  = 1
+        @operator_priority["-"]  = 1
+        @operator_priority["*"]  = 2
+        @operator_priority["/"]  = 2
+        @operator_priority["="]  = 3        
+      end
+  end
+
+end

data/lib/expression.rb

@@ -0,0 +1,93 @@
+require_relative 'tree'
+require_relative 'dictionary'
+
+module LambdaGem
+  class Expression
+    attr_accessor :tree, :current_order, :dictionary
+
+    def initialize expression=nil, order=:infix, dictionary=nil     
+      order = :infix if !@@AVAILABLE_ORDERING.include? order
+      @dictionary = Dictionary.new
+      @formula, @current_order, @tree = expression, order, Tree.new
+      tree_from_expression(expression,order) if !expression.nil?
+    end
+
+    def formula
+     @formula
+    end
+
+    def formula= new_expression
+      tree_from_expression new_expression
+      @formula = new_expression
+    end
+
+    def tree_from_expression expression=@formula, order=:infix
+      tokens = tokenize expression
+      operator_stack, node_stack = [], []
+
+      tokens.each do |token|
+        token = token.downcase
+
+        if operator?(token)
+          until(operator_stack.empty? or
+                operator_stack.last.data == "(" or
+                @dictionary.operator_priority[operator_stack.last.data] < @dictionary.operator_priority[token])
+            pop_connect_push operator_stack, node_stack
+          end
+          operator_stack.push(Node.new(token))
+        elsif token == "("
+          operator_stack.push(Node.new(token))
+        elsif token == ")"
+          while operator_stack.last.data != "("
+            pop_connect_push operator_stack, node_stack
+          end
+          operator_stack.pop #throw '('
+        else
+          node_stack.push(Node.new(token))
+        end
+
+      end
+
+      until operator_stack.empty?
+        pop_connect_push operator_stack, node_stack
+      end
+
+      @tree.root = node_stack.last
+      @tree
+    end
+
+    def operator?(token)
+     @dictionary.contains?(token.to_s)
+    end
+
+    def evaluate
+     eval(@tree.root)
+    end
+
+    private
+      @@AVAILABLE_ORDERING = [:prefix,:infix,:postfix]
+
+      def eval node
+        if !node.leaf? and operator?(node.data)
+          @dictionary[node.data].call( eval(node.left), eval(node.right) )
+        else
+          #if a number, cast from string to numeric, otherwise return it as-is
+          (/[0-9]/ =~ node.data) ? node.data.to_f : node.data
+        end
+      end
+
+      def tokenize expression
+        expression.gsub('(', ' ( ').gsub(')', ' ) ').split(' ')
+      end
+
+      #pops the topmost node, assigns the next two nodes
+      #as its left and right branches and is pushed back
+      def pop_connect_push operator_stack, node_stack
+        temp = operator_stack.pop
+        temp.right = node_stack.pop
+        temp.left = node_stack.pop
+        node_stack.push temp
+      end
+  end
+end
+

data/lib/lambda_gem.rb

@@ -0,0 +1,9 @@
+require 'version'
+require 'dictionary'
+require 'node'
+require 'tree'
+require 'expression'
+
+module LambdaGem
+  # Your code goes here...
+end

data/lib/node.rb

@@ -0,0 +1,38 @@
+# Description
+#   A tree structure that contains the expression 
+#   in an infix notation tree.
+module LambdaGem
+
+  class Node
+    attr_accessor :left, :right, :data
+
+    def initialize data=nil
+      @data, @left, @right = data, nil, nil
+    end
+
+    def leaf?
+      @left.nil? and @right.nil?
+    end
+
+    def purge 
+      @data, @left, @right = nil, nil, nil
+    end
+
+    def traverse order=:infix
+      if leaf?
+        @data
+      else
+        left_child, right_child = @left.traverse(order), @right.traverse(order)
+
+        strs = case order
+          when :prefix then [@data, left_child, right_child]
+          when :infix then [left_child, @data, right_child]
+          when :postfix then [left_child, right_child, @data]
+          else []
+        end   
+        "(" + strs.join(" ") + ")"
+      end             
+    end
+
+  end
+end

data/lib/tree.rb

@@ -0,0 +1,20 @@
+require_relative 'node'
+
+module LambdaGem
+  class Tree
+    attr_accessor :root
+
+    def initialize root=nil
+        @root = Node.new root
+    end
+
+    def preorder_insert new_data
+      new_data
+    end
+
+    def traverse order=:infix
+      @root.traverse order
+    end
+
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module LambdaGem
+  VERSION = "0.0.1"
+end

data/spec/dictionary_spec.rb

@@ -0,0 +1,33 @@
+require 'lambda_gem'
+
+include LambdaGem
+
+describe Dictionary do
+
+	it "the default dictionary should contain seven operators" do
+		Dictionary.new.count.should eq(7)
+	end
+
+	it "should return nil for an unknown operator" do
+		dict = Dictionary.new
+		dict["boing"].should be_nil
+	end
+
+	it "an instance should return the correct lambda" do
+		dict = Dictionary.new
+		a, b, and_lambda = true, false, lambda { |a,b| a and b }
+
+		result_dict = dict["and"].call(a, b)
+		result_local = and_lambda.call(a, b)
+		result_local.should eq(result_dict)
+	end
+
+	it "should use the user defined dictionary if given in initialization" do
+		userDict = Hash.new 
+		userDict["xy"] = lambda { |a,b| a**b }
+
+		dict = Dictionary.new(userDict)
+		dict["xy"].call(2,3).should eq(8)
+	end
+
+end

data/spec/expression_spec.rb

@@ -0,0 +1,69 @@
+require 'lambda_gem'
+
+include LambdaGem
+
+describe Expression do 
+	it "should have a nil expression if nothing is given" do
+		Expression.new().formula.should be_nil
+	end
+	
+	it "should have an infix order as default" do
+		Expression.new().current_order.should eq(:infix)
+	end
+
+	it "should have infix ordering in case a non-acceotable ordering was passed" do
+		Expression.new(nil,:noorder).current_order.should eq(:infix)
+	end
+
+	it "should contain a Tree class instance in @tree" do
+		Expression.new().tree.class.should eq(Tree)
+	end
+
+	it "should verify correctly if a node's data are an operator contained in a given dictionary" do
+		expression = Expression.new
+		expression.operator?('+').should be_true
+	end
+
+	it "should not recognize a number as an operator" do
+		expression = Expression.new
+		expression.operator?('3').should be_false
+	end	
+
+	it "should be able to verify operators from a node" do
+		expression, node = Expression.new, Node.new(1)
+		expression.operator?(node).should be_false
+	end
+
+	it "should be able to store the expression as a expression tree and traverse it back to its original form" do
+		#the expression could also be given as 
+		# => (nd_age = 1 or nd_age = 2) and nd_gnd = 2
+		# it would be parsed correctly 
+		# but the returned expression couldn't match because of expressions
+		expression_test = "(((nd_age = 1) or (nd_age = 2)) and (nd_gnd = 2))"
+		expression = Expression.new expression_test, :infix
+		expression.tree.traverse(:infix).should eq(expression_test)
+	end
+
+	it "should identify correctly an operator " do
+		Expression.new.operator?('+').should be_true
+	end
+
+	it "should not identify a symbol as an operator " do
+		Expression.new.operator?('ni_auto').should be_false
+	end
+
+	it "should not identify a digit as an operator " do
+		Expression.new.operator?('9').should be_false
+	end	
+
+	it "should be able to correctly return all the token orders of an expression" do
+		expr_inorder = "(1 + 1)"
+		expr_preorder = "(+ 1 1)"
+		expr_postorder = "(1 1 +)"
+		expr = Expression.new "(1 + 1)"
+
+		expr.tree.traverse(:prefix).should eq(expr_preorder) and
+		expr.tree.traverse(:postfix).should eq(expr_postorder) and
+		expr.tree.traverse(:infix).should eq(expr_inorder)		
+	end
+end

data/spec/node_spec.rb

@@ -0,0 +1,15 @@
+require 'lambda_gem'
+
+include LambdaGem
+
+describe Node do
+	it "an empty node is a leaf" do
+		Node.new.leaf?
+	end
+
+	it "purge is called, all data in the node must be cleared" do
+		node = Node.new(1)
+		node.purge
+		node.data.should be_nil and node.left.should be_nil and node.right.should be_nil
+	end
+end

data/spec/tree_spec.rb

@@ -0,0 +1,18 @@
+require 'lambda_gem'
+
+include LambdaGem
+
+describe Tree do 
+	it "the root should a node with nill value an empty tree" do
+		Tree.new.root.data.should be_nil and Tree.new.root.class.should eq(Node)
+	end
+
+	it "the root should be of a node class" do
+		Tree.new(1).root.class.should eq(Node)
+	end
+
+	it "every node should contain the data given to it" do
+		tree = Tree.new(1)
+		tree.root.data.should eq(1)
+	end
+end

data/test.rb

@@ -0,0 +1,24 @@
+require_relative 'lib/tree'
+require_relative 'lib/expression'
+
+include LambdaGem
+
+tree = Tree.new '+'
+tree.root.left = Node.new(1)
+tree.root.right = Node.new(1)
+
+# puts "root #{tree.root.data}"
+# puts "left: #{tree.root.left.data}"
+# puts "right: #{tree.root.right.data}"
+
+exp = Expression.new 
+
+exp.formula = "((nd_gnd = 1) AND 
+		(nd_agr = 1 OR nd_agr = 2 OR nd_agr = 3 OR nd_agr = 4)) AND
+		((ni_care = 1 OR ni_care = 2 OR ni_care = 3 OR ni_care = 4) AND 
+		(ni_perf = 1 OR ni_perf = 2 OR ni_perf = 3 OR ni_perf = 4)) AND 
+		((na_book = 1 OR na_book = 2))"
+puts exp.tree.traverse :infix
+
+exp.formula = "(nd_agr = 1 or nd_agr = 0) and ni_auto = 9"
+puts exp.evaluate

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: lambda_gem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- angelos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Lambda expressions support
+email:
+- angelos.kapsimanis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- git_settings.txt
+- lambda_gem.gemspec
+- lib/dictionary.rb
+- lib/expression.rb
+- lib/lambda_gem.rb
+- lib/node.rb
+- lib/tree.rb
+- lib/version.rb
+- spec/dictionary_spec.rb
+- spec/expression_spec.rb
+- spec/node_spec.rb
+- spec/tree_spec.rb
+- test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: The current gem provides a lambda  calculus implementation with the possibility
+  to define any arbitrary operator with any functionality
+test_files:
+- spec/dictionary_spec.rb
+- spec/expression_spec.rb
+- spec/node_spec.rb
+- spec/tree_spec.rb