updates

doc/src/tut/basics.do.txt

@@ -58,16 +58,16 @@ sketches of the type in Figure ref{sketcher:fig:inclinedplane}.
 However, it is more appropriate to start with a significantly simpler
 example as depicted in Figure ref{sketcher:fig:vehicle0}.  This toy
 sketch consists of several elements: two circles, two rectangles, and
-a "ground" element.
+a ``ground'' element.
 
 # #else
 
 ===== Basic Construction of Sketches =====
 
 Before attacking real-life sketches as in Figure ref{sketcher:fig1}
-we focus on the significantly simpler drawing shown in
+we focus on the significantly simpler drawing shown
 in Figure ref{sketcher:fig:vehicle0}.  This toy sketch consists of
-several elements: two circles, two rectangles, and a "ground" element.
+several elements: two circles, two rectangles, and a ``ground'' element.
 
 # #endif
 
@@ -151,7 +151,7 @@ vehicle = Composition({'wheels': wheels, 'body': body})
 The ground is illustrated by an object of type `Wall`,
 mostly used to indicate walls in sketches of mechanical systems.
 A `Wall` takes the `x` and `y` coordinates of some curve,
-and a `thickness` parameter, and creates a "thick" curve filled
+and a `thickness` parameter, and creates a thick curve filled
 with a simple pattern. In this case the curve is just a flat
 line so the construction is made of two points on the
 ground line ($(w_1-L,0)$ and $(w_1+3L,0)$):
@@ -161,7 +161,7 @@ ground = Wall(x=[w_1 - L, w_1 + 3*L], y=[0, 0], thickness=-0.3*R)
 The negative thickness makes the pattern-filled rectangle appear below
 the defined line, otherwise it appears above.
 
-We may now collect all the objects in a "top" object that contains
+We may now collect all the objects in a ``top'' object that contains
 the whole figure:
 !bc pycod
 fig = Composition({'vehicle': vehicle, 'ground': ground})
@@ -531,7 +531,6 @@ figure can be rotated, translated, or scaled.  Subparts of the figure
 can also be copied and moved to other parts of the drawing
 area. However, the single most important feature is probably the
 ability to make animations governed by mathematical formulas or data
-coming from physics simulations of the problem, as very simplistically
-shown in the example above.
+coming from physics simulations of the problem, as shown in the example above.
 
 

doc/src/tut/implementation.do.txt

@@ -303,7 +303,7 @@ drawings of mechanical systems.
 ===== Adding Functionality via Recursion =====
 
 The really powerful feature of our class hierarchy is that we can add
-much functionality to the superclass `Shape` and to the "bottom" class
+much functionality to the superclass `Shape` and to the ``bottom'' class
 `Curve`, and then all other classes for various types of geometrical shapes
 immediately get the new functionality. To explain the idea we may
 look at the `draw` method, which all classes in the `Shape`
@@ -343,21 +343,21 @@ Since class `Composition` inherits the same `draw` method, this method will
 run through `self.shapes` and call `wheels.draw()` and `body.draw()`.
 Now, the `wheels` object is also a `Composition` with the same `draw`
 method, which will run through `self.shapes`, now containing
-the `wheel1` and and `wheel2` objects. The `wheel1` object is a `Circle`,
+the `wheel1` and `wheel2` objects. The `wheel1` object is a `Circle`,
 so calling `wheel1.draw()` calls the `draw` method in class `Circle`,
 but this is the same `draw` method as shown above. This method will
 therefore traverse the circle's `shapes` dictionary, which we have seen
 consists of one `Curve` element.
 
 The `Curve` object holds the coordinates to be plotted so here `draw`
-really needs to do something "physical", namely send the coordinates to
+really needs to do something ``physical'', namely send the coordinates to
 the plotting program. The `draw` method is outlined in the short listing
 of class `Curve` shown previously.
 
 We can go to any of the other shape objects that appear in the figure
 hierarchy and follow their `draw` calls in the similar way. Every time,
 a `draw` call will invoke a new `draw` call, until we eventually hit
-a `Curve` object in the "botton" of the figure hierarchy, and then that part
+a `Curve` object at the ``bottom'' of the figure hierarchy, and then that part
 of the figure is really plotted (or more precisely, the coordinates
 are sent to a plotting program).