A community-maintained Python framework for creating mathematical animations.
AnalyzeFunctionWithTransformations
Grant Sandersoncc209ae6efe1
diff --git a/active_projects/alt_calc.py b/active_projects/alt_calc.pyindex 8f28113cd..a7e4f1e3b 100644--- a/active_projects/alt_calc.py+++ b/active_projects/alt_calc.py@@ -214,7 +214,8 @@ class NumberlineTransformationScene(ZoomedScene):sample_dots=None,local_sample_dots=None,target_coordinate_values=None,- added_anims=None+ added_anims=None,+ **kwargs):zcbr_group = self.zoomed_camera_background_rectangle_groupzcbr_anim = self.zoomed_camera_background_rectangle_anim@@ -260,21 +261,35 @@ class NumberlineTransformationScene(ZoomedScene):anims += added_animsanims.append(Animation(zcbr_group))- self.play(*anims)+ self.play(*anims, **kwargs)# Zoomingdef zoom_in_on_input(self, x,local_sample_dots=None,local_coordinate_values=None,pop_out=True,- first_added_anims=[],- second_added_anims=[],+ first_added_anims=None,+ first_anim_kwargs=None,+ second_added_anims=None,+ second_anim_kwargs=None,+ zoom_factor=None,):++ first_added_anims = first_added_anims or []+ first_anim_kwargs = first_anim_kwargs or {}+ second_added_anims = second_added_anims or []+ second_anim_kwargs = second_anim_kwargs or {}input_point = self.get_input_point(x)# Decide how to move camera frame into placeframe = self.zoomed_camera.frame- movement = ApplyMethod(frame.move_to, input_point)+ frame.generate_target()+ frame.target.move_to(input_point)+ if zoom_factor:+ frame.target.scale_to_fit_height(+ self.zoomed_display.get_height() * zoom_factor+ )+ movement = MoveToTarget(frame)zcbr = self.zoomed_camera_background_rectanglezcbr_group = self.zoomed_camera_background_rectangle_groupzcbr_anim = self.zoomed_camera_background_rectangle_anim@@ -323,14 +338,15 @@ class NumberlineTransformationScene(ZoomedScene):anims.append(Animation(zcbr_group))if not pop_out:self.activate_zooming(animate=False)- self.play(*anims)+ self.play(*anims, **first_anim_kwargs)if not self.zoom_activated and pop_out:self.activate_zooming(animate=False)added_anims = second_added_anims or []self.play(self.get_zoomed_display_pop_out_animation(),- *added_anims+ *added_anims,+ **second_anim_kwargs)def get_local_coordinates(self, line, *x_values, **kwargs):@@ -2264,50 +2280,731 @@ class GraphOnePlusOneOverX(GraphScene):"x_max": 6,"x_axis_width": 12,"y_min": -4,- "y_max": 4,+ "y_max": 5,"y_axis_height": 8,"y_axis_label": None,- "graph_origin": ORIGIN,+ "graph_origin": 0.5 * DOWN,"num_graph_anchor_points": 100,+ "func_graph_color": GREEN,+ "identity_graph_color": BLUE,}def construct(self):+ self.add_title()self.setup_axes()self.draw_graphs()+ self.show_solutions()++ def add_title(self):+ title = self.title = TexMobject(+ "\\text{Solve: }", "1 + \\frac{1}{x}", "=", "x",+ )+ title.set_color_by_tex("x", self.identity_graph_color, substring=False)+ title.set_color_by_tex("frac", self.func_graph_color)+ title.to_corner(UL)+ self.add(title)def setup_axes(self):GraphScene.setup_axes(self)- self.x_axis.add_numbers(*range(-6, 0) + range(1, 7))+ step = 2+ self.x_axis.add_numbers(*range(-6, 0, step) + range(step, 7, step))self.y_axis.label_direction = RIGHT- self.y_axis.add_numbers(*range(-3, 0) + range(1, 4))+ self.y_axis.add_numbers(*range(-2, 0, step) + range(step, 4, step))- def draw_graphs(self):+ def draw_graphs(self, animate=True):lower_func_graph, upper_func_graph = func_graph = VGroup(*[self.get_graph(lambda x: 1.0 + 1.0 / x,x_min=x_min,x_max=x_max,- color=BLUE,+ color=self.func_graph_color,)for x_min, x_max in (-10, -0.1), (0.1, 10)])- func_graph_label = self.get_graph_label(+ func_graph.label = self.get_graph_label(upper_func_graph, "y = 1 + \\frac{1}{x}",- x_val=6, direction=UP+ x_val=6, direction=UP,)identity_graph = self.get_graph(- lambda x: x, color=GREEN+ lambda x: x, color=self.identity_graph_color)- identity_graph_label = self.get_graph_label(+ identity_graph.label = self.get_graph_label(identity_graph, "y = x",x_val=3, direction=UL, buff=SMALL_BUFF)- # for label in func_graph_label, identity_graph_label:- # label[:2].set_color(WHITE)- self.play(ShowCreation(func_graph))- self.play(Write(func_graph_label))- self.play(ShowCreation(identity_graph))- self.play(Write(identity_graph_label))+ if animate:+ for graph in func_graph, identity_graph:+ self.play(+ ShowCreation(graph),+ Write(graph.label),+ run_time=2+ )+ self.wait()+ else:+ self.add(+ func_graph, func_graph.label,+ identity_graph, identity_graph.label,+ )++ self.func_graph = func_graph+ self.identity_graph = identity_graph++ def show_solutions(self):+ phi = 0.5 * (1 + np.sqrt(5))+ phi_bro = 0.5 * (1 - np.sqrt(5))++ lines = VGroup()+ for num in phi, phi_bro:+ line = DashedLine(+ self.coords_to_point(num, 0),+ self.coords_to_point(num, num),+ color=WHITE+ )+ line_copy = line.copy()+ line.fade(0.5)+ line_anim = ShowCreationThenDestruction(+ line_copy,+ submobject_mode="lagged_start",+ run_time=2+ )+ line.continual_anim = CycleAnimation(line_anim)+ lines.add(line)++ phi_line, phi_bro_line = lines++ decimal_kwargs = {+ "num_decimal_places": 3,+ "show_ellipsis": True,+ "color": YELLOW,+ }+ arrow_kwargs = {+ "buff": SMALL_BUFF,+ "color": WHITE,+ "tip_length": 0.15,+ "rectangular_stem_width": 0.025,+ }++ phi_decimal = DecimalNumber(phi, **decimal_kwargs)+ phi_decimal.next_to(phi_line, DOWN, LARGE_BUFF)+ phi_arrow = Arrow(+ phi_decimal[:4].get_top(), phi_line.get_bottom(),+ **arrow_kwargs+ )++ phi_bro_decimal = DecimalNumber(phi_bro, **decimal_kwargs)+ phi_bro_decimal.next_to(phi_bro_line, UP, LARGE_BUFF)+ phi_bro_decimal.shift(0.5 * LEFT)+ phi_bro_arrow = Arrow(+ phi_bro_decimal[:6].get_bottom(), phi_bro_line.get_top(),+ **arrow_kwargs+ )++ brother_words = TextMobject(+ "$\\varphi$'s little brother",+ tex_to_color_map={"$\\varphi$": YELLOW},+ arg_separator=""+ )+ brother_words.next_to(+ phi_bro_decimal[-2], UP, buff=MED_SMALL_BUFF,+ aligned_edge=RIGHT+ )++ self.add(phi_line.continual_anim)+ self.play(ShowCreation(phi_line))+ self.play(+ Write(phi_decimal),+ GrowArrow(phi_arrow),+ )+ self.wait(4)+ self.add(phi_bro_line.continual_anim)+ self.play(ShowCreation(phi_bro_line))+ self.play(+ Write(phi_bro_decimal),+ GrowArrow(phi_bro_arrow),+ )+ self.wait(4)+ self.play(Write(brother_words))+ self.wait(8)+++class NumericalPlayFromOne(ExternallyAnimatedScene):+ pass+++class NumericalPlayFromTau(ExternallyAnimatedScene):+ pass+++class NumericalPlayFromNegPhi(ExternallyAnimatedScene):+ pass+++class NumericalPlayOnNumberLineFromOne(Scene):+ CONFIG = {+ "starting_value": 1,+ "n_jumps": 10,+ "func": lambda x: 1 + 1.0 / x,+ "number_line_config": {+ "x_min": 0,+ "x_max": 2,+ "unit_size": 6,+ "tick_frequency": 0.25,+ "numbers_with_elongated_ticks": [0, 1, 2]+ }+ }++ def construct(self):+ self.add_number_line()+ self.add_phi_label()+ self.add_title()+ self.bounce_around()++ def add_number_line(self):+ number_line = NumberLine(**self.number_line_config)+ number_line.move_to(2 * DOWN)+ number_line.add_numbers()++ self.add(number_line)+ self.number_line = number_line++ def add_phi_label(self):+ number_line = self.number_line+ phi_point = number_line.number_to_point(+ (1 + np.sqrt(5)) / 2+ )+ phi_dot = Dot(phi_point, color=YELLOW)+ arrow = Vector(DL)+ arrow.next_to(phi_point, UR, SMALL_BUFF)+ phi_label = TexMobject("\\varphi = 1.618\\dots")+ phi_label.set_color(YELLOW)+ phi_label.next_to(arrow.get_start(), UP, SMALL_BUFF)++ self.add(phi_dot, phi_label, arrow)++ def add_title(self):+ title = TexMobject("x \\rightarrow 1 + \\frac{1}{x}")+ title.to_corner(UL)+ self.add(title)++ def bounce_around(self):+ number_line = self.number_line+ value = self.starting_value+ point = number_line.number_to_point(value)+ dot = Dot(point)+ dot.set_fill(RED, opacity=0.8)+ arrow = Vector(DR)+ arrow.next_to(point, UL, buff=SMALL_BUFF)+ arrow.match_color(dot)+ start_here = TextMobject("Start here")+ start_here.next_to(arrow.get_start(), UP, SMALL_BUFF)+ start_here.match_color(dot)++ self.play(+ FadeIn(start_here),+ GrowArrow(arrow),+ GrowFromPoint(dot, arrow.get_start())+ )+ self.play(+ FadeOut(start_here),+ FadeOut(arrow)+ )+ self.wait()+ for x in range(self.n_jumps):+ new_value = self.func(value)+ new_point = number_line.number_to_point(new_value)+ if new_value - value > 0:+ path_arc = -120 * DEGREES+ else:+ path_arc = -120 * DEGREES+ arc = Line(+ point, new_point,+ path_arc=path_arc,+ buff=SMALL_BUFF+ )+ self.play(+ ShowCreationThenDestruction(arc, run_time=1.5),+ ApplyMethod(+ dot.move_to, new_point,+ path_arc=path_arc+ ),+ )+ self.wait(0.5)++ value = new_value+ point = new_point+++class NumericalPlayOnNumberLineFromTau(NumericalPlayOnNumberLineFromOne):+ CONFIG = {+ "starting_value": TAU,+ "number_line_config": {+ "x_min": 0,+ "x_max": 7,+ "unit_size": 2,+ }+ }+++class NumericalPlayOnNumberLineFromMinusPhi(NumericalPlayOnNumberLineFromOne):+ CONFIG = {+ "starting_value": -0.61803,+ "number_line_config": {+ "x_min": -3,+ "x_max": 3,+ "unit_size": 2,+ "tick_frequency": 0.25,+ },+ "n_jumps": 25,+ }++ def add_phi_label(self):+ NumericalPlayOnNumberLineFromOne.add_phi_label(self)+ number_line = self.number_line+ new_point = number_line.number_to_point(+ (1 - np.sqrt(5)) / 2+ )+ arrow = Vector(DR)+ arrow.next_to(new_point, UL, SMALL_BUFF)+ arrow.set_color(RED)+ new_label = TexMobject("-\\frac{1}{\\varphi} = -0.618\\dots")+ new_label.set_color(RED)+ new_label.next_to(arrow.get_start(), UP, SMALL_BUFF)+ new_label.shift(RIGHT)+ self.add(new_label, arrow)+++class RepeatedApplicationGraphically(GraphOnePlusOneOverX, PiCreatureScene):+ CONFIG = {+ "starting_value": 1,+ "n_jumps": 5,+ "n_times_to_show_identity_property": 2,+ }++ def setup(self):+ GraphOnePlusOneOverX.setup(self)+ PiCreatureScene.setup(self)++ def construct(self):+ self.setup_axes()+ self.draw_graphs(animate=False)+ self.draw_spider_web()++ def create_pi_creature(self):+ randy = Randolph(height=2)+ randy.flip()+ randy.to_corner(DR)+ return randy++ def get_new_randy_mode(self):+ randy = self.pi_creature+ if not hasattr(self, "n_mode_changes"):+ self.n_mode_changes = 0+ else:+ self.n_mode_changes += 1+ if self.n_mode_changes % 3 != 0:+ return randy.get_mode()+ return random.choice([+ "confused",+ "erm",+ "maybe"+ ])++ def draw_spider_web(self):+ randy = self.pi_creature+ func = self.func_graph[0].underlying_function+ x_val = self.starting_value+ curr_output = 0+ dot = Dot(color=RED, fill_opacity=0.7)+ dot.move_to(self.coords_to_point(x_val, curr_output))++ self.play(FadeInAndShiftFromDirection(dot, 2 * UR))self.wait()++ for n in range(self.n_jumps):+ new_output = func(x_val)+ func_graph_point = self.coords_to_point(x_val, new_output)+ id_graph_point = self.coords_to_point(new_output, new_output)+ v_line = DashedLine(dot.get_center(), func_graph_point)+ h_line = DashedLine(func_graph_point, id_graph_point)++ curr_output = new_output+ x_val = new_output++ for line in v_line, h_line:+ line_end = line.get_end()+ self.play(+ ShowCreation(line),+ dot.move_to, line_end,+ randy.change, self.get_new_randy_mode()+ )+ self.wait()++ if n < self.n_times_to_show_identity_property:+ x_point = self.coords_to_point(new_output, 0)+ y_point = self.coords_to_point(0, new_output)+ lines = VGroup(*[+ Line(dot.get_center(), point)+ for point in x_point, y_point+ ])+ lines.set_color(YELLOW)+ self.play(ShowCreationThenDestruction(+ lines, run_time=2+ ))+ self.wait(0.25)+++class RepeatedApplicationGraphicallyFromNegPhi(RepeatedApplicationGraphically):+ CONFIG = {+ "starting_value": -0.61,+ "n_jumps": 13,+ "n_times_to_show_identity_property": 0,+ }+++class LetsSwitchToTheTransformationalView(TeacherStudentsScene):+ def construct(self):+ self.teacher_says(+ "Lose the \\\\ graphs!",+ target_mode="hooray"+ )+ self.change_student_modes("hooray", "erm", "surprised")+ self.wait(5)+++class AnalyzeFunctionWithTransformations(NumberlineTransformationScene):+ CONFIG = {+ "input_line_zero_point": 0.5 * UP,+ "output_line_zero_point": 2 * DOWN,+ "func": lambda x: 1 + 1.0 / x,+ "num_initial_applications": 10,+ "num_repeated_local_applications": 7,+ "zoomed_display_width": 3.5,+ "zoomed_display_height": 2,+ "default_mapping_animation_config": {},+ }++ def construct(self):+ self.add_function_title()+ self.repeatedly_apply_function()+ self.show_phi_and_phi_bro()+ self.zoom_in_on_phi()+ self.zoom_in_on_phi_bro()++ def setup_number_lines(self):+ NumberlineTransformationScene.setup_number_lines(self)+ for line in self.input_line, self.output_line:+ VGroup(line.main_line, line.tick_marks).set_stroke(width=2)++ def add_function_title(self):+ title = TexMobject("f(x)", "=", "1 + \\frac{1}{x}")+ title.to_edge(UP)+ self.add(title)+ self.title = title++ def repeatedly_apply_function(self):+ input_zero_point = self.input_line.number_to_point(0)+ output_zero_point = self.output_line.number_to_point(0)+ sample_dots = self.get_sample_dots(+ delta_x=0.05,+ dot_radius=0.05,+ x_min=-10,+ x_max=10,+ )+ sample_dots.set_stroke(BLACK, 0.5)+ point_func = self.number_func_to_point_func(self.func)+ arrows = VGroup(*[+ Arrow(+ c, point_func(c), buff=SMALL_BUFF,+ rectangular_stem_width=0.02,+ tip_length=0.15+ )+ for c in map(Mobject.get_center, sample_dots)+ if np.linalg.norm(c - input_zero_point) > 0.3+ ])+ arrows.set_fill(WHITE, 0.75)+ arrows.set_stroke(BLACK, 0.5)++ self.play(LaggedStart(+ FadeInAndShiftFromDirection, sample_dots,+ lambda m: (m, UP)+ ))+ self.play(LaggedStart(GrowArrow, arrows))+ self.wait()+ for x in range(self.num_initial_applications):+ self.apply_function(+ self.func,+ apply_function_to_number_line=False,+ sample_dots=sample_dots+ )+ self.wait()++ shift_vect = input_zero_point - output_zero_point+ shift_vect[0] = 0+ lower_output_line = self.output_line.copy()+ upper_output_line = self.output_line.copy()+ lower_arrows = arrows.copy()+ upper_arrows = arrows.copy()+ lower_group = VGroup(lower_output_line, lower_arrows)+ lower_group.shift(-shift_vect)+ lower_group.fade(1)++ self.remove(self.output_line, *arrows)+ self.play(+ ReplacementTransform(lower_arrows, arrows),+ ReplacementTransform(lower_output_line, self.output_line),+ upper_arrows.shift, shift_vect,+ upper_arrows.fade, 1,+ upper_output_line.shift, shift_vect,+ upper_output_line.fade, 1,+ sample_dots.shift, shift_vect,+ )+ self.remove(upper_output_line, upper_arrows)+ self.wait()+ self.play(FadeOut(sample_dots))++ self.all_arrows = arrows++ def show_phi_and_phi_bro(self):+ phi = (1 + np.sqrt(5)) / 2+ phi_bro = (1 - np.sqrt(5)) / 2++ input_phi_point = self.input_line.number_to_point(phi)+ output_phi_point = self.output_line.number_to_point(phi)+ input_phi_bro_point = self.input_line.number_to_point(phi_bro)+ output_phi_bro_point = self.output_line.number_to_point(phi_bro)++ tick = Line(UP, DOWN)+ tick.set_stroke(YELLOW, 3)+ tick.match_height(self.input_line.tick_marks)+ phi_tick = tick.copy().move_to(input_phi_point, DOWN)+ phi_bro_tick = tick.copy().move_to(input_phi_bro_point, DOWN)+ VGroup(phi_tick, phi_bro_tick).shift(SMALL_BUFF * DOWN)++ phi_label = TexMobject("1.618\\dots")+ phi_label.next_to(phi_tick, UP)+ phi_bro_label = TexMobject("-0.618\\dots")+ phi_bro_label.next_to(phi_bro_tick, UP)+ VGroup(phi_label, phi_bro_label).set_color(YELLOW)++ arrow_kwargs = {+ "buff": SMALL_BUFF,+ "rectangular_stem_width": 0.035,+ "tip_length": 0.2,+ }+ phi_arrow = Arrow(phi_tick, output_phi_point, **arrow_kwargs)+ phi_bro_arrow = Arrow(phi_bro_tick, output_phi_bro_point, **arrow_kwargs)++ self.play(+ LaggedStart(+ ApplyMethod, self.all_arrows,+ lambda m: (m.set_fill, {"opacity": 0.1})+ ),+ FadeIn(phi_arrow),+ FadeIn(phi_bro_arrow),+ )+ self.play(+ Write(phi_label),+ GrowFromCenter(phi_tick)+ )+ self.play(+ Write(phi_bro_label),+ GrowFromCenter(phi_bro_tick)+ )++ self.set_variables_as_attrs(+ input_phi_point, output_phi_point,+ input_phi_bro_point, output_phi_bro_point,+ phi_label, phi_tick,+ phi_bro_label, phi_bro_tick,+ phi_arrow, phi_bro_arrow+ )++ def zoom_in_on_phi(self):+ phi = (1 + np.sqrt(5)) / 2+ # phi_point = self.get_input_point(phi)+ local_sample_dots = self.get_local_sample_dots(+ phi, dot_radius=0.005, sample_radius=1+ )+ local_coordinate_values = [1.55, 1.6, 1.65, 1.7]++ # zcbr = self.zoomed_camera_background_rectangle+ zcbr_group = self.zoomed_camera_background_rectangle_group+ zcbr_group.add(self.phi_tick)++ title = self.title+ deriv_text = TexMobject(+ "|", "\\frac{df}{dx}(\\varphi)", "|", "< 1",+ tex_to_color_map={"\\varphi": YELLOW}+ )+ deriv_text.get_parts_by_tex("|").match_height(+ deriv_text, stretch=True+ )+ deriv_text.move_to(title, UP)+ approx_value = TexMobject("\\approx |%.2f|" % (-1 / phi**2))+ approx_value.move_to(deriv_text)+ deriv_text_lhs = deriv_text[:-1]+ deriv_text_rhs = deriv_text[-1]++ self.zoom_in_on_input(+ phi,+ local_sample_dots=local_sample_dots,+ local_coordinate_values=local_coordinate_values+ )+ self.wait()+ self.apply_function(+ self.func,+ apply_function_to_number_line=False,+ local_sample_dots=local_sample_dots,+ target_coordinate_values=local_coordinate_values,+ )+ self.wait()+ self.play(+ FadeInFromDown(deriv_text_lhs),+ FadeInFromDown(deriv_text_rhs),+ title.to_corner, UL+ )+ self.wait()+ self.play(+ deriv_text_lhs.next_to, approx_value, LEFT,+ deriv_text_rhs.next_to, approx_value, RIGHT,+ FadeIn(approx_value)+ )+ self.wait()+ for n in range(self.num_repeated_local_applications):+ self.apply_function(+ self.func,+ apply_function_to_number_line=False,+ local_sample_dots=local_sample_dots,+ path_arc=60 * DEGREES,+ run_time=2+ )++ self.deriv_text = VGroup(+ deriv_text_lhs, deriv_text_rhs, approx_value+ )++ def zoom_in_on_phi_bro(self):+ zcbr = self.zoomed_camera_background_rectangle+ # zcbr_group = self.zoomed_camera_background_rectangle_group+ zoomed_frame = self.zoomed_camera.frame++ phi_bro = (1 - np.sqrt(5)) / 2+ # phi_bro_point = self.get_input_point(phi_bro)+ local_sample_dots = self.get_local_sample_dots(phi_bro)+ local_coordinate_values = [-0.65, -0.6, -0.55]++ deriv_text = TexMobject(+ "\\left| \\frac{df}{dx}\\left(\\frac{-1}{\\varphi}\\right) \\right|",+ "\\approx |%.2f|" % (-1 / (phi_bro**2)),+ "> 1"+ )+ deriv_text.move_to(self.deriv_text, UL)+ deriv_text[0][10:14].set_color(YELLOW)++ self.play(+ zoomed_frame.scale_to_fit_height, 4,+ zoomed_frame.center,+ self.deriv_text.fade, 1,+ run_time=2+ )+ self.wait()+ zcbr.set_fill(opacity=0)+ self.zoom_in_on_input(+ phi_bro,+ local_sample_dots=local_sample_dots,+ local_coordinate_values=local_coordinate_values,+ zoom_factor=self.zoom_factor,+ first_anim_kwargs={"run_time": 2},+ )+ self.wait()+ self.play(FadeInFromDown(deriv_text))+ self.wait()+ zcbr.set_fill(opacity=1)+ self.apply_function(+ self.func,+ apply_function_to_number_line=False,+ local_sample_dots=local_sample_dots,+ target_coordinate_values=local_coordinate_values,+ )+ self.wait()+ for n in range(self.num_repeated_local_applications):+ self.apply_function(+ self.func,+ apply_function_to_number_line=False,+ local_sample_dots=local_sample_dots,+ path_arc=20 * DEGREES,+ run_time=2,+ )+++class StabilityAndInstability(AnalyzeFunctionWithTransformations):+ CONFIG = {+ "num_initial_applications": 0,+ }+ def construct(self):+ self.force_skipping()+ self.add_function_title()+ self.repeatedly_apply_function()+ self.show_phi_and_phi_bro()+ self.revert_to_original_skipping_status()++ self.label_stability()++ def label_stability(self):+ self.title.to_corner(UL)++ stable_label = TextMobject("Stable fixed point")+ unstable_label = TextMobject("Unstable fixed point")+ labels = VGroup(stable_label, unstable_label)+ labels.scale(0.8)+ stable_label.next_to(self.phi_label, UP, aligned_edge=ORIGIN)+ unstable_label.next_to(self.phi_bro_label, UP, aligned_edge=ORIGIN)++ phi_point = self.input_phi_point+ phi_bro_point = self.input_phi_bro_point++ arrow_groups = VGroup()+ for point in phi_point, phi_bro_point:+ arrows = VGroup(*filter(+ lambda a: np.linalg.norm(a.get_start() - point) < 0.75,+ self.all_arrows+ )).copy()+ arrows.set_fill(PINK, 1)+ arrows.second_anim = LaggedStart(+ ApplyMethod, arrows,+ lambda m: (m.set_fill, YELLOW, 1),+ rate_func=there_and_back_with_pause,+ lag_ratio=0.7,+ run_time=2,+ )+ arrows.anim = AnimationGroup(*map(GrowArrow, arrows))+ arrow_groups.add(arrows)+ phi_arrows, phi_bro_arrows = arrow_groups++ self.add_foreground_mobjects(self.phi_arrow, self.phi_bro_arrow)+ self.play(+ Write(stable_label),+ phi_arrows.anim,+ )+ self.play(phi_arrows.second_anim)+ self.play(+ Write(unstable_label),+ phi_bro_arrows.anim,+ )+ self.play(phi_bro_arrows.second_anim)+ self.wait()+++class NotBetterThanGraphs(TeacherStudentsScene):+ def construct(self):+ self.student_says(+ "Um, yeah, I'll stick \\\\ with graphs thanks",+ target_mode="sassy",+ )+ self.play(+ self.teacher.change, "guilty",+ self.get_student_changes("sad", "sassy", "hesitant")+ )+ self.wait(2)