Merge pull request #106 from gtbook/frank_feb9

Chapter 5 edits

Author: dellaert

S10_introduction.ipynb

@@ -80,7 +80,7 @@
    "id": "01db0ccf",
    "metadata": {},
    "source": [
-    "```{index} differential drive robot, DDR\n",
+    "```{index} differential-drive robot, DDR\n",
     "```\n",
     "\n",
     "The chapters of the book proceed through a sequence of increasingly complex robotic systems.\n",

S11_models.ipynb

@@ -119,7 +119,7 @@
     "```{index} configuration, configuration space\n",
     "```\n",
     "\n",
-    "The most basic information about a robot’s state is merely a description of the robot’s location (and orientation) in its environment, which we will define as the robot’s *configuration*. The set of all possible configurations will be called the *configuration space*. This information could be a qualitative, high-level description (e.g., the room in which the vacuum cleaning robot of Chapter 3 is located), coordinates for the robot’s position in a grid or continuous position coordinates in the plane (as for the logistics robot of Chapter 4), continuous coordinates for a position and orientation in the plane (as for the differential drive robot, or DDR, of Chapter 5 and the autonomous car of Chapter 6), or continuous coordinates for three-dimensional position and orientation (as for the drone in Chapter 7)."
+    "The most basic information about a robot’s state is merely a description of the robot’s location (and orientation) in its environment, which we will define as the robot’s *configuration*. The set of all possible configurations will be called the *configuration space*. This information could be a qualitative, high-level description (e.g., the room in which the vacuum cleaning robot of Chapter 3 is located), coordinates for the robot’s position in a grid or continuous position coordinates in the plane (as for the logistics robot of Chapter 4), continuous coordinates for a position and orientation in the plane (as for the differential-drive robot, or DDR, of Chapter 5 and the autonomous car of Chapter 6), or continuous coordinates for three-dimensional position and orientation (as for the drone in Chapter 7)."
    ]
   },
   {

S13_math.ipynb

@@ -179,7 +179,7 @@
     "```{index} Jacobian matrix\n",
     "```\n",
     "\n",
-    "Perhaps most surprisingly, the relationship between velocities can always be encoded as a linear mapping from one vector space to another. Consider a differential drive robot with two wheels that rotate independently. As these wheels rotate, the robot will move in the world, changing its position and orientation. The *instantaneous* relationship between the angular velocities of the two wheels and the linear and angular velocities of the robot is linear! The matrix that encodes this relationship is called a *Jacobian* matrix (which may include time-varying entries that are nonlinear functions of configuration variables). You may remember Jacobian matrices from an advanced calculus class. If so, you may recall that the Jacobian of a function relates the derivatives of the function’s input to the derivatives of its output.  Even for highly nonlinear functions, the instantaneous relationship between these derivatives is linear, and expressed by the Jacobian matrix. We will see Jacobian matrices for omnidirectional robots in Chapter 4, DDRs in Chapter 5, and for drone dynamics in Chapter 7."
+    "Perhaps most surprisingly, the relationship between velocities can always be encoded as a linear mapping from one vector space to another. Consider a differential-drive robot with two wheels that rotate independently. As these wheels rotate, the robot will move in the world, changing its position and orientation. The *instantaneous* relationship between the angular velocities of the two wheels and the linear and angular velocities of the robot is linear! The matrix that encodes this relationship is called a *Jacobian* matrix (which may include time-varying entries that are nonlinear functions of configuration variables). You may remember Jacobian matrices from an advanced calculus class. If so, you may recall that the Jacobian of a function relates the derivatives of the function’s input to the derivatives of its output.  Even for highly nonlinear functions, the instantaneous relationship between these derivatives is linear, and expressed by the Jacobian matrix. We will see Jacobian matrices for omnidirectional robots in Chapter 4, DDRs in Chapter 5, and for drone dynamics in Chapter 7."
    ]
   },
   {

S21_sorter_state.ipynb

@@ -914,7 +914,7 @@
    "id": "IKt2DaIm1Brr",
    "metadata": {},
    "source": [
-    "Above we created an instance of the `gtsam.DiscreteDistribution` class. As with any GTSAM class, you can type\n",
+    "Above we created an instance of the `DiscreteDistribution` class. As with any GTSAM class, you can type\n",
     "```python\n",
     "help(gtsam.DiscreteDistribution)\n",
     "```\n",

S23_sorter_sensing.ipynb

@@ -712,7 +712,7 @@
    "id": "tHvu2cyxbopL",
    "metadata": {},
    "source": [
-    "Above we created an instance of the `gtsam.DiscreteConditional` class. As with any GTSAM class, you can type\n",
+    "Above we created an instance of the `DiscreteConditional` class. As with any GTSAM class, you can type\n",
     "\n",
     "```python\n",
     "help(gtsam.DiscreteConditional)\n",

S24_sorter_perception.ipynb

@@ -1536,7 +1536,7 @@
    "source": [
     "### Factors\n",
     "\n",
-    "Above we created an instance of the `gtsam.DecisionTreeFactor` class. As with any GTSAM class, you can type\n",
+    "Above we created an instance of the `DecisionTreeFactor` class. As with any GTSAM class, you can type\n",
     "\n",
     "```python\n",
     "help(gtsam.DecisionTreeFactor)\n",
@@ -1575,7 +1575,7 @@
    "id": "3mAh1FdQ0xrA",
    "metadata": {},
    "source": [
-    "The factors we created above are of type `gtsam.DecisionTreeFactor`, which are stored as decision trees:"
+    "The factors we created above are of type `DecisionTreeFactor`, which are stored as decision trees:"
    ]
   },
   {
@@ -1677,7 +1677,7 @@
     }
    ],
    "source": [
-    "#| caption: Decision tree in a `gtsam.DecisionTreeFactor`.\n",
+    "#| caption: Decision tree in a `DecisionTreeFactor`.\n",
     "#| label: fig:decision_tree_factor\n",
     "show(conductivity_false_factor)"
    ]

S26_sorter_learning.ipynb

@@ -573,7 +573,7 @@
     }
    },
    "source": [
-    "A `gtsam.DiscreteConditional` determines the counts, grouped by the conditioning variable. In our case, `Category` can take on 5 separate values, and hence we have five groups. For example, for a binary sensor:\n"
+    "A `DiscreteConditional` determines the counts, grouped by the conditioning variable. In our case, `Category` can take on 5 separate values, and hence we have five groups. For example, for a binary sensor:\n"
    ]
   },
   {

S31_vacuum_state.ipynb

@@ -369,7 +369,7 @@
    "id": "2OOSTBL1a4sV",
    "metadata": {},
    "source": [
-    "When we print the results, we see that we now get a dictionary of `DiscreteKeys`, i.e., integer tuples of the form *(`Key`, cardinality)*. However, the \"keys\" now seem to be very large integers. This is because for series of variables we use the `gtsam.Symbol` type, composed of a single character and an integer index:"
+    "When we print the results, we see that we now get a dictionary of `DiscreteKeys`, i.e., integer tuples of the form *(`Key`, cardinality)*. However, the \"keys\" now seem to be very large integers. This is because for series of variables we use the `Symbol` type, composed of a single character and an integer index:"
    ]
   },
   {

S32_vacuum_actions.ipynb

@@ -1419,17 +1419,17 @@
     "\n",
     "> The GTSAM concepts used in this section, explained.\n",
     "\n",
-    "As in Chapter 2, we once again used a `gtsam.DiscreteConditional`, this time to specify a motion model for the controlled Markov chain above, as shown in Figure [4](#vacuum-motion-model)."
+    "As in Chapter 2, we once again used a `DiscreteConditional`, this time to specify a motion model for the controlled Markov chain above, as shown in Figure [4](#vacuum-motion-model)."
    ]
   },
   {
    "cell_type": "markdown",
    "id": "1GGXFMgV1VUb",
    "metadata": {},
    "source": [
-    "To specify the motion model, we used the `gtsam.DiscreteBayesNet` class, and in particular these methods:\n",
+    "To specify the motion model, we used the `DiscreteBayesNet` class, and in particular these methods:\n",
     "\n",
-    "- `add(self:, key: Tuple[int, int], parents: List[Tuple[int, int]], spec: str) -> None`: adds a conditional with the same arguments as the `gtsam.DiscreteConditional` constructor.\n",
+    "- `add(self:, key: Tuple[int, int], parents: List[Tuple[int, int]], spec: str) -> None`: adds a conditional with the same arguments as the `DiscreteConditional` constructor.\n",
     "- `at(self, i: int) -> gtsam.DiscreteConditional`: retrieves the $i^{th}$ conditional added."
    ]
   },
@@ -1522,7 +1522,7 @@
    "id": "22gJu5XkegOn",
    "metadata": {},
    "source": [
-    "Finally, a word about the graphs above. You might wonder, why these graphs come out so beautifully positioned, e.g., to indicate time from left to right. This was accomplished with the `hints` argument, which positions variables series at an appropriate height. Similarly, the `boxes` argument (which takes `gtsam.Keys`, not tuples) indicates which variables should considered as given.\n",
+    "Finally, a word about the graphs above. You might wonder, why these graphs come out so beautifully positioned, e.g., to indicate time from left to right. This was accomplished with the `hints` argument, which positions variables series at an appropriate height. Similarly, the `boxes` argument (which takes `Keys`, not tuples) indicates which variables should considered as given.\n",
     "\n",
     "These arguments are handled in the `gtbook` library {cite:p}`gtbook`, and are passed on in the appropriate format to the underlying GTSAM `dot` methods, which generate graphviz-style graphs{cite:p}`graphviz`."
    ]

S33_vacuum_sensing.ipynb

@@ -647,7 +647,7 @@
    "id": "HlzAWlJNSilC",
    "metadata": {},
    "source": [
-    "We use the `gtsam.DiscreteBayesNet` method `sample`, with signature\n",
+    "We use the `DiscreteBayesNet` method `sample`, with signature\n",
     "\n",
     "```python\n",
     "    sample(self, given: gtsam::DiscreteValues) -> gtsam::DiscreteValues\n",
@@ -660,7 +660,7 @@
    "metadata": {},
    "source": [
     "It implements ancestral sampling, but does assume that the Bayes net is reverse topologically sorted, i.e. last\n",
-    "conditional will be sampled first. In addition, it can optionally take an assignment for certain *given* variables, as a `gtsam.DiscreteValues` instance.\n",
+    "conditional will be sampled first. In addition, it can optionally take an assignment for certain *given* variables, as a `DiscreteValues` instance.\n",
     "In that case, it is also assumed that the Bayes net does not contain any conditionals for the given values.\n",
     "We used this functionality to pass the given action sequence above."
    ]