A community-maintained Python framework for creating mathematical animations.
Lemma1 and Lemma2 animations
Grant Sanderson16fe9209e876
diff --git a/active_projects/wallis_g.py b/active_projects/wallis_g.pyindex cf90cefaa..b825000f6 100644--- a/active_projects/wallis_g.py+++ b/active_projects/wallis_g.py@@ -4,23 +4,238 @@ from once_useful_constructs.light import Lighthousefrom once_useful_constructs.light import SwitchOn# from once_useful_constructs.light import LightSource+PRODUCT_COLOR = BLUE+CHEAP_AMBIENT_LIGHT_CONFIG = {+ "num_levels": 5,+ "radius": 1,+}-class IntroduceDistanceProduct(MovingCameraScene):++class DistanceProductScene(MovingCameraScene):CONFIG = {"ambient_light_config": {- "opacity_function": inverse_quadratic(1, 1.1, 1),+ "opacity_function": inverse_power_law(1, 1.5, 1, 4),"num_levels": 100,+ "light_radius": 5,+ "max_opacity": 0.8,+ "color": PRODUCT_COLOR,+ },+ "circle_color": BLUE,+ "circle_radius": 3,+ "num_lighthouses": 6,+ "lighthouse_height": 0.5,+ "ignored_lighthouse_indices": [],+ "observer_config": {+ "color": MAROON_B,+ "mode": "pondering",+ "height": 0.25,+ "flip_at_start": True,+ },+ "observer_fraction": 1.0 / 3,+ "d_label_height": 0.35,+ "numeric_distance_label_height": 0.25,+ "default_product_column_top": FRAME_WIDTH * RIGHT / 4 + 1.5 * UP,+ }++ def setup(self):+ super(DistanceProductScene, self).setup()+ self.circle = Circle(+ color=self.circle_color,+ radius=self.circle_radius,+ )++ def get_circle_point_at_proportion(self, alpha):+ radius = self.get_radius()+ center = self.circle.get_center()+ angle = alpha * TAU+ unit_circle_point = np.cos(angle) * RIGHT + np.sin(angle) * UP+ return radius * unit_circle_point + center++ def get_lh_points(self):+ return np.array([+ self.get_circle_point_at_proportion(fdiv(i, self.num_lighthouses))+ for i in range(self.num_lighthouses)+ if i not in self.ignored_lighthouse_indices+ ])++ def get_observer_point(self, fraction=None):+ if fraction is None:+ fraction = self.observer_fraction+ return self.get_circle_point_at_proportion(fraction / self.num_lighthouses)++ def get_observer(self):+ observer = self.observer = PiCreature(**self.observer_config)+ observer.next_to(self.get_observer_point(), RIGHT, buff=SMALL_BUFF)+ return observer++ def get_observer_dot(self):+ self.observer_dot = Dot(+ self.get_observer_point(),+ color=self.observer_config["color"]+ )+ return self.observer_dot++ def get_lighthouses(self):+ self.lighthouses = VGroup()+ for point in self.get_lh_points():+ lighthouse = Lighthouse()+ lighthouse.scale_to_fit_height(self.lighthouse_height)+ lighthouse.move_to(point)+ self.lighthouses.add(lighthouse)+ return self.lighthouses++ def get_lights(self):+ self.lights = VGroup()+ for point in self.get_lh_points():+ light = AmbientLight(+ source_point=VectorizedPoint(point),+ **self.ambient_light_config+ )+ self.lights.add(light)+ return self.lights++ def get_distance_lines(self):+ self.distance_lines = VGroup(*[+ Line(self.get_observer_point(), point)+ for point in self.get_lh_points()+ ])+ return self.distance_lines++ def get_symbolic_distance_labels(self):+ if not hasattr(self, "distance_lines"):+ self.get_distance_lines()+ self.d_labels = VGroup()+ for i, line in enumerate(self.distance_lines):+ d_label = TexMobject("d_%d" % i)+ d_label.scale_to_fit_height(self.d_label_height)+ vect = rotate_vector(line.get_vector(), 90 * DEGREES)+ vect *= 2.5 * SMALL_BUFF / np.linalg.norm(vect)+ d_label.move_to(line.get_center() + vect)+ self.d_labels.add(d_label)+ return self.d_labels++ def get_numeric_distance_labels(self, num_decimal_points=3, show_ellipsis=True):+ radius = self.circle.get_width() / 2+ if not hasattr(self, "distance_lines"):+ self.get_distance_lines()+ labels = self.numeric_distance_labels = VGroup()+ for line in self.distance_lines:+ label = DecimalNumber(+ line.get_length() / radius,+ num_decimal_points=num_decimal_points,+ show_ellipsis=show_ellipsis,+ )+ label.scale_to_fit_height(self.numeric_distance_label_height)+ max_width = 0.5 * line.get_length()+ if label.get_width() > max_width:+ label.scale_to_fit_width(max_width)+ angle = (line.get_angle() % TAU) - TAU / 2+ if np.abs(angle) > TAU / 4:+ angle += np.sign(angle) * np.pi+ label.angle = angle+ label.next_to(line.get_center(), UP, SMALL_BUFF)+ label.rotate(angle, about_point=line.get_center())+ labels.add(label)+ return labels++ def get_circle_group(self):+ group = VGroup(self.circle)+ if not hasattr(self, "observer_dot"):+ self.get_observer_dot()+ if not hasattr(self, "observer"):+ self.get_observer()+ if not hasattr(self, "lighthouses"):+ self.get_lighthouses()+ if not hasattr(self, "lights"):+ self.get_lights()+ group.add(+ self.observer_dot,+ self.observer,+ self.lighthouses,+ self.lights,+ )+ return group++ def setup_lighthouses_and_observer(self):+ self.add(*self.get_circle_group())++ # Numerical results++ def get_radius(self):+ return self.circle.get_width() / 2.0++ def get_distance_product(self, fraction=None):+ radius = self.get_radius()+ observer_point = self.get_observer_point(fraction)+ distances = [+ np.linalg.norm(point - observer_point) / radius+ for point in self.get_lh_points()+ ]+ return reduce(op.mul, distances, 1.0)++ # Animating methods++ def add_numeric_distance_labels(self, show_line_creation=True):+ anims = []+ if not hasattr(self, "distance_lines"):+ self.get_distance_lines()+ if not hasattr(self, "numeric_distance_labels"):+ self.get_numeric_distance_labels()+ if show_line_creation:+ anims.append(LaggedStart(ShowCreation, self.distance_lines))+ anims.append(LaggedStart(FadeIn, self.numeric_distance_labels))++ self.play(*anims)++ def show_distance_product_in_column(self, column_top=None):+ if not hasattr(self, "numeric_distance_labels"):+ self.get_numeric_distance_labels()+ if column_top is None:+ column_top = self.default_product_column_top+ labels = self.numeric_distance_labels+ stacked_labels = labels.copy()+ for label in stacked_labels:+ label.rotate(-label.angle)+ label.scale_to_fit_height(self.numeric_distance_label_height)+ stacked_labels.arrange_submobjects(DOWN)+ stacked_labels.move_to(column_top, UP)++ h_line = Line(LEFT, RIGHT)+ h_line.scale_to_fit_width(1.5 * stacked_labels.get_width())+ h_line.next_to(stacked_labels, DOWN, aligned_edge=RIGHT)+ times = TexMobject("\\times")+ times.next_to(h_line, UP, SMALL_BUFF, aligned_edge=LEFT)++ product_decimal = DecimalNumber(+ self.get_distance_product(),+ num_decimal_points=3,+ show_ellipsis=True+ )+ product_decimal.scale_to_fit_height(self.numeric_distance_label_height)+ product_decimal.next_to(h_line, DOWN)+ product_decimal.align_to(stacked_labels, RIGHT)+ product_decimal.set_color(BLUE)++ self.play(ReplacementTransform(labels.copy(), stacked_labels))+ self.play(+ ShowCreation(h_line),+ Write(times)+ )+ self.play(+ ReplacementTransform(+ stacked_labels.copy(),+ VGroup(product_decimal)+ )+ )+++class IntroduceDistanceProduct(DistanceProductScene):+ CONFIG = {+ "ambient_light_config": {# "num_levels": 10,- "light_radius": 10,# "radius": 1,- "max_opacity": 0.4,"color": YELLOW,},- "num_lighthouses": 6,- "circle_radius": 3,- "observer_color": MAROON_B,- "lighthouse_height": 0.5,- "camera_class": MovingCamera,}def construct(self):@@ -29,12 +244,10 @@ class IntroduceDistanceProduct(MovingCameraScene):self.show_sum_of_inverse_squares()def draw_circle_with_points(self):- circle = Circle(color=BLUE)- circle.scale(self.circle_radius)+ circle = self.circlelh_dots = self.lh_dots = VGroup(*[- Dot().move_to(circle.point_from_proportion(alpha))- for alpha in np.arange(0, 1, 1.0 / self.num_lighthouses)+ Dot(point) for point in self.get_lh_points()])lh_dot_arrows = VGroup(*[Arrow(*[@@ -47,8 +260,7 @@ class IntroduceDistanceProduct(MovingCameraScene):evenly_space_dots_label.scale_to_fit_width(0.5 * circle.get_width())evenly_space_dots_label.move_to(circle)- special_dot = self.special_dot = Dot(color=self.observer_color)- special_dot.move_to(circle.point_from_proportion(0.04))+ special_dot = self.special_dot = self.get_observer_dot()special_dot_arrow = Vector(DL)special_dot_arrow.next_to(special_dot, UR, SMALL_BUFF)special_dot_arrow.match_color(special_dot)@@ -77,24 +289,13 @@ class IntroduceDistanceProduct(MovingCameraScene):self.play(FadeOut(VGroup(special_dot_arrow, special_dot_label)))def turn_into_lighthouses_and_observer(self):- lighthouses = self.lighthouses = VGroup()- lights = self.lights = VGroup()- for dot in self.lh_dots:- point = dot.get_center()- lighthouse = Lighthouse()- lighthouse.scale_to_fit_height(self.lighthouse_height)- lighthouse.move_to(point)- lighthouses.add(lighthouse)+ lighthouses = self.get_lighthouses()+ lights = self.get_lights()- light = AmbientLight(- source_point=VectorizedPoint(point),- **self.ambient_light_config- )- lights.add(light)-- observer = self.observer = PiCreature(color=self.observer_color)- observer.flip()- observer.move_to(self.special_dot)+ observer = self.get_observer()+ observer.save_state()+ observer.scale_to_fit_height(2)+ observer.change_mode("happy")observer.to_edge(RIGHT)self.play(@@ -104,23 +305,12 @@ class IntroduceDistanceProduct(MovingCameraScene):)self.wait()self.play(FadeIn(observer))- self.play(- observer.scale_to_fit_height, 0.25,- observer.next_to, self.special_dot, RIGHT, 0.5 * SMALL_BUFF,- )+ self.play(observer.restore)self.wait()def show_sum_of_inverse_squares(self):- lines = VGroup(*[- Line(self.special_dot.get_center(), dot.get_center())- for dot in self.lh_dots- ])- labels = VGroup(*[TexMobject("d_%d" % i) for i in range(len(lines))])- for label, line in zip(labels, lines):- label.scale(0.75)- vect = rotate_vector(line.get_vector(), TAU / 4)- vect *= 2 * SMALL_BUFF / np.linalg.norm(vect)- label.move_to(line.get_center() + vect)+ lines = self.get_distance_lines()+ labels = self.get_symbolic_distance_labels()sum_of_inverse_squares = TexMobject(*it.chain(*[["{1", "\\over", "(", "d_%d" % i, ")", "^2}", "+"]@@ -182,7 +372,7 @@ class IntroduceDistanceProduct(MovingCameraScene):labels[:-1].copy(),d_terms[:-1],),- circle_group.scale, 0.8, {"about_edge": DOWN}+ circle_group.scale, 0.8, {"about_point": FRAME_Y_RADIUS * DOWN})self.wait()self.play(LaggedStart(@@ -195,9 +385,10 @@ class IntroduceDistanceProduct(MovingCameraScene):# Mention useful just to basel problemcircle_group.save_state()+ v_point = VectorizedPoint(FRAME_X_RADIUS * LEFT + FRAME_Y_RADIUS * DOWN)self.play(- circle_group.scale, 0.5,- circle_group.to_corner, DL,+ circle_group.next_to, v_point, UR, {"submobject_to_align": self.circle},+ circle_group.scale, 0.5, {"about_point": v_point.get_center()},)self.play(GrowFromCenter(brace),@@ -230,7 +421,9 @@ class IntroduceDistanceProduct(MovingCameraScene):wallis_product.next_to, basel_sum, UP, {"aligned_edge": RIGHT},)self.play(- d_terms.shift, d_terms.get_height() * UP / 2,+ d_terms.shift, 0.75 * d_terms.get_height() * UP,+ d_terms.set_color, PRODUCT_COLOR,+ light_rings.set_fill, PRODUCT_COLOR,*[FadeOut(mob)for mob in sum_of_inverse_squares@@ -240,7 +433,7 @@ class IntroduceDistanceProduct(MovingCameraScene):self.wait()self.play(FadeOut(plusses),- d_terms.arrange_submobjects, RIGHT, 0.5 * SMALL_BUFF,+ d_terms.arrange_submobjects, RIGHT, 0.25 * SMALL_BUFF,d_terms.move_to, sum_of_inverse_squares, DOWN,)self.wait()@@ -268,6 +461,182 @@ class IntroduceDistanceProduct(MovingCameraScene):self.wait()+class Lemma1(DistanceProductScene):+ CONFIG = {+ "circle_radius": 2.5,+ "observer_fraction": 0.5,+ # "ambient_light_config": {+ # "num_levels": 5,+ # "radius": 1,+ # },+ "lighthouse_height": 0.25,+ "lemma_text": "distance product = 2",+ }++ def construct(self):+ self.add_title()+ self.add_circle_group()+ self.state_lemma_premise()+ self.show_product()++ def add_title(self):+ title = self.title = TextMobject("Two lemmas:")+ title.set_color(YELLOW)+ title.to_edge(UP, buff=MED_SMALL_BUFF)+ self.add(title)++ def add_circle_group(self):+ self.circle.to_corner(DL)+ circle_group = self.get_circle_group()+ self.play(LaggedStart(FadeIn, VGroup(*circle_group.family_members_with_points())))++ def state_lemma_premise(self):+ premise = TextMobject("Lemma 1: If observer is halfway between lighthouses,")+ self.premise = premise+ premise.next_to(self.title, DOWN)++ frac = 1.0 / self.num_lighthouses+ arc1, arc2 = arcs = VGroup(VMobject(), VMobject())+ arc1.pointwise_become_partial(self.circle, 0, frac / 2)+ arc2.pointwise_become_partial(self.circle, frac / 2, frac)+ arc1.reverse_points()+ arcs.set_stroke(YELLOW, 5)+ show_arcs = ShowCreationThenDestruction(+ arcs,+ submobject_mode="all_at_once",+ run_time=2,+ )++ self.play(Write(premise), show_arcs, run_time=2)+ self.wait()+ self.play(show_arcs)+ self.wait()++ def show_product(self):+ lemma = TextMobject(self.lemma_text)+ lemma.set_color(BLUE)+ lemma.next_to(self.premise, DOWN)+ self.add_numeric_distance_labels()+ self.play(Write(lemma, run_time=1))+ self.show_distance_product_in_column()+ self.wait()+++class Lemma1With7Lighthouses(Lemma1):+ CONFIG = {+ "num_lighthouses": 7,+ }+++class Lemma1With8Lighthouses(Lemma1):+ CONFIG = {+ "num_lighthouses": 8,+ }+++class Lemma1With9Lighthouses(Lemma1):+ CONFIG = {+ "num_lighthouses": 9,+ }+++class Lemma2(Lemma1):+ CONFIG = {+ # "ambient_light_config": CHEAP_AMBIENT_LIGHT_CONFIG,+ "lemma_text": "distance product = \\# Initial lighthouses"+ }++ def construct(self):+ self.add_title()+ self.add_circle_group()+ self.state_lemma_premise()+ self.replace_first_lighthouse()+ self.show_product()++ def state_lemma_premise(self):+ premise = self.premise = TextMobject(+ "If the observer replaces a lighthouse,"+ )+ premise.next_to(self.title, DOWN)++ self.play(Write(premise, run_time=1))++ def replace_first_lighthouse(self):+ dot = self.observer_dot+ observer_anim = MaintainPositionRelativeTo(self.observer, dot)+ lighthouse_group = VGroup(self.lighthouses[0], self.lights[0])+ point = self.get_lh_points()[0]++ self.play(+ lighthouse_group.shift, 5 * RIGHT,+ lighthouse_group.fade, 1,+ run_time=1.5,+ rate_func=running_start,+ remover=True,+ )+ self.play(+ dot.move_to, point,+ observer_anim,+ path_arc=(-120 * DEGREES),+ )+ self.wait()++ self.ignored_lighthouse_indices = [0]+ self.observer_fraction = 0+ for group in self.lighthouses, self.lights:+ self.lighthouses.submobjects.pop(0)+++class Lemma2With7Lighthouses(Lemma2):+ CONFIG = {+ "num_lighthouses": 7,+ }+++class Lemma2With8Lighthouses(Lemma2):+ CONFIG = {+ "num_lighthouses": 8,+ }+++class Lemma2With9Lighthouses(Lemma2):+ CONFIG = {+ "num_lighthouses": 9,+ }+++class FromGeometryToAlgebra(DistanceProductScene):+ CONFIG = {+ "num_lighthouses": 7,+ "ambient_light_config": CHEAP_AMBIENT_LIGHT_CONFIG,+ }++ def construct(self):+ self.setup_lights()+ self.point_out_evenly_spaced()+ self.transition_to_complex_plane()+ self.name_roots_of_unity()++ def setup_lights(self):+ lights = self.get_lights()+ circle = self.circle++ self.add(circle, lights)++ def point_out_evenly_spaced(self):+ pass++ def transition_to_complex_plane(self):+ pass++ def name_roots_of_unity(self):+ pass++++++