ada_truthy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f60c11c32eb2f78bf12f596577d76cf7800f9f4a555c0bd68ab9ea2d9f5ddea
+  data.tar.gz: 86a813a004e5c51817a5bd7ab31d96bc8cfbed92e081d418b80f30d2dd06329a
+SHA512:
+  metadata.gz: 1e3f39e7f20a550147c303383d4c4f1f6ab7c2066c53cfa914ec168acd5e0ff466e77f218e0b947a5f2a6a6a9b1e687abc550d645062dbd8bbbffe651a3b6245
+  data.tar.gz: 30065c106ffe083fa2e8f285d831a8bb97eaa586a57aa5e63fce4848ad8f32b61b8132a8534b565b765e09b0e3b81c83a1591bc21906496f4b9e482f476ffc39

data/GEM_README.md

@@ -0,0 +1,30 @@
+# Truthy Gem
+
+### What is truthy anyway?
+
+Well, think of a truth table you just invented, you put your 1s and 0s and **Truthy** figures out which formula works
+for the table.
+
+| A   | B   | C   |
+|-----|-----|-----|
+| 0   | 0   | 1   |
+| 1   | 0   | 1   |
+| 1   | 1   | 0   |
+| 0   | 1   | 0   |
+
+If you create the above table with **Truthy**, it will know what to do so that your table makes sense.
+Also, **Truthy** has implementations for the following logical gates: `and`, `or`, `not`,
+`xor`, `nand`, `nor`, and `xnor`.
+
+### Where can I use it?
+
+- Access matrices are a good example;
+- Other examples are just day-to-day comparisons you do with booleans in your code.
+
+Let your imagination make good use of Truthy.
+
+### Where do I learn how to use it?
+
+Check the documentation [here](https://github.com/roberwil/truthy_gem/blob/main/README.md).
+Remember, **Truthy** is the way.
+

data/lib/ada_truthy.rb

@@ -0,0 +1,4 @@
+require_relative 'logical_gates/logical_gate_extension'
+require_relative 'truth_table/truth_table'
+
+

data/lib/logical_gates/logical_gate.rb

@@ -0,0 +1,59 @@
+class LogicalGate
+  def self.not(a)
+    return inot(a) if a.is_a? Integer
+    return !a
+  end
+
+  def self.and(a, b, *others)
+    return self.iand(a, b, others) if a.is_a? Integer
+    return false if (others.include?(false) || !a || !b)
+    return true
+  end
+
+  def self.nand(a, b, *others)
+    self.not self.and(a, b, others)
+  end
+
+  def self.or(a, b, *others)
+    return self.ior(a, b, others) if a.is_a? Integer
+    return true if others.include?(true) || a || b
+    return false
+  end
+
+  def self.nor(a, b, *others)
+    self.not self.or(a, b, others)
+  end
+
+  def self.xor(a, b, *others)
+    result = self.base_xor a, b
+
+    others.each do |term|
+      result = base_xor(result, term)
+    end
+
+    return result
+  end
+
+  def self.xnor(a, b, *others)
+    return !self.xor(a, b, others)
+  end
+
+  private
+  def self.base_xor(a, b)
+    a != b
+  end
+
+  def self.inot(a)
+    a == 1? 0 : 1
+  end
+
+  def self.iand(a, b, *others)
+    return 0 if others.include?(0) || a == 0 || b == 0
+    return 1
+  end
+
+  def self.ior(a, b, *others)
+    return 1 if others.include?(1) || a == 1 || b == 1
+    return 0
+  end
+end

data/lib/logical_gates/logical_gate_extension.rb

@@ -0,0 +1,75 @@
+require_relative 'logical_gate'
+
+class TrueClass
+  def not
+    LogicalGate.not self
+  end
+
+  def or(b, *others)
+    LogicalGate.or self, b, others
+  end
+
+  def nor(b, *others)
+    LogicalGate.nor self, b, others
+  end
+
+  def and(b, *others)
+    LogicalGate.and self, b, others
+  end
+
+  def nand(b, *others)
+    LogicalGate.nand self, b, others
+  end
+
+  def xor(b, *others)
+    LogicalGate.xor self, b, others
+  end
+
+  def xnor(b, *others)
+    LogicalGate.xnor self, b, others
+  end
+end
+
+class FalseClass
+  def not
+    LogicalGate.not self
+  end
+
+  def or(b, *others)
+    LogicalGate.or self, b, others
+  end
+
+  def nor(b, *others)
+    LogicalGate.nor self, b, others
+  end
+
+  def and(b, *others)
+    LogicalGate.and self, b, others
+  end
+
+  def nand(b, *others)
+    LogicalGate.nand self, b, others
+  end
+
+  def xor(b, *others)
+    LogicalGate.xor self, b, others
+  end
+
+  def xnor(b, *others)
+    LogicalGate.xnor self, b, others
+  end
+end
+
+class Integer
+  def not
+    LogicalGate.not self
+  end
+
+  def or(b, *others)
+    LogicalGate.or self, b, others
+  end
+
+  def and(b, *others)
+    LogicalGate.and self, b, others
+  end
+end

data/lib/truth_table/truth_table.rb

@@ -0,0 +1,216 @@
+require_relative 'truthy_exception'
+require_relative '../logical_gates/logical_gate_extension'
+
+class TruthTable
+  @@letters = %w[A B C D E F G H I J]
+
+  @@combinations = {
+    2 =>  04, 3 =>   8,  4 =>   16,
+    5 =>  32, 6 =>  64,  7 =>  128,
+    8 => 256, 9 => 512, 10 => 1024
+  }
+
+  MAX_LIMIT   =  6
+  MIN_LIMIT   =  2
+  SELF        = 'S'
+  COMPLEMENT  = 'C'
+  TRUE_VALUE  = 'T'
+  FALSE_VALUE = 'F'
+
+  def initialize(number_of_terms)
+    case number_of_terms
+    when number_of_terms > MAX_LIMIT
+      raise TruthyException, "The maximum number of terms is #{MAX_LIMIT}"
+    when number_of_terms < MIN_LIMIT
+      raise TruthyException, "The minimum number of terms is #{MIN_LIMIT}"
+    end
+
+    @number_of_terms = number_of_terms
+    @number_of_combinations = @@combinations[number_of_terms]
+
+    @cache   = Hash.new
+    @formula = Array.new
+    @rows    = Array.new
+
+    @using_sum_of_products = true
+    @using_product_of_sums = false
+
+    @number_of_zeros = 0
+    @number_of_ones  = 0
+  end
+
+  def add_row(*terms)
+    table_has_enough_rows = @rows.size == @number_of_combinations
+
+    if table_has_enough_rows
+      raise TruthyException, "There should be only #{@number_of_combinations} rows."
+    end
+
+    right_number_of_terms = terms.size == @number_of_terms + 1
+
+    unless right_number_of_terms
+      raise TruthyException, "There should be only #{@number_of_terms} terms."
+    end
+
+    row = terms
+
+    unless row_is_valid? row
+      raise TruthyException, "The combination #{row} has been used already."
+    end
+
+    @cache = {}
+
+    row_output = row[-1]
+    change_algorithm = (@rows.size == 0).and(row_output == 0)
+
+    use_product_of_sums if change_algorithm
+
+    @rows << row
+    (row_output == 1)? @number_of_ones += 1 : @number_of_zeros += 1
+
+    compute row
+  end
+
+  def check(*terms)
+    has_right_number_of_terms = terms.size == @number_of_terms
+
+    unless has_right_number_of_terms
+      raise TruthyException, "There should be only #{@number_of_terms} terms."
+    end
+
+    change_algorithm_if_needed
+
+    cache_code   = TruthTable.get_row_cache_code terms
+    cache_result = @cache[cache_code]
+
+    return cache_result unless cache_result.nil?
+
+    terms_cursor = 0
+    partial_result = true
+    result = false
+
+    if @using_product_of_sums
+      partial_result = false
+      result = true
+    end
+
+    @formula.each do |t|
+      if @using_sum_of_products
+        partial_result = (t == SELF ? partial_result.and(terms[terms_cursor]) :
+                           partial_result.and(!terms[terms_cursor]))
+      else
+        partial_result = (t == SELF ? partial_result.or(terms[terms_cursor]) :
+                           partial_result.or(!terms[terms_cursor]))
+      end
+
+      terms_cursor += 1
+      next if terms_cursor != @number_of_terms
+      terms_cursor = 0
+
+      if (@using_sum_of_products)
+        return true if partial_result
+        result = result.or(partial_result)
+        partial_result = true
+      else
+        return false if not partial_result
+        result = result.and(partial_result)
+        partial_result = false
+      end
+    end
+
+    @cache[cache_code] = result
+    return result
+  end
+
+  def to_s
+    terms_cursor   = 0
+    partial_result = ''
+    result         = ''
+
+    @formula.each do |t|
+      if @using_sum_of_products
+        partial_result += (t == SELF ? "#{@@letters[terms_cursor]}." : "~#{@@letters[terms_cursor]}.")
+      else
+        partial_result += (t == SELF ? "#{@@letters[terms_cursor]}+" : "~#{@@letters[terms_cursor]}+")
+      end
+
+      terms_cursor += 1
+      next if terms_cursor != @number_of_terms
+      terms_cursor = 0
+
+      result += (@using_sum_of_products? "(#{partial_result[0...-1]})+" : "(#{partial_result[0...-1]}).")
+      partial_result = ''
+    end
+
+    result[0...-1]
+  end
+
+  private
+  def row_is_valid?(row)
+    @rows.each do |existing_row|
+      is_equal = true
+
+      (0..existing_row.size - 1).each do |i|
+        is_equal = is_equal.and(row[i] == existing_row[i])
+      end
+
+      return false if is_equal
+    end
+
+    return true
+  end
+
+  def compute(row)
+    row_output = row[-1]
+
+    return if @using_sum_of_products.and(row_output != 1)
+    return if @using_product_of_sums.and(row_output != 0)
+
+    (0...row.size - 1).each do |i|
+      if @using_sum_of_products
+        @formula << (row[i] == 1 ? SELF : COMPLEMENT)
+      else
+        @formula << (row[i] == 1 ? COMPLEMENT : SELF)
+      end
+    end
+  end
+
+  def change_algorithm_if_needed
+    no_need_to_change = @using_sum_of_products.and(@number_of_zeros == 0).
+      or(@using_product_of_sums.and(@number_of_ones == 0))
+
+    return if no_need_to_change
+
+    more_zeros = @number_of_zeros > @number_of_ones
+
+    no_need_to_change = @using_sum_of_products.and(more_zeros).
+      or(@using_product_of_sums.and(!more_zeros))
+
+    return if no_need_to_change
+
+    more_zeros ? use_sum_of_products : use_product_of_sums
+
+    @formula = []
+    @cache   = {}
+
+    @rows.each do |row|
+      compute row
+    end
+  end
+
+  def use_sum_of_products
+    @using_sum_of_products = true
+    @using_product_of_sums = false
+  end
+
+  def use_product_of_sums
+    @using_sum_of_products = false
+    @using_product_of_sums = true
+  end
+
+  def self.get_row_cache_code(terms)
+    code = ''
+    terms.each { |term| code += (term ? TRUE_VALUE : FALSE_VALUE) }
+    return code
+  end
+end

data/lib/truth_table/truthy_exception.rb

@@ -0,0 +1,2 @@
+class TruthyException < StandardError
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: ada_truthy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Roberto W. P. Ribeiro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Create truth tables and let truthy handle the annoying part. Also, operate
+  with logical gates.
+email: rober.will@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- GEM_README.md
+files:
+- GEM_README.md
+- lib/ada_truthy.rb
+- lib/logical_gates/logical_gate.rb
+- lib/logical_gates/logical_gate_extension.rb
+- lib/truth_table/truth_table.rb
+- lib/truth_table/truthy_exception.rb
+homepage: https://github.com/roberwil/truthy_gem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Create truth tables and operate with logical gates.
+test_files: []