Normal quotes

17-04.md

@@ -2,43 +2,43 @@
   [Previous](17-03.html)   [Table of Contents](index.html)   [Next](17-05.html)
   ------------------------ --------------------------------- --------------------
 
-There’s a kicker here, though, and that’s the counting of neighbors for
+There's a kicker here, though, and that's the counting of neighbors for
 cells at the edge of the cellmap. When cellmap wrapping is enabled (so
 that the cellmap becomes essentially a toroid, with each edge joined
 seamlessly to the opposite edge, as opposed to having a border of
-off-cells), neighbors that reside on the other edge of the cellmap can’t
+off-cells), neighbors that reside on the other edge of the cellmap can't
 be accessed by the standard fixed offset, as shown in Figure 17.1. So,
 in general, we could improve performance by hard-wiring our
-neighbor-counting for the bit-per-cell cellmap format, but it seems we’d
+neighbor-counting for the bit-per-cell cellmap format, but it seems we'd
 need a lot of conditional code to handle wrapping, and that would slow
 things back down again.
 
 ![](images/17-01.jpg)\
  **Figure 17.1**  *Edge-wrapping complications.*
 
-When a problem doesn’t lend itself well to optimization, make it a
+When a problem doesn't lend itself well to optimization, make it a
 practice to see if you can change the problem definition to one that
-allows for greater efficiency. In this case, we’ll change the problem by
+allows for greater efficiency. In this case, we'll change the problem by
 putting padding bytes around the edge of the cellmap, and duplicating
 each edge of the cellmap in the padding bytes at the opposite side, as
 shown in Figure 17.2. That way, a hard-wired neighbor count will find
 exactly what it should—the opposite edge—without any special code at
 all.
 
-But doesn’t that extra copying of the edges take time? Sure, but only a
+But doesn't that extra copying of the edges take time? Sure, but only a
 little; we can build it into the cellmap copying function, and then
-frankly we won’t even notice it. Avoiding tens or hundreds of thousands
+frankly we won't even notice it. Avoiding tens or hundreds of thousands
 of calls to **cell\_state(),** on the other hand, will be *very*
 noticeable. Listing 17.3 shows the alterations to Listing 17.1 required
 to implement a hard-wired neighbor-counting function. This is a minor
 change, in truth, implemented in about half an hour and not making the
 code significantly larger—but Listing 17.3 is 3.6 times faster than
-Listing 17.1, as shown in Table 17.1. We’re up to about 10 generations
+Listing 17.1, as shown in Table 17.1. We're up to about 10 generations
 per second on a 486; not where we want to be, but it is a vast
 improvement.
 
 ![](images/17-02.jpg)\
- **Figure 17.2**  *The “padding cells” solution.*
+ **Figure 17.2**  *The "padding cells" solution.*
 
 **LISTING 17.3 L17-3.CPP**
 
@@ -79,7 +79,7 @@ improvement.
        memset(cells, 0, length_in_bytes);              // clear all cells, to start
     }
 
-    /* Copies one cellmap’s cells to another cellmap. If wrapping is
+    /* Copies one cellmap's cells to another cellmap. If wrapping is
        enabled, copies edge (wrap) bytes into opposite padding bytes in
        source first, so that the padding bytes off each edge have the
        same values as would be found by wrapping around to the opposite