Создание класса XOR для реализации полного сумматора

Убедитесь, что в следующий раз вы разбиваете свой код на более мелкие фрагменты и тестируете их изолированно. Это поможет вам определить проблему. Поскольку эти логические ворота вызывают воспоминания, я не мог с собой поделать, реализовал их самостоятельно и написал длинный ответ :-)

Я внес некоторые улучшения (я бы назвал это так :-)) в ваш код:

Поскольку у вас разное количество входных данных, я бы НЕ заставлял ваш родительский класс Circuit принимать определенное количество входных данных, а затем переопределять, чтобы изменить это число. Либо удалите родительский класс (мой предпочтительный способ), либо заставьте его принимать переменное количество входных данных. Это имеет некоторые преимущества, но также и недостатки (необходим доступ к входам как inputs[0] и т. д. Вы можете обойти это, предоставив средства доступа):

class Circuit
  def initialize(*inputs)
    @inputs = inputs
  end

  def call
    raise "Please implement in #{__FILE__}"
  end

  def inspect
    "#{self.class.name}: #{inputs.join(', ')} => #{call}"
  end

  private

  attr_reader :inputs
end

Поскольку вы выбрали родительский класс, я реализовал несколько примеров, используя эту технику:

class AndGate < Circuit
  def call
    inputs.inject do |memo, input|
      memo &&= input
      memo
    end
  end
end

class OrGate < Circuit

  def call
    inputs.inject do |memo, input|
      memo ||= input
      memo
    end
  end
end

class NotGate < Circuit
  def call
    !inputs[0]
  end
end

AndGate и OrGate поддерживают произвольное количество входов:

p AndGate.new(true, true, true).call # => true

Если вам это не нравится... тогда вы можете ограничить ввод...

Также обратите внимание, что я переименовал cir_func в call. Это по двум причинам:

• Я не знаю, что означает cir
• Мне не нравятся сокращенные имена методов (func)

но, конечно, вы можете изменить это, как вам нравится.

Теперь вы можете написать несколько тестов для проверки поведения:

require 'minitest/autorun'
class GateTest < Minitest::Test
  def assert_table(klass, table)
    table.each do |inputs, outputs|
      gate = klass.new(*inputs)
      assert_equal outputs, gate.call, "Expected #{klass} to convert #{inputs} to #{outputs}"
    end
  end
end

class AndGateTest < GateTest

  def test_gate
    table = {
      [false, false] => false,
      [false, true] => false,
      [true, false] => false,
      [true, true] => true
    }
    assert_table(AndGate, table)
  end

end
class OrGateTest < GateTest

  def test_gate
    table = {
      [false, false] => false,
      [false, true] => true,
      [true, false] => true,
      [true, true] => true
    }
    assert_table(OrGate, table)
  end

end

class NotGateTest < GateTest

  def test_gate
    table = {
      [false] => true,
      [true] => false,
    }
    assert_table(NotGate, table)
  end

end

Я выбрал тест суперкласса, который предоставляет вспомогательный метод для подтверждения того, что логическая таблица.

Имея базовые ворота, вы можете начать строить составные:

class NandGate < Circuit
 def call
   NotGate.new(
    AndGate.new(*inputs).call
  ).call
 end
end

И еще несколько сложных:

class XOrGate < Circuit
  def call
    OrGate.new(
      AndGate.new(
        NotGate.new(inputs[0]).call,
        inputs[1]
      ).call,
      AndGate.new(
        inputs[0],
        NotGate.new(inputs[1]).call
      ).call
    ).call
  end
end

И тесты для тех:

class NandGateTest < GateTest

  def test_gate
    table = {
      [false, false] => true,
      [false, true] => true,
      [true, false] => true,
      [true, true] => false
    }
    assert_table(NandGate, table)
  end

end

class XOrGateTest < GateTest

  def test_gate
    table = {
      [false, false] => false,
      [false, true] => true,
      [true, false] => true,
      [true, true] => false
    }
    assert_table(XOrGate, table)
  end

end

И, наконец, мы можем реализовать полный сумматор с его тестом:

class FullAdderGate < Circuit
  def call

    sum = XOrGate.new(
      inputs[2],
      XOrGate.new(
        inputs[0],
        inputs[1]
      ).call
    ).call

    carry = OrGate.new(
      AndGate.new(inputs[0], inputs[1]).call,
      AndGate.new(
        XOrGate.new(inputs[0], inputs[1]).call,
        inputs[2]
      ).call
    ).call

    [carry, sum]
  end

end

Вы могли бы уменьшить этот метод, назначая/повторно используя промежуточные результаты, но я не мог придумать умные имена, поэтому я этого не сделал :-)

class FullAdderGateTest < GateTest

  def test_gate
    table = {
      [false, false, false] => [false, false],
      [false, false, true] => [false, true],
      [false, true, false] => [false, true],
      [false, true, true] => [true, false],
      [true, false, false] => [false, true],
      [true, false, true] => [true, false],
      [true, true, false] => [true, false],
      [true, true, true] => [true, true],
    }
    assert_table(FullAdderGate, table)
  end

end

Внимание: для вашего кода вы хотите убедиться, что вы конвертируете ввод, который вы читаете через gets, в логические значения. У вас уже есть код с Boolean.

Это полусумматор, который работает. Возможно, вы могли бы сделать такой полный сумматор без особых сложностей. Я не думаю, что есть веская причина для 30 страниц кода, когда речь идет о том, что, возможно, является самой простой и простой функцией компьютера.

#resulting values, do not set
sum0 = false
carry = false


#binary (set)
a = true
b = true

if a ^ b        #this is the equivalent of XOR
  sum0 = true
  carry = false
end

if a && b
  sum0 = false
  carry = true
end

#expand from here...