logic_analyzer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 93f454e3f8b567810914170b9850e7023993048d27fafa9a83c21be7e7718846
+  data.tar.gz: ebf24d0492a3e4b6c4884ad679e3cffe6a69c93cb5d8c742bbad13fbc4f36f5d
+SHA512:
+  metadata.gz: e0744be2c9a9558fe72a455381e2bca3a0875a23c9741e5eda2cbb4a09137c24e168bca04e5dbec51f2780ebd0d1142f8b3087f36c8e829ec2eb8e727bc782eb
+  data.tar.gz: 9107fb46e8b05a0a3cc8bd84a761a4e805a4bdccbe53f63463046e2674b55844392a3624a088fa46d78ddf411bb6263f4fccf3e7f154946d2323ff24cdd1a6af

data/lib/logic_analyzer.rb

@@ -0,0 +1,6 @@
+require_relative 'logic_analyzer/boolean'
+require_relative 'logic_analyzer/exception'
+require_relative 'logic_analyzer/logic_evaluation'
+require_relative 'logic_analyzer/logical_context'
+require_relative 'logic_analyzer/proposition'
+require_relative 'logic_analyzer/truth_table'

data/lib/logic_analyzer/boolean.rb

@@ -0,0 +1,41 @@
+module Boolean
+  def and(other)
+    self && other
+  end
+
+  def or(other)
+    self || other
+  end
+
+  def xor(other)
+    (self && !other) || (other && !self)
+  end
+
+  def then(other)
+    !self || other
+  end
+
+  def if_and_only_if(other)
+    self.then(other) && other.then(self)
+  end
+
+  def not(expression = nil)
+    if expression.nil?
+      !self
+    else
+      !expression
+    end
+  end
+
+  alias > :then
+  alias <=> if_and_only_if
+  alias != xor
+end
+
+class TrueClass
+  include Boolean
+end
+
+class FalseClass
+  include Boolean
+end

data/lib/logic_analyzer/exception.rb

@@ -0,0 +1,5 @@
+class Contingency < Exception
+  def initialize(msg = 'Proposition might not always be false or always true under any circumstance')
+    super(msg)
+  end
+end

data/lib/logic_analyzer/logic_evaluation.rb

@@ -0,0 +1,14 @@
+require_relative 'proposition'
+
+module LogicEvaluation
+  def logic_value
+    prop = Proposition.new(self)
+    prop.parse
+
+    prop.evaluate
+  end
+end
+
+class String
+  include LogicEvaluation
+end

data/lib/logic_analyzer/logical_context.rb

@@ -0,0 +1,33 @@
+require_relative 'boolean'
+
+class LogicalContext
+  def connectors
+    %i[and or xor then if_and_only_if not]
+  end
+
+  def define_premise(premise, value)
+    define_singleton_method(premise) do
+      value
+    end
+  end
+
+  def truth_value(sentence)
+    eval('lambda { ' + sentence + ' } ').call
+  end
+
+  def >(a, b)
+    a.then b
+  end
+
+  def <=>(a, b)
+    a.if_and_only_if b
+  end
+
+  def !=(a, b)
+    a.xor b
+  end
+
+  def not(expression)
+    !expression
+  end
+end

data/lib/logic_analyzer/proposition.rb

@@ -0,0 +1,57 @@
+require_relative 'logical_context'
+require_relative 'exception'
+require_relative 'truth_table'
+
+class Proposition
+  attr_accessor :sentence, :variables
+
+  def initialize(sentence)
+    @sentence = syntax_sugars(sentence)
+
+    @sentence.define_singleton_method(:words) do
+      split(/\W+/)
+    end
+
+    @sentence.define_singleton_method(:operands) do
+      split(/\s|\w|\s/).reject(&:empty?)
+    end
+  end
+
+  def syntax_sugars(sentence)
+    sugared = sentence.gsub(/and|&&/, '.and')
+                      .gsub(/or|\|\|/, '.or')
+                      .gsub(/then|>/, '.then')
+                      .gsub(/if_and_only_if|<=>/, '.if_and_only_if')
+                      .gsub(/xor|!=/, '.xor')
+                      .gsub(/not/, '!')
+  end
+
+  def parse
+    @variables = sentence.words
+  end
+
+  def evaluate
+    context = LogicalContext.new
+    values = []
+    table = TruthTable.new(variables)
+    table.generate_table
+
+    for iteration in 0...amount_of_variables
+      variables.each do |var|
+        context.define_premise(var, table.truth_value_of(var, iteration))
+      end
+
+      values.append(context.truth_value(sentence))
+    end
+
+    if values.include?(true) && values.include?(false)
+      raise Contingency
+    else
+      values.send(:all?)
+    end
+  end
+
+  def amount_of_variables
+    2**variables.length
+  end
+end

data/lib/logic_analyzer/truth_table.rb

@@ -0,0 +1,29 @@
+class TruthTable
+  attr_accessor :variables, :iterations, :table
+
+  def initialize(variables)
+    @variables = variables
+    @iterations = 2 ** variables.size
+    @table = []
+  end
+
+  def generate_table
+    for iteration in 0...iterations
+      row = []
+
+      for column in (variables.size - 1).downto 0
+        value = (iteration / 2 ** column).odd?
+        row.append(value)
+      end
+
+      table.append(row)
+    end
+
+    table
+  end
+
+  def truth_value_of(variable, row)
+    column = variables.find_index(variable)
+    table.at(row).at(column)
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: logic_analyzer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alejandro Peralta Bazas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-05 00:00:00.000000000 Z
+dependencies: []
+description: Ruby implementation of a propositional logic parser
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/logic_analyzer.rb
+- lib/logic_analyzer/boolean.rb
+- lib/logic_analyzer/exception.rb
+- lib/logic_analyzer/logic_evaluation.rb
+- lib/logic_analyzer/logical_context.rb
+- lib/logic_analyzer/proposition.rb
+- lib/logic_analyzer/truth_table.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: Propositional Logic Analyzer
+test_files: []