What is Recursion? 21. Recursion. The Concept of Recursion Is Hard But VERY Important. Recursive Graphics. Tiling a Triangle.

Size: px

Start display at page:

Download "What is Recursion? 21. Recursion. The Concept of Recursion Is Hard But VERY Important. Recursive Graphics. Tiling a Triangle."

Britton Baker
5 years ago
Views:

1 . Recursion Recursive Tiling Recursive Evaluation of n! Tracking a Recursive Function Call Random Mondrian What is Recursion? A function is recursive if it calls itself. A pattern is recursive if it is defined in terms of itself. I can tell you what this is in terms of what that is. The Concept of Recursion Is Hard But VERY Important Teaching Plan: Develop a recursive triangle-tiling procedure informally. Fully implement (in Python) a recursive rectangle-tiling procedure. Fully implement a recursive function for n! Fully implement a recursive function for sorting (in a later lecture). Recursive Graphics We will develop a graphics procedure that draws this: The procedure will call itself. We are tiling a triangle with increasingly smaller triangles. Tiling a Triangle Tiling a Triangle We start with one big triangle: And are to end up with this:

Requires Repetition Repeat the Process Visit every yellow triangle and replace it with this Given a yellow triangle Define the inner triangle and the corner triangles Color the inner triangle and

2 Requires Repetition Repeat the Process Visit every yellow triangle and replace it with this Given a yellow triangle Define the inner triangle and the corner triangles Color the inner triangle and repeat the process on the corner triangles We Get This Repeat the Process Visit every yellow triangle and replace it with We Get This Repeat the Process Visit every yellow triangle and replace it with

3 We Get This The Notion of Level Etc. A level-0 tiling A level- tiling A level- tiling A level- tiling The Connection Between Levels The Connection Between Levels A level- tiling A level- tiling T T T0 T0 T T T T To display a level- tiling you do this: - display the inner triangle T0 - display a level- tiling of corner triangles T, T, and T To display an level-l tiling you do this: - display the inner triangle T0 - display an level-(l-) tiling of triangles T, T, and T Some Tools to Pull This Off class Point(object): def init (self,x,y): self.x = x self.y = y def Mid(self,other): """ Returns a point that encodes the midpoint of theline segment that connects the Point self and the Point other. """ Midpoints from Vertices P P T T0 T P P T P P P = P.Mid(P) P = P.Mid(P) P = P.Mid(P)

4 Some Tools to Pull This Off Coloring the Inner Triangle def DrawTriangle(P,P,P,c): """ Draws a triangle with vertices P, P, and P and FillColor c PreC: P, P, and P are points and c is a rgb list. """ P P T P T T0 T P P P DrawTriangle(P,P,P,MAGENTA) The Overall Procedure def Tile(P,P,P,L): if L ==0: # Base case. Draw a yellow triangle DrawTriangle(P,P,P,YELLOW) # Compute side midpoints P,P,P The Overall Procedure # Compute side midpoints P,P,P P = P.Mid(P) P = P.Mid(P) P = P.Mid(P) # Color inner triangle MAGENTA # Draw level L- tilings of T,T,T The Overall Procedure The Overall Procedure # Color the inner triangle magenta DrawTriangle(P,P,P,MAGENTA # Draw level-(l-) tilings of T, T, T Tile(P,P,P,L-) Tile(P,P,P,L-) Tile(P,P,P,L-) These are the recursive calls. 4

5 The Overall Procedure def Tile(P,P,P,L): if L ==0: # Base case. Draw a yellow triangle DrawTriangle(P,P,P,YELLOW) # Compute side midpoints P,P,P # Color inner triangle MAGENTA # Draw level L- tilings of T,T,T Tile(P,P,P,L-) Tile(P,P,P,L-) Tile(P,P,P,L-) A Note on Chopping up a Region into Triangles It is Important! Next Up An Area Of Interest A Non-Graphics Example of Recursion: The Factorial Function Step One in simulating flow around an airfoil is to generate a triangular mesh and (say) estimate the velocity at each little triangle using physics and math. Recursive Evaluation of Factorial Recall the factorial function: x = for k in range(,n+): x = x*k x Recursive Evaluation of Factorial Q. How would you compute! given that you have computed 5! = 0? A.! = 0 x 5! = xxx4x5 5! = xxx4x5 5

6 Recursive Evaluation of Factorial How does this work? We are in the calling script print n -> n -> The function F is called with argument. We open up a call frame. We encounter a function call. F is called with argument equal to. n -> n -> n -> n -> We open up a call frame. We encounter a function call. F is called with argument

7 n -> n -> n -> n -> n -> n -> We open up a call frame. The value of is assigned to n -> n -> n -> n -> n -> n -> The value is sent back to the caller. That function call is over n -> n -> n -> n -> Control now passes to this edition of F Control passes to this edition of F. The value is assigned to 7

8 n -> n -> n -> n -> The value is ed to the caller. The function call is over n -> n -> Control now passes to this edition of F The value is assigned to n -> n -> The value is ed to the caller. This function call is over. 8

Output: Control passes to the script that

Another Example: Random Mondrians Random

Mondrian The Subdivide Process Applies to

rectangle specified by its length, width,

9 Output: Control passes to the script that asked for F() All Done! Another Example: Random Mondrians Random Mondrian Given This: Using Python: Random Mondrian The Subdivide Process Applies to a Rectangle Draw This: (x,y) W L Given a rectangle specified by its length, width, and center, either randomly color it or randomly subdivide it. 9

Subdivision Starts with a Random Dart Throw This Defines 4 Smaller Rectangles Repeat the process on each of the 4 smaller rectangles This Defines 4 Smaller Rectangles The Notion of Level We can again

10 Subdivision Starts with a Random Dart Throw This Defines 4 Smaller Rectangles Repeat the process on each of the 4 smaller rectangles This Defines 4 Smaller Rectangles The Notion of Level We can again repeat the process on each of the smaller rectangles. Etc. A -level Partitioning A -level Partitioning Pseudocode def Mondrian(x,y,L,W,level): if level ==0: c = RandomColor()) DrawRect(x,y,L,W,FillColor=c) # Subdivide into 4 smaller rectangles Mondrian(upper left rectangle info,level-) Mondrian(upper right rectangle info,level-) Mondrian(lower left rectangle info,level-) Mondrian(lower right rectangle info,level-) How to Generate Random Colors We need some new technology to organize the selection random colors. We need lists whose entries are lists. We look at a few details. Complete implementation online 0

11 Lists with Entries that Are Lists An Example: cyan = [0.0,.0,.0] magenta = [.0,0.0,.0] yellow = [.0,.0,0.0] colorlist = [cyan,magenta,yellow] Pick a Color at Random cyan = [0.0,.0,.0] magenta = [.0,0.0,.0] yellow = [.0,.0,0.0] colorlist = [cyan,magenta,yellow] r = randi(0,) randomcolor = colorlist[r] Package the Idea from simplegraphics import * from random import randint as randi def RandomColor(): Returns a randomly selected rgb list. c = [RED,GREEN,BLUE,ORANGE,CYAN] i = randi(0,len(c)-) c[i] How to Randomly Subdivide a Rectangle (xc,y c) L (x,y ) W xc = randu(x-l/,x+l/) yc = randu(y-w/,y+w/) The Math Behind the Little Rectangles (xc,y c) L The upper right rectangle is typical: Length: Width: Center: (x,y ) W L = (x+l/)-xc W = (y+w/)-yc (xc+l/,yc+w/) The Procedure Mondrian A couple of features to make the design more interesting: () The dart throw that determines the subdivision can t land too near the edge. No super skinny tiles! () Randomly decide whether or not to subdivide. This creates a nice diversity in size.

12 Overall Conclusions Recursion is sometimes the simplest way to organize a computation. It would be next to impossible to do the triangle tiling problem any other way. On the other hand, factorial computation is easier via for-loop iteration. Overall Conclusions Infinite recursion (like infinite loops) can happen so careful reasoning is required. Will we reach the base case? Graphics examples: We will reach Level==0 Factorial: We will reach n==

5. Introduction to Procedures

5. Introduction to Procedures Topics: The module SimpleGraphics Creating and Showing figures Drawing Rectangles, Disks, and Stars Optional arguments Application Scripts Procedures We continue our introduction