Small fix in circle()

AllenDowney · AllenDowney · commit 3ebb7ef78785 · 2016-09-06T13:52:03.000-04:00
diff --git a/book/book.tex b/book/book.tex
@@ -7,8 +7,7 @@
 
 %\documentclass[10pt,b5paper]{book}
 \documentclass[10pt]{book}
-\usepackage[width=5.5in,height=8.5in,
-  hmarginratio=3:2,vmarginratio=1:1]{geometry}
+\usepackage[width=5.5in,height=8.5in,hmarginratio=3:2,vmarginratio=1:1]{geometry}
 
 % for some of these packages, you might have to install
 % texlive-latex-extra (in Ubuntu)
@@ -33,7 +32,7 @@
 \title{Think Python}
 \author{Allen B. Downey}
 \newcommand{\thetitle}{Think Python: How to Think Like a Computer Scientist}
-\newcommand{\theversion}{2nd Edition, Version 2.2.16}
+\newcommand{\theversion}{2nd Edition, Version 2.2.19}
 \newcommand{\thedate}{}
 
 % these styles get translated in CSS for the HTML version
@@ -720,9 +719,10 @@ \section*{Contributor List}
 % ENDCONTRIB
 
 In addition, people who spotted typos or made corrections include
+Czeslaw Czapla,
 Richard Fursa, Brian McGhie, Lokesh Kumar Makani, Matthew Shultz, Viet
 Le, Victor Simeone, Lars O.D. Christensen, Swarup Sahoo, Alix Etienne,
-Kuang He, Wei Huang, and Karen Barber.
+Kuang He, Wei Huang, Karen Barber, and Eric Ransom.
 
 
 
@@ -3180,7 +3180,7 @@ \section{Interface design}
 
 {\tt n} is the number of line segments in our approximation of a circle,
 so {\tt length} is the length of each segment.  Thus, {\tt polygon}
-draws a 50-sides polygon that approximates a circle with radius {\tt r}.
+draws a 50-sided polygon that approximates a circle with radius {\tt r}.
 
 One limitation of this solution is that {\tt n} is a constant, which
 means that for very big circles, the line segments are too long, and
@@ -3207,7 +3207,7 @@ \section{Interface design}
 \begin{verbatim}
 def circle(t, r):
     circumference = 2 * math.pi * r
-    n = int(circumference / 3) + 1
+    n = int(circumference / 3) + 3
     length = circumference / n
     polygon(t, n, length)
 \end{verbatim}
@@ -3217,6 +3217,8 @@ \section{Interface design}
 enough that the circles look good, but big enough to be efficient,
 and acceptable for any size circle.
 
+Adding 3 to {\tt n} guarantees that the polygon has at least 3 sides.
+
 
 \section{Refactoring}
 \label{refactoring}
@@ -8116,11 +8118,13 @@ \section{List arguments}
 It is important to distinguish between operations that
 modify lists and operations that create new lists.  For
 example, the {\tt append} method modifies a list, but the
-{\tt +} operator creates a new list:
+{\tt +} operator creates a new list.
 \index{append method}
 \index{method!append}
 \index{list!concatenation}
 \index{concatenation!list}
+
+Here's an example using {\tt append}:
 %
 \begin{verbatim}
 >>> t1 = [1, 2]
@@ -8131,19 +8135,20 @@ \section{List arguments}
 None
 \end{verbatim}
 %
-{\tt append} modifies the list and returns {\tt None}.
+The return value from {\tt append} is {\tt None}.
+
+Here's an example using the {\tt +} operator:
 %
 \begin{verbatim}
 >>> t3 = t1 + [4]
 >>> t1
 [1, 2, 3]
 >>> t3
 [1, 2, 3, 4]
->>> t1
 \end{verbatim}
 %
-The {\tt +} operator creates a new list and leaves the
-original list unchanged.
+The result of the operator is a new list, and the original list is
+unchanged.
 
 This difference is important when you write functions that
 are supposed to modify lists.  For example, this function
@@ -16567,7 +16572,7 @@ \section{Order of growth}
 problems asymptotic behavior is irrelevant.
 
 But if you keep those caveats in mind, algorithmic analysis is a
-useful tool.  At least for large problems, the ``better'' algorithms
+useful tool.  At least for large problems, the ``better'' algorithm
 is usually better, and sometimes it is {\em much} better.  The
 difference between two algorithms with the same order of growth is
 usually a constant factor, but the difference between a good algorithm
diff --git a/code/polygon.py b/code/polygon.py
@@ -57,7 +57,7 @@ def arc(t, r, angle):
     angle: angle subtended by the arc, in degrees
     """
     arc_length = 2 * math.pi * r * abs(angle) / 360
-    n = int(arc_length / 4) + 1
+    n = int(arc_length / 4) + 3
     step_length = arc_length / n
     step_angle = float(angle) / n
 
