布尔逻辑模拟器 - StackOverflowError

Question

我正在创建一个布尔逻辑模拟器。我发布了一个有关应用程序的组织和一般设置的问题，它位于此处：组织简单的布尔逻辑模拟器 - Java。我认为这并不直接适用于其他问题，所以单独发布这个问题是可以的。请原谅我的代码，我对 Java 很陌生。

代码的组织实际上非常简单，但是当我尝试在分配语句中将变量分配给自身时遇到了问题。

例如，我们通常会使用这样的语句：

assign input1 * input2 + test3 * input2 to test3;

当input1和input2为高电平时，test3将变高。此时，input1 可能会退出，而 test3 仍会很高，因为它在语句中引用了自身。 （注意：* => AND，+ => OR）正如您在下面看到的，当变量在上面的赋值语句中引用自身时，我遇到了问题。那是因为当我尝试获取上面语句的值时，我得到：

input1 * input2 + (input1 * input2 + (input1 * input2 + test3 * input2) * input2) * input2

等。它只是尝试评估其语句反复。

public interface Argument {
    public boolean evaluate();
}

这是存储有关每个位的信息的“Bit”类。该位可以是“硬连线”真或假，也可以有一个分配给它的语句。

public class Bit implements Argument {

    private String name;
    private boolean value;
    private Argument assign;
    private boolean assigned;

    Bit( String name, boolean value ) {
        this.name = name;
        this.value = value;
    }

    @Override
    public boolean evaluate() {
        if ( assigned == true ) {
            return assign.evaluate();
        } else {
            return value;
        }
    }

    public void setValue( boolean value ) {
        this.value = value;
    }

    public void setAssign( Argument assign ) {
        this.assign = assign;
        this.assigned = true;
    }

}

这是Operation类的一个例子；其他的都非常相似。

public class OrOperation implements Argument {

    private Argument argument1, argument2;

    public OrOperation( Argument arg1, Argument arg2 ) {
        this.argument1 = arg1;
        this.argument2 = arg2;
    }

    @Override
    public boolean evaluate() {
        return argument1.evaluate() || argument2.evaluate();
    }

}

解析器类：我只包含了其中的一部分，因为实际解析并不那么相关。 请注意，当我将变量分配给自身时，会产生错误。在下面的第二个测试中，我将 test3 分配给 test3。我可以推断这是因为 test3 尝试确定自身的值，一遍又一遍地调用第二个语句。

public class Parser {

    public HashMap<String, Bit> bits = new HashMap<String, Bit>();

    Parser(String file) {

        bits.put( "test1", new Bit( "test1", true ) );
        bits.put( "test2", new Bit( "test2", true ) );
        bits.put( "test3", new Bit( "test3", false ) );
        bits.put( "test4", new Bit( "test4", true ) );

        // Works great
        bits.get("test3").setAssign( parseStatement("test1 * ~test2 + test4 * test2") );
        System.out.println( bits.get("test3").evaluate() );

        // Produces error
        bits.get("test3").setAssign( parseStatement("test1 * test2 + test3 * test2") );
        System.out.println( bits.get("test3").evaluate() );

    }
}

解析器基本上创建如下语句：（取自上一个问题）

Operand op = new AndOperand( register1, new OrOperand( register2, register3 );
boolean output = op.evaluate(); // this is register1 && (register2 || register3 )

希望这足够清楚。如果对问题所在或我正在尝试做什么有任何疑问，请告诉我。提前致谢。

Answer 1

假设这是一个模拟器/评估器（而不是方程求解器），那么您需要将系统建模为随时间变化的状态。因此，语句：

assign test1 * input1 to test1;

意味着 test1_t+1 的状态是 test1_t * input1_t。

您的代码所做的不是区分 test1_t 和 test1_t+1 ...，因此导致无限递归。

一种解决方案是将状态（变量的值）与方程分开表示，并且使用不同的数据结构来表示 t 时刻的状态和 t + 时刻的状态1..

Answer 2

您所描述的是电路中的反馈回路。它们确实存在于现实中，在较低级别上它们用于例如存储元件（触发器和锁存器），在较高级别上您可以将其用于具有确实需要反馈的操作的电路（例如IIR滤波器）。

在这个更高级别的“应用程序”中，您在不同（逻辑）操作之间有寄存器。
这就是你如何将循环纳入你的逻辑中。然后，您必须计算结果作为时间的函数。

您可以从使用复位值（通常为 0）循环的寄存器/输入的内容开始。然后开始计算。您可以在中间的寄存器处中断循环，并通过赋值语句根据前一个周期的值计算一个周期的值。这也意味着即使输入不改变，输出也会随着时间步长的变化而变化。对于每个输出，您也拥有的不是单个输出值，而是输出序列（随时间变化）。

另一种选择（我建议您使用一个简单的模拟器）是禁止此类循环，并在识别它们时抛出错误消息。

如果这是用于生产，我只能建议：不要再次发明轮子。这不是一个新问题。例如，有硬件描述语言（例如 Verilog 或 VHDL），其中存在一些模拟器（例如，如果您想要免费的，可以使用来自 synopsys 的 vcs 或 verilator）。