fix program/input to program/code

Author: bnmnetp

pretext/Appendices/errorsAndDebug.ptx

@@ -155,15 +155,15 @@ token</c>, neither of which is very informative.</p>
                 condition.</p>
     <p>For example:</p>
     <program language="python">
-      <input>
+      <code>
 while x &gt; 0 and y &lt; 0:
     # do something to x
     # do something to y
 
     print("x: ", x)
     print("y: ", y)
     print("condition: ", (x &gt; 0 and y &lt; 0))
-</input>
+</code>
     </program>
     <p>Now when you run the program, you will see three lines of output for each time
                 through the loop. The last time through the loop, the condition should be
@@ -363,17 +363,17 @@ while x &gt; 0 and y &lt; 0:
                 expression into a series of assignments to temporary variables.</p>
     <p>For example:</p>
     <program language="python">
-      <input>
+      <code>
 self.hands[i].addCard (self.hands[self.findNeighbor(i)].popCard())
-</input>
+</code>
     </program>
     <p>This can be rewritten as:</p>
     <program language="python">
-      <input>
+      <code>
 neighbor = self.findNeighbor (i)
 pickedCard = self.hands[neighbor].popCard()
 self.hands[i].addCard (pickedCard)
-</input>
+</code>
     </program>
     <p>The explicit version is easier to read because the variable names provide
                 additional documentation, and it is easier to debug because you can check the
@@ -382,19 +382,19 @@ self.hands[i].addCard (pickedCard)
                 evaluation may not be what you expect. For example, if you are translating the
                 expression <c>x/2pi</c> into Python, you might write:</p>
     <program language="python">
-      <input>
+      <code>
 y = x / 2 * math.pi;
-</input>
+</code>
     </program>
     <p>That is not correct because multiplication and division have the same
                 precedence and are evaluated from left to right. So this expression computes
                 <c>(x/2)pi</c>.</p>
     <p>A good way to debug expressions is to add parentheses to make the order of
                 evaluation explicit:</p>
     <program language="python">
-      <input>
+      <code>
 y = x / (2 * math.pi);
-</input>
+</code>
     </program>
     <p>Whenever you are not sure of the order of evaluation, use parentheses.  Not
                 only will the program be correct (in the sense of doing what you intended), it
@@ -407,16 +407,16 @@ y = x / (2 * math.pi);
                 chance to print the <c>return</c> value before returning. Again, you can use a
                 temporary variable. For example, instead of:</p>
     <program language="python">
-      <input>
+      <code>
 return self.hands[i].removeMatches()
-</input>
+</code>
     </program>
     <p>you could write:</p>
     <program language="python">
-      <input>
+      <code>
 count = self.hands[i].removeMatches()
 return count
-</input>
+</code>
     </program>
     <p>Now you have the opportunity to display or inspect the value of <c>count</c> before
                 returning.</p>

pretext/Appendices/testmodule.ptx

@@ -5,7 +5,7 @@
             the <c>test</c> module. This test module is not included in the standard Python distribution. (There is
             a standard test module but it is different from this.) What follows is the source code for this <c>test</c> module.</p>
   <program language="python">
-    <input>
+    <code>
 def testEqual(actual,expected,places=5):
     '''
     Does the actual value equal the expected value?
@@ -21,7 +21,7 @@ def testEqual(actual,expected,places=5):
             return True
     print('\tTest Failed: expected {} but got {}'.format(expected,actual))
     return False
-</input>
+</code>
   </program>
   <p>To use this module when programming on your own computer, save the above code with the name <term>test.py</term> in the same folder as the python program you want to test.</p>
 </section>

pretext/ClassesBasics/AddingOtherMethodstoourClass.ptx

@@ -15,7 +15,7 @@
   <p>Let's add two simple methods to allow a point to give us information about its state.  The <c>getX</c> method, when invoked, will return the value of the x coordinate.  The implementation of this method is straight forward since we already know how
             to write functions that return values.  One thing to notice is that even though the <c>getX</c> method does not need any other parameter information to do its work, there is still one formal parameter, <c>self</c>.  As we stated earlier, all methods defined in a class that operate on objects of that class will have <c>self</c> as their first parameter.  Again, this serves as reference to the object itself which in turn gives access to the state data inside the object.</p>
   <program xml:id="chp13_classes4" interactive="activecode" language="python">
-    <input>
+    <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -34,14 +34,14 @@ class Point:
 p = Point(7, 6)
 print(p.getX())
 print(p.getY())
-        </input>
+        </code>
   </program>
   <p>Note that the <c>getX</c> method simply returns the value of <c>self.x</c> from the object itself.  In other words, the implementation of the method is to go to the state of the object itself and get the value of <c>x</c>.  Likewise, the <c>getY</c> method looks the same.</p>
   <p>Let's add another method, <c>distanceFromOrigin</c>, to see better how methods
             work.  This method will again not need any additional information to do its work.
             It will perform a more complex task.</p>
   <program xml:id="chp13_classes5" interactive="activecode" language="python">
-    <input>
+    <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -62,7 +62,7 @@ class Point:
 
 p = Point(7, 6)
 print(p.distanceFromOrigin())
-        </input>
+        </code>
   </program>
   <p>Notice that the caller of <c>distanceFromOrigin</c> does not explicitly
             supply an argument to match the <c>self</c> parameter.  This is true of all method calls. The definition will always

pretext/ClassesBasics/ConvertinganObjecttoaString.ptx

@@ -4,7 +4,7 @@
   <p>When we're working with classes and objects, it is often necessary to print an object (that is to print the state of an object).
             Consider the example below.</p>
   <program xml:id="chp13_classesstr1" interactive="activecode" language="python">
-    <input>
+    <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -25,7 +25,7 @@ class Point:
 
 p = Point(7, 6)
 print(p)
-        </input>
+        </code>
   </program>
   <p>The <c>print</c> function shown above produces a string representation of the Point <c>p</c>.  The default functionality provided by
             Python tells you that <c>p</c> is an object of type <c>Point</c>.  However, it does not tell you anything about the specific
@@ -36,7 +36,7 @@ print(p)
             have decided that the string representation will include the values of x and y as well as some identifying text.  It
             is required that the <c>__str__</c> method create and <em>return</em> a string.</p>
   <program xml:id="chp13_classesstr2" interactive="activecode" language="python">
-    <input>
+    <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -59,7 +59,7 @@ class Point:
 
 p = Point(7, 6)
 print(p)
-        </input>
+        </code>
   </program>
   <p>When we run the program above you can see that the <c>print</c> function now shows the string that we chose.</p>
   <p>Now, you ask, don't we already have an <c>str</c> type converter that can

pretext/ClassesBasics/Exercises.ptx

@@ -8,13 +8,13 @@
                         computes the distance between that point and self.</p>
     </statement>
     <program interactive="activecode" language="python" xml:id="classes_q1_editor">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
     <solution>
       <program xml:id="ch_cl_ex_1_answer" language="python">
-        <input>
+        <code>
 import math
 
 class Point:
@@ -42,7 +42,7 @@ class Point:
 p = Point(3, 3)
 q = Point(6, 7)
 print(p.distanceFromPoint(q))
-        </input>
+        </code>
       </program>
     </solution>
   </exercise>
@@ -53,9 +53,9 @@ print(p.distanceFromPoint(q))
                 <c>Point(3, 5).reflect_x()</c> is (3, -5)</p>
     </statement>
     <program xml:id="ch_cl_02_editor" interactive="activecode" language="python">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
   </exercise>
   <exercise label="classes_q3">
@@ -67,13 +67,13 @@ print(p.distanceFromPoint(q))
       <p>What cases will cause your method to fail? Return None when it happens.</p>
     </statement>
     <program interactive="activecode" language="python" xml:id="classes_q3_editor">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
     <solution>
       <program xml:id="ch_cl_ex_3_answer" language="python">
-        <input>
+        <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -100,7 +100,7 @@ class Point:
 
 p = Point(4, 10)
 print(p.slope_from_origin())
-        </input>
+        </code>
       </program>
     </solution>
   </exercise>
@@ -117,9 +117,9 @@ print(p.slope_from_origin())
                 When will your method fail?</p>
     </statement>
     <program xml:id="ch_cl_04_editor" interactive="activecode" language="python">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
   </exercise>
   <exercise label="classes_q5">
@@ -129,13 +129,13 @@ print(p.slope_from_origin())
                         state of the point)</p>
     </statement>
     <program interactive="activecode" language="python" xml:id="classes_q5_editor">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
     <solution>
       <program xml:id="ch_cl_05_answer" language="python">
-        <input>
+        <code>
 class Point:
     """ Point class for representing and manipulating x,y coordinates. """
 
@@ -165,7 +165,7 @@ p = Point(7, 6)
 print(p)
 p.move(5, 10)
 print(p)
-        </input>
+        </code>
       </program>
     </solution>
   </exercise>
@@ -174,9 +174,9 @@ print(p)
       <p>Given three points that fall on the circumference of a circle, find the center and radius of the circle.</p>
     </statement>
     <program xml:id="classes_q6_editor" interactive="activecode" language="python">
-      <input>
+      <code>
 
-        </input>
+        </code>
     </program>
   </exercise>
 </exercises>

pretext/ClassesBasics/ImprovingourConstructor.ptx

@@ -6,17 +6,17 @@
   <p>We can make our class constructor more general by putting extra parameters into
             the <c>__init__</c> method, as shown in this codelens example.</p>
   <program xml:id="chp13_improveconstructor" interactive="codelens" language="python">
-    <input>
+    <code>
           class Point:
               """ Point class for representing and manipulating x,y coordinates. """
-          
+
               def __init__(self, initX, initY):
                   """ Create a new point at the given coordinates. """
                   self.x = initX
                   self.y = initY
-          
+
           p = Point(7, 6)
-    </input>
+    </code>
   </program>
   <p>Now when we create new points, we supply the x and y coordinates as parameters.  When the point is created, the values of <c>initX</c> and <c>initY</c> are assigned to the state of the object.</p>
   <image source="ClassesBasics/Figures/objectpic5.png" width="50%" alt="Simple object has state and methods"/>

pretext/ClassesBasics/InstancesasReturnValues.ptx

@@ -9,7 +9,7 @@
             it <c>halfway</c> that takes another <c>Point</c> as a parameter and returns the <c>Point</c> that is halfway between the point and
             the target.</p>
   <program xml:id="chp13_classesmid1" interactive="activecode" language="python">
-    <input>
+    <code>
 class Point:
 
     def __init__(self, initX, initY):
@@ -41,7 +41,7 @@ mid = p.halfway(q)
 print(mid)
 print(mid.getX())
 print(mid.getY())
-        </input>
+        </code>
   </program>
   <p>The resulting Point, <c>mid</c>, has an x value of 4 and a y value of 8.  We can also use any other methods since <c>mid</c> is a
             <c>Point</c> object.</p>
@@ -51,10 +51,10 @@ print(mid.getY())
   <note>
     <p>This workspace is provided for your convenience.  You can use this activecode window to try out anything you like.</p>
     <program xml:id="scratch_cl_01" interactive="activecode" language="python">
-      <input>
+      <code>
 
 
-        </input>
+        </code>
     </program>
   </note>
 </section>

pretext/ClassesBasics/ObjectsasArgumentsandParameters.ptx

@@ -8,7 +8,7 @@
   <p>Here is a simple function called <c>distance</c> involving our new <c>Point</c> objects.  The job of this function is to figure out the
             distance between two points.</p>
   <program xml:id="chp13_classes6" interactive="activecode" language="python">
-    <input>
+    <code>
 import math
 
 class Point:
@@ -38,7 +38,7 @@ def distance(point1, point2):
 p = Point(4, 3)
 q = Point(0, 0)
 print(distance(p, q))
-        </input>
+        </code>
   </program>
   <p><c>distance</c> takes two points and returns the distance between them.  Note that <c>distance</c> is <term>not</term> a method of the Point class.  You can see this by looking at the indentation pattern.  It is not inside the class definition.  The other way we
             can know that <c>distance</c> is not a method of Point is that <c>self</c> is not included as a formal parameter.  In addition, we do not invoke <c>distance</c> using the dot notation.</p>