Day 29, Mat385

Last time

Next time

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

    Only those who's projects are in place by midnight will be assigned reviewers, and only those who have their projects in place will serve as reviewers. So make sure that your project is in place by midnight. (I will be up, waiting!)

    I'm a little concerned by the number of pages on the Wiki that haven't even been started....

  • Your final is Monday, 5/5, from 2:30-4:30pm.
    • You will be allowed a one-page sheet, front and back.
    • It will be a two-hour, cumulative exam.
    • It will be 40% new and 60% old material.
    • You might check the daily agendas for the reviews of our previous exam material. Certainly look over the two midterm exams, and keys.

      Older material on the final will resemble the material you saw on the two midterms. That does not mean that related material cannot appear, but it won't be much of a stretch.

    • Check out the edited highlights for any sections you're unsure of.
    • Email me with any specific questions. We can still zoom, or perhaps meet in person until the final.
    • New material (covered since the last exam): 8.1, 8.2, 8.3, and 9.3.

• Last time:

  We finished up (mostly) section 9.3: Finite State Machines

  I do want to clean up just a little, before we start the review: we were a bit rushed last time at the very end, and didn't actually create a simplified machine. Let's start by fixing up that delay machine....

  I had a request to do another of the "equivalent state" problems, so we'll do that last one from the highlights, as well as build one finite state machine to do recognition.

• Today:
  • I'll start by handing out some problems from recent finals, that you might look over as representatives of what you might see.

  • A review of recent material: chapters 8 and 9

  • Looking back....

  • Here is an example final (from which the problems above were taken, with some modest modification): you'll notice that I allow some skipping.

    This one was probably a little too long. I do curve the final, by the way, and will give partial credit. So try all problems on which you can say anything at all that's reasonable!

    We've covered a lot of ground. But you should know that it's likely that there will be some topics that you'll be seeing and that you won't be able to skip.

  • Let's continue with any questions you might have.

  • And get on those projects!

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