Day 28, Mat385

Last time

Next time

• Announcements
  • Your quiz
    • The quiz
    • The key

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

  • On Wednesday we'll review! No quiz.

• Last time:

  We started work on section 9.3: Finite State Machines

• Today:
  • We finish off section 9.3: Finite State Machines, covering recognition -- another task of FSMs -- and then minimization: again, an optimization issue.

• 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: