// This program is an example of the use of binary decision diagrams (BDD's).
// Since BDD's implement the BooleanAlgebra interface, all the boolean algebra
// operators ("&", "|", "^", "~", and "mux") can be used on BDD's.
import jazz.circuit.*;
import jazz.circuit.bdd.*;

// Function defined over any boolean algebra.
fun fbool(u, v, w) = (~u | v) & (v ^ w);

// Create three BDD variables "x", "y", and "z" such that "x < y < z".
var vars = Bdd.newVars(3)(["x", "y", "z"]);
var x = vars[0];
var y = vars[1];
var z = vars[2];

// Build the BDD that computes "fbool" by giving the three BDD variables as
// argument to "fbool" (this is legal since "fbool" is defined for any boolean
// algebra and BDD's implement the BooleanAlgebra interface).
var bdd = fbool(x, y, z);

// Display the BDD as a canonical set of Jazz equations (the "%a" format calls
// the "toString()" method of the BDD).
@ print("bdd(%a, %a, %a) = %a\n\n", x, y, z, bdd);

// Build a function "bdd2fun" that can be used to build a function that
// computes the BDD for x, y, and z over any particular boolean algebra given
// the "zero" and "one" constants of the algebra.
fun bdd2fun(zero, one)(x, y, z) =
  Bdd.toFunction(3)(vars)(1)([bdd])(zero, one)([x, y, z])[0];

// Build the function that computes the bdd for booleans (since zero=false,
// and one=true for this boolean algebra)
var fbool' = bdd2fun(false, true);

// Check that "fbool" and "fbool'" compute the same function over booleans
  var bools = [false, true];
  for (i < 2) {
    for (j < 2) {
      for (k < 2) {
        var u = bools[i];
        var v = bools[j];
        var w = bools[k];
        var fb = fbool(u, v, w);
        var fb' = fbool'(u, v, w);
        assert(fb == fb');
        @ print("fbool'(%a, %a, %a) = %a\n", u, v, w, fb);

// Check that "fper" computes the same thing as "fbool" for a few sets of
// three periodic numbers chosen at random.
  // Build the function that computes the BDD for periodics (since zero=#(0),
  // and one=#(1) for this boolean algebra).
  var fper = bdd2fun(#(0), #(1));
  // Returns a random periodic number.
  fun random() = (per) (Integer.random(25) / (1 + 2 * Integer.random(35)));
  @ print("\n");
  for (i < 5) {
    var u = random();
    var v = random();
    var w = random();
    var fb = fbool(u, v, w);
    var fp = fper(u, v, w);
    assert(fb == fp);
    @ print("fper(%a, %a, %a) = %a\n", u, v, w, fb);

// Create a new bdd from "fbool'", which is essentially the restriction of
// "fbool" to booleans (since "fbool" was defined over any boolean algebra),
// and thus implements the truth table of "fbool".
var bdd' = Bdd.fromFunction(3)(vars)(f)
  fun f(v) = fbool'(v[0], v[1], v[2]);

// Formally check that the two BDD's are indeed equal (that is to say, that
// they compute the same function).
assert(bdd == bdd');
@ print("\n(bdd == bdd')\n\n");

// Create a device computing the BDD over nets.
device Test {
  input in1: Net;
  input in2: Net;
  input in3: Net;
  output out: Net;

  var zero = Net.constant(#(0));
  var one = Net.constant(#(1));
  out = bdd2fun(zero, one)(in1, in2, in3);

export Test();