twc/visual-modeling
5
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

start translating inline code to Ludus

Browse Source
This commit is contained in:
Scott Richmond 2024-12-01 19:18:35 -05:00
parent 9890a6f0c2
commit 3a7171b2e3
1 changed files with 92 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
ch_1_intro.md
View File

@ -185,12 +185,12 @@ Pinpoint the `x = 0` and `y = 0` point on your screen.
The turtle can be moved about the screen using cartesian x-y coordinates or turtle coordinates. The turtle can be moved about the screen using cartesian x-y coordinates or turtle coordinates.
Cartesian commands send the turtle to a specific xy position on the screen, without regard to the turtle's current position. Cartesian commands send the turtle to a specific xy position on the screen, without regard to the turtle's current position.
Various `SET` commands move the turtle through cartesian space. Various `set` commands move the turtle through cartesian space.
Review them. Review them.
In the turtle reference system, all commands refer to the turtle's current position, not its final position. In the turtle reference system, all commands refer to the turtle's current position, not its final position.
The turtle is moved forward, backward, turned left or right in relation to where it is now. The turtle is moved forward, backward, turned left or right in relation to where it is now.
Review the turtle reference commands: `FD`, `BK`, `PU`, `PD`, `RT` `LT`. Review the turtle reference commands: `fd`, `bk`, `pu`, `pd`, `rt` `lt`.
In the cartesian system, the destination is the important thing; in the turtle reference system, it's the trip. In the cartesian system, the destination is the important thing; in the turtle reference system, it's the trip.
@ -199,7 +199,7 @@ Let's draw a simple shape using turtle reference commands.
Suppose you would like the turtle to draw a square box located at the center of the screen (usually the origin of the coordinate system). Suppose you would like the turtle to draw a square box located at the center of the screen (usually the origin of the coordinate system).
Here are the steps you would take: Here are the steps you would take:
First, you would clear the screen by typing `CG` (clear graphics). First, you would clear the screen by typing `cg` (clear graphics).
The trutle now sits at 0,0 and faces straight up. The trutle now sits at 0,0 and faces straight up.
Second, you would think about the commands needed to walk the turtle through the shape. Second, you would think about the commands needed to walk the turtle through the shape.
@ -227,9 +227,9 @@ And here is what you will see.
Great. Great.
This series of commands does indeed draw the square you wanted; but wasn't it tedious to type in all that stuff? This series of commands does indeed draw the square you wanted; but wasn't it tedious to type in all that stuff?
The command `FD 50 RT 90` was typed four times. The command `forward! (50); right! (0.25)` was typed four times.
Surely there is a shorthand method to repeat this line four times without typing four times. Surely there is a shorthand method to repeat this line four times without typing four times.
Review the `REPEAT` command; it is exactly what we need here. Review the `repeat` command; it is exactly what we need here.
Try it. Try it.
``` ```
@ -239,7 +239,7 @@ repeat 4 {
} }
``` ```
Notice that the line `repeat 4 { forward! (50); right! (0.25) }` is a kind of operational definition of what a square is: a square is four sides, four `FD` commands, with each side joined at right angles to the next, the `RT 90` commands. Notice that the line `repeat 4 { forward! (50); right! (0.25) }` is a kind of operational definition of what a square is: a square is four sides, four `fd` commands, with each side joined at right angles to the next, the `RT 90` commands.
That's tidy, but it's still a bore to type two lines each time you want a size 50 box on the screen. That's tidy, but it's still a bore to type two lines each time you want a size 50 box on the screen.
After all, you may want to draw 100 boxes. After all, you may want to draw 100 boxes.
@ -249,7 +249,7 @@ Wouldn't it be convenient to be able to "tell" Logo your definition of a square
You can group a series of Logo commands together under a single name by writing a Logo procedure. You can group a series of Logo commands together under a single name by writing a Logo procedure.
The name of the procedure is a shorthand for all commands included in it. The name of the procedure is a shorthand for all commands included in it.
Typing the name of the procedure tells Logo to automatically execute each line of the procedure in turn, just as if you had typed them, one after another, on the keyboard. Typing the name of the procedure tells Logo to automatically execute each line of the procedure in turn, just as if you had typed them, one after another, on the keyboard.
You can "tell" Logo your definition of a square by creating a procedure called `SQUARE`. You can "tell" Logo your definition of a square by creating a procedure called `square`.
Logo will "remember" your definition until you either erase it or turn off your computer. Logo will "remember" your definition until you either erase it or turn off your computer.
Review the defining and editing procedures in your Logo manual. Review the defining and editing procedures in your Logo manual.
@ -266,14 +266,14 @@ fn box50! () -> {
} }
``` ```
Logo will add `BOX50` to all its other commands. Logo will add `box50` to all its other commands.
Each time you type `BOX50`, the turtle will draw a square of size 50. Each time you type `box50`, the turtle will draw a square of size 50.
The figure will be drawn at the turtle's current position on the screen. The figure will be drawn at the turtle's current position on the screen.
Unless you move the turtle to a different starting point, each time you type `BOX50`, the square produced will be on top of the previously drawn figure. Unless you move the turtle to a different starting point, each time you type `box50`, the square produced will be on top of the previously drawn figure.
So move the turtle around to new positions and draw some more boxes. So move the turtle around to new positions and draw some more boxes.
But you can certainly be more imaginative than that. But you can certainly be more imaginative than that.
Create an interesting design on the screen using only the `BOX50` procedure and move commands. Create an interesting design on the screen using only the `box50` procedure and move commands.
If you have a color screen, you might want to investigate the effects of changing the screen's background color and the color of the pen. If you have a color screen, you might want to investigate the effects of changing the screen's background color and the color of the pen.
Keep track of what you are doing in your notebook so that you can reconstruct your successful designs. Keep track of what you are doing in your notebook so that you can reconstruct your successful designs.
@ -299,23 +299,23 @@ Is one image more pleasing than the other? Why?
### Generalizing procedures ### Generalizing procedures
What about boxes of different sizes? What about boxes of different sizes?
You could edit the `BOX50` procedure every time you wanted it to draw a different size box. You could edit the `box50!` procedure every time you wanted it to draw a different size box.
You could also define many `BOX`-like procedures, each to draw a different size box. You could also define many `box`-like procedures, each to draw a different size box.
But that doesn't seem very efficient, does it? But that doesn't seem very efficient, does it?
After all, Logo itself doesn't have a different `FD` command for every possible length of line that you might wish the turtle to draw. After all, Logo itself doesn't have a different `forward!` command for every possible length of line that you might wish the turtle to draw.
There is not a `FD-1O` command for drawing lines of length 10 and a `FD-43` command for drawing them 43 units long. There is not a `forward!-10` command for drawing lines of length 10 and a `forward!-43` command for drawing them 43 units long.
Logo has a single `FD` command. Logo has a single `forward!` command.
Whenever `FD` is used, an argument must be used in conjunction with it: the form is `FD` argument. Whenever `forward!` is used, an argument must be used in conjunction with it: the form is `forward!` argument.
A single argument must be typed just after `FD`. A single argument must be typed just after `forward!`.
For example, one could type: `FD 10` or `FD 43`. For example, one could type: `forward! (10)` or `forward! (43)`.
The value of the argument "tells" `FD` how to go about its business of drawing straight lines. The value of the argument "tells" `forward!` how to go about its business of drawing straight lines.
Isn't this convenient? Isn't this convenient?
One command does a variety of things. One command does a variety of things.
`FD argument` draws straight lines of _any_ length. `forward! (argument)` draws straight lines of _any_ length.
If we change the value of the argument, the line length changes accordingly. If we change the value of the argument, the line length changes accordingly.
Let's _generalize_ `BOX50` in terms of box size as `FD` is _general_ in terms of line length. Let's _generalize_ `box50!` in terms of box size as `forward!` is _general_ in terms of line length.
### Adding an argument to a procedure ### Adding an argument to a procedure
Define a new box procedure that has a size argument. Define a new box procedure that has a size argument.
@ -334,7 +334,7 @@ fn box! (edge) -> {
``` ```
### Putting a demonsuation procedure together ### Putting a demonsuation procedure together
I am sure that by this time you have already designed some interesting patterns with various `BOX` procedures. I am sure that by this time you have already designed some interesting patterns with various `box!` procedures.
Some of these patterns you probably liked enough to print and glue into your notebook. Some of these patterns you probably liked enough to print and glue into your notebook.
Remember to include a few written comments on what you were trying to achieve. Remember to include a few written comments on what you were trying to achieve.
@ -355,7 +355,7 @@ Here is an example of such a demonstration procedure:
``` ```
& A demonstration procedure to show off a design & A demonstration procedure to show off a design
& produced from multiple boxes of different sizes. & produced from multiple boxes of different sizes.
fn demo () -> { fn demo! () -> {
repeat 4 { repeat 4 {
box! (100) box! (100)
box! (98) box! (98)
@ -369,7 +369,7 @@ fn demo () -> {
} }
``` ```
To see the pattern defined by `DEMO`, type it: To see the pattern defined by `demo!`, type it:
{{Figure 4: Differently sized boxes. Top of p. 15.}} {{Figure 4: Differently sized boxes. Top of p. 15.}}
@ -414,12 +414,12 @@ To generalize a procedure is to stretch your thinking about what it does; and th
Pin that phrase over your computer screen. Pin that phrase over your computer screen.
### Generalizing a procedure with arguments ### Generalizing a procedure with arguments
Let's go back to that `BOX` procedure. Let's go back to that `box!` procedure.
Can we generalize it so that it draws triangle "boxes" as well as square ones? Can we generalize it so that it draws triangle "boxes" as well as square ones?
While we are at it, let's ask `BOX` to draw boxes with any number of equal sides. While we are at it, let's ask `box!` to draw boxes with any number of equal sides.
These shapes will be regular polygons with n sides. These shapes will be regular polygons with n sides.
Why not call the generalized procedure `NGON` for n-sided polygon? Why not call the generalized procedure `ngon!` for n-sided polygon?
Look again at the procedure BOX and decide what needs to be changed to turn `BOX` into `NGON`. Look again at the procedure BOX and decide what needs to be changed to turn `box!` into `ngon!`.
``` ```
fn box! (edge) -> { fn box! (edge) -> {
@ -430,10 +430,10 @@ fn box! (edge) -> {
} }
``` ```
You need to add a second argument `:N`. You need to add a second argument `n`.
This will tell Logo how many sides to draw. This will tell Logo how many sides to draw.
We can replace the `REPEAT 4` with `REPEAT :N`. We can replace the `repeat 4` with `repeat n`.
`FD :EDGE` will stay the same, but what about the angle you want the turtle to turn before drawing the next side? `forward! (edge)` will stay the same, but what about the angle you want the turtle to turn before drawing the next side?
It surely will be different for different sided polygons. It surely will be different for different sided polygons.
Generally, sketching focuses geometric thinking. Generally, sketching focuses geometric thinking.
Here are some walking plans that you might issue to the turtle to do NGON.s 7. Here are some walking plans that you might issue to the turtle to do NGON.s 7.
@ -441,12 +441,12 @@ Here are some walking plans that you might issue to the turtle to do NGON.s 7.
{{Figure 5: Triangle, square, pentagon. Middle of p. 17.}} {{Figure 5: Triangle, square, pentagon. Middle of p. 17.}}
How can you calculate the angle indicated by the "?" for any n-sided polygon? How can you calculate the angle indicated by the "?" for any n-sided polygon?
Your geometric intuition should tell you that the turtle, after making `:N` turns, will end up facing the same direction in which it started. Your geometric intuition should tell you that the turtle, after making `n` turns, will end up facing the same direction in which it started.
The amount of each individual turn will be 360 divided by thenumber of turns,or `360/:N`. The amount of each individual turn will be 360 divided by thenumber of turns,or `360/n`.
(Now is the time to recall Logo's mathematical capacities. (Now is the time to recall Logo's mathematical capacities.
Review the Logo notation to add, subtract, multiply, and divide.) Review the Logo notation to add, subtract, multiply, and divide.)
You are ready to write the new procedure NGON: You are ready to write the new procedure `ngon!`:
``` ```
fn ngon! (n, edge) -> { fn ngon! (n, edge) -> {
@ -458,20 +458,20 @@ fn ngon! (n, edge) -> {
``` ```
Try it out. Try it out.
Notice that when `:N` becomes large, the drawn figure becomes a circle (almost). Notice that when `n` becomes large, the drawn figure becomes a circle (almost).
Carry out some clever visual experiments with `NGON`s. Carry out some clever visual experiments with `ngon`s.
### Some observations ### Some observations
Look back carefully at what we have done so far with procedure writing. Look back carefully at what we have done so far with procedure writing.
We started with a list of commands that drew a box of a single size. We started with a list of commands that drew a box of a single size.
Next, we grouped these commands into procedures that could draw boxes of several different sizes. Next, we grouped these commands into procedures that could draw boxes of several different sizes.
Next, we generalized the `BOX` procedure with an argument so that it could draw boxes of any size. Next, we generalized the `box!` procedure with an argument so that it could draw boxes of any size.
Finally, we produced a still more general procedure, `NGON`, that can draw any regular, polygonal "box"--triangles, squares, pentagons, hexagons, and so on--of whatever size we wanted. Finally, we produced a still more general procedure, `ngon!`, that can draw any regular, polygonal "box"--triangles, squares, pentagons, hexagons, and so on--of whatever size we wanted.
### Making the simple more complete ### Making the simple more complete
What next? What next?
How can we make these simple polygons more interesting? How can we make these simple polygons more interesting?
Maybe we can add another polygon characteristic to `NGON`. Maybe we can add another polygon characteristic to `ngon!`.
Sometime in your life you were probably given an exercise like the following. Sometime in your life you were probably given an exercise like the following.
"Cut out some different sized squares from a sheet of colored paper and think about placing the squares on a large piece of white paper. "Cut out some different sized squares from a sheet of colored paper and think about placing the squares on a large piece of white paper.
@ -484,7 +484,7 @@ Each design used the same squares.
What made them different? What made them different?
Their placement. Their placement.
Make `NGON` draw a bunch of `NGON`s and put them on the screen according to some placement rule. Make `ngon!` draw a bunch of `ngon`s and put them on the screen according to some placement rule.
Take out your notebook and doodle. Take out your notebook and doodle.
Here are some results from my doodling. Here are some results from my doodling.
Your approach will be different. Your approach will be different.
@ -492,21 +492,21 @@ I'll explain mine, and I'll expect that your plans will go into your notebook.
Sketches of spinning polygons that grow or shrink as they spin Sketches of spinning polygons that grow or shrink as they spin
{{Figure 6: Sketches of `BOX`es of different spins and sizes. Bottom of p. 19.}} {{Figure 6: Sketches of `box`es of different spins and sizes. Bottom of p. 19.}}
### Word description of sketched ideas ### Word description of sketched ideas
"I want Logo to draw a series of polygons rotating around a common point, and I want each successive polygon to get bigger, or maybe get smaller. "I want Logo to draw a series of polygons rotating around a common point, and I want each successive polygon to get bigger, or maybe get smaller.
"I don't know what angle to turn between one polygon and the next, so I'll include an argument called `:ANGLE` that I can vary, to see what happens. "I don't know what angle to turn between one polygon and the next, so I'll include an argument called `angle` that I can vary, to see what happens.
"I don't know how big the growth should be between one polygon and the next, so I'll define another argument called `:GROWTH`. "I don't know how big the growth should be between one polygon and the next, so I'll define another argument called `growth`.
I'll play with different values of `:GROWTH` to seewhat looks best. I'll play with different values of `growth` to seewhat looks best.
"How do I make `:GROWTH` work? "How do I make `growth` work?
Growth can be of two sorts: growth by a constant amount, or growth by a constant percentage. Growth can be of two sorts: growth by a constant amount, or growth by a constant percentage.
I'll try the latter. I'll try the latter.
That means that if I want polygons to grow by 10%, I define `:GROWTH` to be 1.10. That means that if I want polygons to grow by 10%, I define `growth` to be 1.10.
For a 90% shrinkage I would use `:GROWTH`=.9." For a 90% shrinkage I would use `growth`=.9."
### A procedure to spin polygons ### A procedure to spin polygons
``` ```
@ -520,13 +520,13 @@ fn spingon! (n, edge, angle, growth) -> {
What is new here? What is new here?
First, there are more arguments than you have seen before. First, there are more arguments than you have seen before.
Every time you use `SPINGON`, you must remember to type four numbers after it. Every time you use `spingon`, you must remember to type four numbers after it.
Second, this procedure is recursive: the last line in the `SPINGON` procedure asks that `SPINGON` be done again, but with some arguments changed. Second, this procedure is recursive: the last line in the `spingon` procedure asks that `spingon` be done again, but with some arguments changed.
For example, `(:EDGE)` becomes `(:EDGE*:GROWTH)` the first time recursion is called; and then `(:EDGE*:GROWTH)` becomes `(:EDGE*:GROWTH)*:GROWTH` the For example, `(edge)` becomes `mult (edge, growth)` the first time recursion is called; and then `mult (edge, growth)` becomes `mult (mult (edge, growth), growth)` the
second time recursion is called. second time recursion is called.
A recursive procedure is a procedure that uses itself as one of its parts. A recursive procedure is a procedure that uses itself as one of its parts.
Will `SPINGON` ever stop? Try it out. Will `spingon!` ever stop? Try it out.
### Some spingons ### Some spingons
``` ```
@ -547,18 +547,18 @@ spingon! (40, 120, 0, 0.25, 19)
### Stopping recursive procedures ### Stopping recursive procedures
One last procedural writing point to review. One last procedural writing point to review.
Having put `SPINGON` into motion, how do you make it stop at a stage of your choosing? Having put `spingon!` into motion, how do you make it stop at a stage of your choosing?
You need to have a way of telling it how to stop. You need to have a way of telling it how to stop.
That's another characteristic to include as an argument. That's another characteristic to include as an argument.
Look at the following modification to `SPINGON`. Look at the following modification to `spingon!`.
Review the conditional commands in Logo. Review the conditional commands in Logo.
`IF... [something]` is such a conditional. `if ::something:: then ::something:: else ::something::` is such a conditional.
Using the `IF` phrase, everything becomes very tidy. Using the `if` form, everything becomes very tidy.
``` ```
fn spingon! (n, edge, angle, growth, times) -> { fn spingon! (n, edge, angle, growth, times) -> {
& Note the new argument above. & Note the new argument above.
if lt? (times, 1) then :stop if lt? (times, 1) then :ok
& This is the conditional stopper. & This is the conditional stopper.
else { else {
ngon! (n, edge) ngon! (n, edge)
@ -583,7 +583,7 @@ Here are several of my presentation rules.
First, the _many comments_ rule. First, the _many comments_ rule.
I have included wordy explanations in some of my procedures. I have included wordy explanations in some of my procedures.
These comments begin with the Logo command "`;`". These comments begin with the Logo command "`&`".
There is, of course, no need for you to include thesecomments in your own version of my procedures. There is, of course, no need for you to include thesecomments in your own version of my procedures.
However, it is a good idea for you to put comments in your own procedures. However, it is a good idea for you to put comments in your own procedures.
@ -596,7 +596,7 @@ Notice the use of comments, too.
``` ```
fn spingon! (n, edge, angle, growth, times) -> { fn spingon! (n, edge, angle, growth, times) -> {
& Note the new argument above. & Note the new argument above.
if lt? (times, 1) then :stop if lt? (times, 1) then :ok
& This is the conditional stopper. & This is the conditional stopper.
else { else {
ngon! (n, edge) ngon! (n, edge)
@ -635,8 +635,8 @@ The first is so important that we will go through it together, step by step.
You can work on the other exercisesby yourself. You can work on the other exercisesby yourself.
#### Exercise 1.1 #### Exercise 1.1
Make `NGON` more versatile by doing two things to it. Make `ngon!` more versatile by doing two things to it.
First, improve `NGON` so that it will draw polygons _around a central point_; and second, improve `NGON` so that it can be given an argument that specifies not the length of an edge of the polygon but the _radius of the polygon_. First, improve `ngon!` so that it will draw polygons _around a central point_; and second, improve `ngon!` so that it can be given an argument that specifies not the length of an edge of the polygon but the _radius of the polygon_.
I've made up the term radius of a polygon. I've made up the term radius of a polygon.
It is the radius of the smallest circle that just encloses a regular polygon. It is the radius of the smallest circle that just encloses a regular polygon.
The center of this circle is the point around which the polygon is to be drawn. The center of this circle is the point around which the polygon is to be drawn.
@ -644,11 +644,11 @@ Seethe diagram below.
{{Figure 9: Polygons inscribed in dotted circles. Bottom of p. 24}} {{Figure 9: Polygons inscribed in dotted circles. Bottom of p. 24}}
Call the revised procedure `CNGON` for "**c**entered **NGON**." Call the revised procedure `cngon!` for "**c**entered **NGON**."
Two hints: First, ask yourself what arguments `CNGON` will need. Two hints: First, ask yourself what arguments `cngon!` will need.
This is another way to ask yourself what information must be given to `CNGON` so that it can go about its business of drawing centered `NGON`s. This is another way to ask yourself what information must be given to `cngon!` so that it can go about its business of drawing centered `ngon`s.
`CNGON` needs only two pieces of information, or two arguments: the number of sides of the polygon to be drawn and the radius of that polygon. `cngon!` needs only two pieces of information, or two arguments: the number of sides of the polygon to be drawn and the radius of that polygon.
That means that the first line of the new procedure will look like this: That means that the first line of the new procedure will look like this:
``` ```
@ -656,7 +656,7 @@ cngon! (n, rad)
``` ```
Second, imagine yourself as the turtle. Second, imagine yourself as the turtle.
How would you walk through the design that `CNGON` must make? How would you walk through the design that `cngon!` must make?
Draw a simple diagram to describe such a "turtle walk." Draw a simple diagram to describe such a "turtle walk."
You might want to divide the diagram up into individual scenes. You might want to divide the diagram up into individual scenes.
Later you can translate each scene in words and then into Logo notation. Later you can translate each scene in words and then into Logo notation.
@ -670,7 +670,7 @@ You, as the turtle, begin your journey from position (1), the center of the prop
You are facing straight up. You are facing straight up.
Pick up your pen and move forward by the amount of the polygon's radius. Pick up your pen and move forward by the amount of the polygon's radius.
This is `:RAD`. This is `rad`.
This puts you in position (2). This puts you in position (2).
You now need to turn right by an amount that is labeled (angle) on the sketch (3). You now need to turn right by an amount that is labeled (angle) on the sketch (3).
@ -691,25 +691,25 @@ Put down the pen in preparation for drawing the polygon.
Diagram B: **Drawing the polygon**. Diagram B: **Drawing the polygon**.
You are at position (4) and ready to draw an n-sided polygon. You are at position (4) and ready to draw an n-sided polygon.
You can use the procedure `NGON`. You can use the procedure `ngon!`.
But what arguments will you use? But what arguments will you use?
It needs some values for `:N` and `:EDGE`. It needs some values for `n` and `edge`.
Right? Right?
Yes, but wait a minute. Yes, but wait a minute.
What should the value for `:EDGE` be? What should the value for `edge` be?
You know the value of `:N`, the number of sides of the polygon. You know the value of `n`, the number of sides of the polygon.
And you know the value of the new argument, `:RAD`. And you know the value of the new argument, `rad`.
What must the polygon's edge dimension be so that, after it is drawn, it has a radius equal to `:RAD`? What must the polygon's edge dimension be so that, after it is drawn, it has a radius equal to `rad`?
In other words, we need to be able to express `:EDGE` in terms of `:N` and `:RAD`. In other words, we need to be able to express `edge` in terms of `n` and `rad`.
OK. OK.
We know the problem, what we have to work on, but let's not stop yet. We know the problem, what we have to work on, but let's not stop yet.
Label the edge thing that must be calculated (edge). Label the edge thing that must be calculated (edge).
We will return to it in a minute. We will return to it in a minute.
Now you can draw an `NGON :N (edge)`. Now you can draw an `ngon! (n, edge)`.
You began the `NGON` from position (4). You began the `ngon` from position (4).
You will end at the same place. You will end at the same place.
Diagram C: **Getting ready to return to the center**. Diagram C: **Getting ready to return to the center**.
@ -719,7 +719,7 @@ This leaves you in position (8), pointing straight up.
Diagram D: **Returning to the center of the polygon**. Diagram D: **Returning to the center of the polygon**.
Pick up your pen and back down, by an amount equal to `:RAD`, to the polygon's center. Pick up your pen and back down, by an amount equal to `rad`, to the polygon's center.
Finally, put your pen down in preparationfor whatevermight comenext. Finally, put your pen down in preparationfor whatevermight comenext.
Note that you, as the turtle, have ended in the sameposition (9) as you began (1). Note that you, as the turtle, have ended in the sameposition (9) as you began (1).
### A turtle walk transfonned into a Logo procedure (almost) ### A turtle walk transfonned into a Logo procedure (almost)
@ -749,7 +749,7 @@ We might as well use this opportunity to review all the bits and pieces of polyg
### The Geometry of CNGONs ### The Geometry of CNGONs
Use the following two diagrams in conjunction with the word and equation descriptions. Use the following two diagrams in conjunction with the word and equation descriptions.
{{Figure 11: Geometry of `CNGON`s. Bottom of p. 28.}} {{Figure 11: Geometry of `cngon`s. Bottom of p. 28.}}
The first problem we face is to find an expression for angle d in terms of n, the number of sides of the polygon. The first problem we face is to find an expression for angle d in terms of n, the number of sides of the polygon.
The second problem is to find an expression for the length of a polygon's edge, e, in terms of its radius, R, and n, the number of sides. The second problem is to find an expression for the length of a polygon's edge, e, in terms of its radius, R, and n, the number of sides.
@ -758,7 +758,7 @@ In preparation for these two acts, let's look at all the angles associated with
The _central angles_, labeled a, are easy. The _central angles_, labeled a, are easy.
They are each equal to 360/n. They are each equal to 360/n.
The _external angles_, labeled c, are also equal to 360/n. The _external angles_, labeled c, are also equal to 360/n.
The external angle is the turning angle used in `NGON`. The external angle is the turning angle used in `ngon!`.
What about the internal angles, labeled b. What about the internal angles, labeled b.
We need some work here: We need some work here:
@ -793,8 +793,8 @@ What is ani arctangent?
Draw some diagrams to explain each of these functions. Draw some diagrams to explain each of these functions.
Glue them on the inside cover of your notebook. Glue them on the inside cover of your notebook.
### Installing the necessary geometry into `CNGON` ### Installing the necessary geometry into `cngon!`
Here's how far we have gotten with `CNGON`: Here's how far we have gotten with `cngon!`:
``` ```
fn cngon! (n, rad) -> { fn cngon! (n, rad) -> {
@ -811,7 +811,7 @@ fn cngon! (n, rad) -> {
``` ```
Now we can replace `(angle)` and `(edge)` with the needed expressions. Now we can replace `(angle)` and `(edge)` with the needed expressions.
Here is the finished `CNGON`: Here is the finished `cngon`:
``` ```
fn cngon! (n, rad) -> { fn cngon! (n, rad) -> {
@ -831,11 +831,11 @@ fn cngon! (n, rad) -> {
``` ```
### Lessons and tips ### Lessons and tips
When solving visual problems, like this `CNGON` thing, try to break the single big problem down into several smaller problems. When solving visual problems, like this `cngon!` thing, try to break the single big problem down into several smaller problems.
Solve each of the small problems in turn, and then plug the little solutions together to form one big solution. Solve each of the small problems in turn, and then plug the little solutions together to form one big solution.
#### Exercise 1.2 #### Exercise 1.2
Put together one or more `DEMO` procedures that make imaginative use of the ideas presented and reviewed in this chapter. Put together one or more `demo!` procedures that make imaginative use of the ideas presented and reviewed in this chapter.
Modify every procedure in the chapter. Modify every procedure in the chapter.
Make them act more strangely. Make them act more strangely.
@ -849,23 +849,23 @@ Can you do something similar?
{{Figure 12: Kasimir Malevich, _Eight Red Rectangles_. https://upload.wikimedia.org/wikipedia/commons/thumb/6/6d/Malevich-Suprematism..jpg/640px-Malevich-Suprematism..jpg. Bottom of p. 31.}} {{Figure 12: Kasimir Malevich, _Eight Red Rectangles_. https://upload.wikimedia.org/wikipedia/commons/thumb/6/6d/Malevich-Suprematism..jpg/640px-Malevich-Suprematism..jpg. Bottom of p. 31.}}
#### Exercise 1.3 #### Exercise 1.3
Combine the ideas of `SPINGON` with your newly constructed `CNGON`. Combine the ideas of `spingon!` with your newly constructed `cngon!`.
### Exercise 1.4 ### Exercise 1.4
Design a fancier `CNGON` that fills up a polygon with textures. Design a fancier `cngon!` that fills up a polygon with textures.
Here are a few visual tips for Exercises 1.3 and 1.4: Here are a few visual tips for Exercises 1.3 and 1.4:
{{Figure 13: `SPINCNGON`s. Bottom of p. 32.}} {{Figure 13: `spincngon`s. Bottom of p. 32.}}
#### Exercise 1.5 #### Exercise 1.5
Design a Logo procedure that puts polygons on the vertices of other polygons. Design a Logo procedure that puts polygons on the vertices of other polygons.
Hint: look carefully at the body of `CNGON`. Hint: look carefully at the body of `cngon!`.
When does the turtle arrive at a polygon vertex? When does the turtle arrive at a polygon vertex?
Mark the vertex arrival place in the `CNGON` procedure. Mark the vertex arrival place in the `cngon!` procedure.
You might consider this location as the right spot to install some recursion: when the turtle arrives at any vertex, ask it to do another `CNGON` centered on that vertex. You might consider this location as the right spot to install some recursion: when the turtle arrives at any vertex, ask it to do another `cngon!` centered on that vertex.
This recursive drawing will place polygons on the vertices of polygons on the vertices of polygons. This recursive drawing will place polygons on the vertices of polygons on the vertices of polygons.
You will need to figure out a way of stopping the recursion machinery, or it will continue forever. You will need to figure out a way of stopping the recursion machinery, or it will continue forever.
Define a new argument, `:LEVEL`, to keep track of recursion levels. Define a new argument, `level`, to keep track of recursion levels.
What about the relative sizes of the polygons? What about the relative sizes of the polygons?
Should they get bigger or smaller? Can you handle that? Should they get bigger or smaller? Can you handle that?
@ -895,6 +895,7 @@ research.
* This we do not need here: * This we do not need here:
- Appeals to a manual - Appeals to a manual
- The `-` character to continue a line - The `-` character to continue a line
- The discussion of x-y coordinates
* Things we do need that are absent (in no particular order): * Things we do need that are absent (in no particular order):
- `let` bindings - `let` bindings
- M-expression math - M-expression math