Day 27, Mat385

Last time

Next time

• Announcements
  • Your quiz today will be over section 8.2.

    This is your last quiz. Next week we'll be reviewing on Wednesday.

  • Your projects are due soon (Wednesday, 4/30). Then you will have until the 7th of May (by 11:59pm) to give me your evaluations (two days after your final).

• Last time:
  • We finished section 8.2: Logic Networks, and saw how we can move smoothly between three representations of the same problem:
    1. A truth table (or "truth function")
    2. A Boolean expression
    3. A logic network

  • We'll wrap up the full adder from section 8.2: Logic Networks
  • We continued with section 8.3: Minimization, with the objective to streamline Boolean expressions in two different ways:
    1. Karnaugh maps
    2. Quine-McCluskey
    The first is very visual, but only works for up to 4 variables. The second generalizes the first, allowing for as many variables as one wants, and works by looking for adjacencies between variables such as one finds in the Karnaugh map.

• Today:
  • We finish off with section 9.3: Finite State Machines

    We will hit the first part, which is creating machines to perform tasks such as binary addition.

    The second part, Monday, will cover recognition -- another task of FSMs -- and then minimization: again, an optimization issue. We'll end today on a machine that we will want to optimize; the question is how do we do that?

  • Then we'll have our quiz.

• Shannon's 1938 paper A symbolic analysis of relay and switching circuits (here's a local copy)
• George Boole's biography
• I love FSMs, and have implemented them in lisp, etc. But I was using some compartmental modeling software for my math modeling class, and realized that we could use that for building a little FSM. So I thought that I'd make something useful -- the binary adder.

  So if you want to try the binary adder I created, here ya go. And it's easy enough to build other little machines (but there are certain pains, because we're using a tool which really wasn't intended for this...:)

  1. You can get a free account on InsightMaker (but you won't need it to just run my examples).

  2. Open up My binary adder FSM at InsightMaker. If you have an account you can "Clone" it (upper right) -- then you'll own your own copy (and can change it to make your own FSM, or give your own input).

  3. You need to make two changes: set the two binary numbers' values, and then within "Settings" you need to set the length of the simulation. Then "Simulate" will run the machine, and generate the sum.

  4. I wrote this little bit of code to create the input in the right form:

     This writes the input vectors for random integers (with padding), and tells what settings to fix, etc. Also the expected output, so one can confirm that the machine is working....

  5. The instructions are included in the insight, at right. I've made a little video to illustrate how it works -- to walk you through it. Take a stroll, if you like!:)

  6. I built a little FSM to do the recognition of Exercise 26b, p. 754 -- set of all strings where the number of 0s is a multiple of 3.

• Dijkstra's Algorithm (defined recursively): once a node is settled, its job is done. It can be "swallowed up" into a smaller graph, where its use as a shortcut has generally reduced the distance between other pairs of nodes.

  This was fun to program, but probably more trouble than it was worth. A direct approach, as in my implementation of Bellman-Ford below, would have been simpler to code. But, if I can do something recursively, I probably will...:)
• Bellman-Ford Algorithm: Bellman-Ford finds the shortest distances between the starting node and every other node, and the paths. It starts with paths of length one (the adjacency matrix row for the start node), and then adds in successively longer paths (and can't add more than n-1, or it would be repeating nodes -- which would make no sense).
• Floyd's algorithm: finds the shortest distances between any two nodes, but doesn't contain any path information.
• Graph traversals:
• EulerPath: