Chapter 6 operator syntax and notebook updates.

Author: michelp

Chapter6/Scene1.py

@@ -134,6 +134,21 @@ def construct(self):
             self.play(Write(edge_count))
             self.wait(1)
 
+        with self.voiceover(
+            """The same operation can be written more concisely using Python's OR
+            operator. The expression A pipe B creates a lazy union, which is then
+            passed to binary plus to produce the result."""
+        ):
+            # Transform code to show operator syntax
+            code2 = Code(
+                code_string="binary.plus(A | B).new()",
+                language="python",
+                background="window",
+            ).scale(0.7)
+            code2.next_to(title, DOWN, buff=0.3)
+            self.play(Transform(code, code2))
+            self.wait(1)
+
         # Cleanup
         self.play(
             FadeOut(title), FadeOut(code),

Chapter6/Scene2.py

@@ -140,6 +140,21 @@ def construct(self):
             self.play(Write(comparison))
             self.wait(1)
 
+        with self.voiceover(
+            """Similarly, Python's AND operator provides a shorthand for intersection.
+            A ampersand B creates a lazy intersection, which binary times then
+            materializes into the result."""
+        ):
+            # Transform code to show operator syntax
+            code2 = Code(
+                code_string="binary.times(A & B).new()",
+                language="python",
+                background="window",
+            ).scale(0.7)
+            code2.next_to(title, DOWN, buff=0.3)
+            self.play(Transform(code, code2))
+            self.wait(1)
+
         # Cleanup
         self.play(
             FadeOut(title), FadeOut(code),

Chapter6/Scene3.py

@@ -121,6 +121,21 @@ def construct(self):
             self.play(FadeIn(result_mat), Write(result_label))
             self.wait(1)
 
+        with self.voiceover(
+            """Comparison operators like greater-than can create boolean masks
+            directly. The expression W greater than 3 produces a matrix of true
+            and false values indicating which elements pass the test."""
+        ):
+            # Transform code to show operator syntax
+            code2 = Code(
+                code_string="(W > 3).new()",
+                language="python",
+                background="window",
+            ).scale(0.7)
+            code2.next_to(mat, DOWN, buff=0.4)
+            self.play(Transform(code, code2))
+            self.wait(1)
+
         # Cleanup
         self.play(
             FadeOut(title), FadeOut(graph), FadeOut(label),

Chapter6/Scene5.py

@@ -105,6 +105,21 @@ def construct(self):
 
             self.wait(0.5)
 
+        with self.voiceover(
+            """This operation can also be written using Python's multiplication
+            operator. The expression 2 times M applies the scalar on the left,
+            producing the same result."""
+        ):
+            # Transform code to show operator syntax
+            code2 = Code(
+                code_string="2 * M",
+                language="python",
+                background="window",
+            ).scale(0.7)
+            code2.move_to(ORIGIN + UP * 0.5)
+            self.play(Transform(code, code2))
+            self.wait(0.5)
+
         # Cleanup
         self.play(
             FadeOut(title), FadeOut(mat_m), FadeOut(mat_label),

Chapter6/Scene6.py

@@ -115,6 +115,22 @@ def construct(self):
             self.play(Write(contrast), Write(contrast_note))
             self.wait(1)
 
+        with self.voiceover(
+            """Division also uses Python's natural syntax. M divided by 2 applies
+            the scalar on the right, matching the mathematical notation. All common
+            Python mathematical operators are supported, making very natural looking
+            code possible."""
+        ):
+            # Transform code to show operator syntax
+            code2 = Code(
+                code_string="M / 2",
+                language="python",
+                background="window",
+            ).scale(0.7)
+            code2.move_to(ORIGIN + UP * 0.5)
+            self.play(Transform(code, code2))
+            self.wait(0.5)
+
         # Cleanup
         self.play(
             FadeOut(title), FadeOut(mat_m), FadeOut(mat_label),