Day 29, Mat385

Last time

Next time

Announcements
- The Zooms continue
  A menu of our past zooms...
- Homework:
  - 9.3 (part 1): #1, 8, 20
    - #1 is pretty straightforward
    - #8 illustrates the translation between tabular and graphical descriptions of FSMs.
    - #20 is a bit mysterious: we are to describe "elevator behavior". What are the outputs? What are the inputs?
      - First of all, it seems that they're talking about the motion of a "call" to the elevator -- not a motion in response to a floor request from inside the elevator.
        That should certainly supercede a request from outside -- so if someone on floor 1 getting on the elevator pushes the 3 button, the elevator should not stop at floor 2 for a down request; but it should stop for an up request (if there's still time for a stop along the way).
        This obviously complexifies the machine, and you'd need more states for in-motion between floors, and which direction. Let's not work that hard!:)
      - So my thought is just to build the machine for calls from the outside -- even if this isn't realistic elevator behavior....
      - Inputs are buttons, which make the elevator change state: U1, U2, U3, D1, D2, or D3 (but we should eliminate those which are impossible -- D1, and U3).
      - The states of the elevator are just which floor its on.
      - No indication of the output. Is it the people that it dumps out?:)
        So we can give them all the same output.
- Your projects are due tonight. That means uploaded to the Wiki, and everything.
  Those who submit a project will then be assigned a couple to evaluate -- 2 other projects.
- Our final exam:
  1. Will be Thursday, 5/12, 4:40-6:40pm.
  2. It will be a two-hour, cumulative exam.
  3. It will be half new and half old material.
  4. You will be allowed a page of notes, front and back.
  5. Some old finals
  6. You might check the daily agendas for the reviews of our previous exam material. Certainly look over the old exams, and keys.
  7. New material (covered since the last exam): 6.3, 7.2, 7.3, 7.4, 8.1, 8.2, 8.3, and 9.3 (that's a lot of material).
  8. I'll have some review problems on Thursday.
Last time:
- We finished Section 9.3: Finite-State Machines.
  We looked at recognition and minimization.
  Recognition is an important job that FSMs can do; and minimization is important for providing simpler, sleeker FSM to do those jobs.
Today:
- Today we review
  - Let's start with your questions
  - Recent material
  - A recent final
  - Problems from a recent final (note: on problem 14, change the state graph so that $s_1 \rightarrow s_3$ on a 1 -- not to $s_0$ (cross that out), and $s_2 \rightarrow s_2$ on a 0).
Links:
- 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.
- Shannon's 1938 paper A symbolic analysis of relay and switching circuits (here's a local copy)
- George Boole's biography
- 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:
- Distilling Free-Form Natural Laws from Experimental Data. A computer rediscovers Newton's laws -- in a day!
  - Supplementary Material On-line
- Graph Terminology Handout
- Tree Terminology Handout
- If you check out this code, you'll see where I compute the power set ("all-subsets") of a set, to cover all the bases. I think that the end result is pretty beautiful, too!
- Recursive in-order, post-order, pre-order in lisp
- Recursive computation of Fibonacci numbers (in lisp)
- Recursive computation of rows from Pascal's triangle (in lisp)
- "String exponention" (in lisp)
- Here is the recursive selection sort algorithm, in lisp:
- Here is a recursive binary search algorithm in lisp:
- Closed-form computation of Fibonacci numbers (in lisp)
- Some examples of the Euclidean algorithm:
  1. Simple and clean recursive Euclidean Algorithm in lisp:
  2. Written as a while loop, using the recurrence relation:
- Here is a recursive bubbleSort algorithm in lisp
  
  (coded up following our author's algorithm, in section 3.3, p. 214, as closely as possible).
Details on why Dijkstra and Bellman-Ford work.

Website maintained by Andy Long. Comments appreciated.