A community-maintained Python framework for creating mathematical animations.
Tiny nudges for of div and curl
Grant Sanderson71400a39413c
diff --git a/active_projects/div_curl.py b/active_projects/div_curl.pyindex 40f0edac2..dde5b79ff 100644--- a/active_projects/div_curl.py+++ b/active_projects/div_curl.py@@ -4,7 +4,7 @@ DEFAULT_SCALAR_FIELD_COLORS = [BLUE_E, GREEN, YELLOW, RED]# Quick note to anyone coming to this file with the# intent of recreating animations from the video. Some-# of these, espeically those involving StreamLineAnimation,+# of these, especially those involving StreamLineAnimation,# can take an extremely long time to run, but much of the# computational cost is just for giving subtle little effects# which don't matter too much. Switching the line_anim_class@@ -14,6 +14,8 @@ DEFAULT_SCALAR_FIELD_COLORS = [BLUE_E, GREEN, YELLOW, RED]# run at production quality.FOX_COLOR = "#DF7F20"+RABBIT_COLOR = "#C6D6EF"+# Helper functionsdef get_flow_start_points(x_min=-8, x_max=8,@@ -301,6 +303,7 @@ class VectorField(VGroup):"stroke_color": BLACK,"stroke_width": 0.5,"fill_opacity": 1.0,+ "vector_config": {},}def __init__(self, func, **kwargs):@@ -317,19 +320,22 @@ class VectorField(VGroup):point = x * RIGHT + y * UPself.add(self.get_vector(point))- def get_vector(self, point):+ def get_vector(self, point, **kwargs):output = np.array(self.func(point))norm = np.linalg.norm(output)if norm == 0:output *= 0else:output *= self.length_func(norm) / norm- vect = Vector(output)+ vector_config = dict(self.vector_config)+ vector_config.update(kwargs)+ vect = Vector(output, **vector_config)vect.shift(point)fill_color = rgb_to_color(self.rgb_gradient_function(np.array([norm]))[0])- vect.set_fill(fill_color, self.fill_opacity)+ vect.set_color(fill_color)+ vect.set_fill(opacity=self.fill_opacity)vect.set_stroke(self.stroke_color,self.stroke_width@@ -456,6 +462,22 @@ class JigglingSubmobjects(ContinualAnimation):# Scenes+class Introduction(MovingCameraScene):+ def construct(self):+ self.show_divergence()+ self.show_curl()+ self.show_context()++ def show_divergence(self):+ pass++ def show_curl(self):+ pass++ def show_context(self):+ pass++class TestVectorField(Scene):CONFIG = {"func": cylinder_flow_vector_field,@@ -476,7 +498,7 @@ class TestVectorField(Scene):self.wait(10)-class Introduction(Scene):+class CylinderModel(Scene):CONFIG = {"production_quality_flow": True,"vector_field_func": cylinder_flow_vector_field,@@ -735,7 +757,7 @@ class Introduction(Scene):)-class ElectricField(Introduction, MovingCameraScene):+class ElectricField(CylinderModel, MovingCameraScene):def construct(self):self.add_plane()self.add_title()@@ -1232,7 +1254,7 @@ class TotallyToScale(Scene):# TODO: Revisit this-class FluidFlowAsHillGradient(Introduction, ThreeDScene):+class FluidFlowAsHillGradient(CylinderModel, ThreeDScene):CONFIG = {"production_quality_flow": False,}@@ -1756,13 +1778,6 @@ class DivergenceAsNewFunction(Scene):class DivergenceZeroCondition(Scene):def construct(self):- self.add_vector_field()- self.add_title()- self.begin_flow()- self.add_circle()- self.wait(5)-- def add_title(self):title = TextMobject("For actual (incompressible) fluid flow:")@@ -1775,6 +1790,15 @@ class DivergenceZeroCondition(Scene):for mob in title, equation:mob.add_background_rectangle(buff=MED_SMALL_BUFF / 2)self.add_foreground_mobjects(mob)+ self.wait(1)+++class PureCylinderFlow(Scene):+ def construct(self):+ self.add_vector_field()+ self.begin_flow()+ self.add_circle()+ self.wait(5)def add_vector_field(self):vector_field = VectorField(@@ -1800,18 +1824,35 @@ class DivergenceZeroCondition(Scene):if np.linalg.norm(stream_line.points[0]) < 1:stream_lines.remove(stream_line)+ self.modify_flow(stream_lines)+stream_line_animation = StreamLineAnimation(stream_lines)stream_line_animation.update(3)self.add(stream_line_animation)def add_circle(self):- self.add_foreground_mobjects(Circle(+ circle = Circle(radius=1,stroke_color=YELLOW,fill_color=BLACK,fill_opacity=1,- ))+ num_anchors=24,+ )+ self.modify_flow(circle)+ self.add_foreground_mobjects()++ def modify_flow(self, mobject):+ pass+++class PureAirfoilFlow(PureCylinderFlow):+ def modify_flow(self, mobject):+ vect = 0.1 * UP + 0.2 * LEFT+ mobject.scale(np.linalg.norm(vect - RIGHT))+ mobject.shift(vect)+ mobject.apply_complex_function(joukowsky_map)+ return mobjectclass IntroduceCurl(IntroduceVectorField):@@ -2502,7 +2543,7 @@ class ShowTwoPopulations(Scene):examples.arrange_submobjects(LEFT, buff=2)preditor, prey = words = VGroup(- TextMobject("Preditor"),+ TextMobject("Predator"),TextMobject("Prey"))for mob, word in zip(examples, words):@@ -2524,11 +2565,9 @@ class ShowTwoPopulations(Scene):group[1:],run_time=4,lag_ratio=0.1,+ rate_func=lambda t: np.clip(smooth(2 * t), 0, 1))- for group in [- foxes[:self.start_num_foxes],- rabbits[:self.start_num_rabbits],- ]+ for group in [foxes, rabbits]])@@ -2536,8 +2575,8 @@ class ShowTwoPopulations(Scene):foxes = self.foxesrabbits = self.rabbitsphase_point = VectorizedPoint(- self.start_num_foxes * RIGHT +- self.start_num_rabbits * UP+ self.start_num_rabbits * RIGHT ++ self.start_num_foxes * UP)self.add(VectorFieldFlow(phase_point,@@ -2629,7 +2668,8 @@ class ShowTwoPopulations(Scene):return self.get_animal("fox", FOX_COLOR)def get_rabbit(self):- return self.get_animal("rabbit", WHITE)+ # return self.get_animal("rabbit", WHITE)+ return self.get_animal("bunny", RABBIT_COLOR)def get_pop_labels(self):labels = VGroup(@@ -2773,18 +2813,18 @@ class PhaseSpaceOfPopulationModel(ShowTwoPopulations, PiCreatureScene, MovingCamself.pop_sizes_updates = pop_sizes_updatesdef write_differential_equations(self):- variables = ["XX", "YY"]+ variables = ["X", "YY"]equations = TexMobject("""- {dXX \\over dt} =- 30 \\cdot XX - XX \\cdot YY \\\\+ {dX \\over dt} =+ X \\cdot (\\alpha - \\beta YY \\,) \\\\\\quad \\\\{dYY \\over dt} =- XX \\cdot YY - 30 \\cdot YY+ YY \\cdot (\\delta X - \\gamma)""",substrings_to_isolate=variables)- animals = [self.get_fox().flip(), self.get_rabbit()]+ animals = [self.get_rabbit(), self.get_fox().flip()]for char, animal in zip(variables, animals):for part in equations.get_parts_by_tex(char):animal_copy = animal.copy()@@ -3191,7 +3231,7 @@ class ShowDotProduct(MovingCameraScene):def get_product(self, v1, v2):return np.dot(v1.get_vector(), v2.get_vector())- def add_additional_continual_animations(self):+ def add_additional_continual_animations(self, v1, v2):pass@@ -3224,6 +3264,479 @@ class ShowCrossProduct(ShowDotProduct):))-class NewSceneName(Scene):+class DivergenceTinyNudgesView(MovingCameraScene):+ CONFIG = {+ "scale_factor": 0.25+ }+def construct(self):- pass+ self.add_vector_field()+ self.zoom_in()+ self.take_tiny_step()+ self.show_dot_product()+ self.show_circle_of_values()+ self.switch_to_curl_words()+ self.rotate_difference_vectors()++ def add_vector_field(self):+ plane = self.plane = NumberPlane()++ vector_field = self.vector_field = VectorField(+ lambda p: 0.4 * np.array([+ np.cos(3 * p[0] * p[1] / 4),+ np.sin(TAU * p[1] / 4),+ 0+ ]),+ length_func=lambda n: max(n, 0.5),+ max_magnitude=1.0,+ )+ self.add(plane)+ self.add(vector_field)++ def zoom_in(self):+ point = self.point = 2 * LEFT + UP+ vector_field = self.vector_field+ sf = self.scale_factor++ self.play(+ self.camera_frame.scale, sf,+ self.camera_frame.move_to, point,+ FadeOut(vector_field),+ run_time=2+ )+ vector_field.vector_config.update({+ "rectangular_stem_width": 0.02,+ "tip_length": 0.1+ })+ vector = vector_field.get_vector(point)++ input_dot = Dot(point).scale(sf)+ input_words = TextMobject("$(x_0, y_0)$").scale(sf)+ input_words.next_to(input_dot, DL, SMALL_BUFF * sf)+ output_words = TextMobject("Output").scale(sf)+ output_words.add_background_rectangle()+ output_words.next_to(vector.get_top(), UP, sf * SMALL_BUFF)+ output_words.match_color(vector)++ self.add_foreground_mobjects(input_dot)+ self.play(+ FadeInAndShiftFromDirection(input_dot, SMALL_BUFF * DL),+ Write(input_words),+ )+ self.play(+ GrowArrow(vector),+ Write(output_words),+ )+ self.wait()++ self.set_variables_as_attrs(+ point, vector, input_dot,+ input_words, output_words,+ )++ def take_tiny_step(self):+ sf = self.scale_factor+ vector_field = self.vector_field+ point = self.point+ vector = self.vector+ output_words = self.output_words+ input_dot = self.input_dot++ nudge = 0.5 * RIGHT+ nudged_point = point + nudge++ new_vector = vector_field.get_vector(nudged_point)+ new_vector.set_color(YELLOW)+ new_dot = Dot(nudged_point).scale(sf)+ step_vector = Arrow(+ point, nudged_point,+ buff=0,+ color=TEAL,+ **vector_field.vector_config+ )+ step_vector.set_stroke(BLACK, 0.5)++ new_output_words = TextMobject("New output").scale(sf)+ new_output_words.add_background_rectangle()+ new_output_words.next_to(new_vector.get_end(), UP, sf * SMALL_BUFF)+ new_output_words.match_color(new_vector)+ step_words = TextMobject("Step").scale(sf)+ step_words.next_to(step_vector, UP, buff=0)+ step_words.set_color(step_vector.get_fill_color())+ step_words.add_background_rectangle()+ small_step_words = TextMobject("(think tiny step)").scale(sf)+ small_step_words.next_to(+ step_words, RIGHT,+ buff=sf * MED_SMALL_BUFF,+ )+ small_step_words.add_background_rectangle()+ small_step_words.match_style(step_words)++ shifted_vector = vector.copy().shift(nudge)+ diff_vector = Arrow(+ shifted_vector.get_end(),+ new_vector.get_end(),+ buff=0,+ color=RED,+ **vector_field.vector_config+ )+ diff_words = TextMobject("Difference").scale(sf)+ diff_words.add_background_rectangle()+ diff_words.next_to(diff_vector.get_start(), UR, buff=2 * sf * SMALL_BUFF)+ diff_words.match_color(diff_vector)+ diff_words.rotate(+ diff_vector.get_angle(),+ about_point=diff_vector.get_start()+ )++ self.play(+ GrowArrow(step_vector),+ Write(step_words),+ ReplacementTransform(input_dot.copy(), new_dot)+ )+ self.add_foreground_mobjects(new_dot)+ self.play(FadeIn(small_step_words))+ self.play(FadeOut(small_step_words))+ self.play(+ ReplacementTransform(vector.copy(), new_vector),+ ReplacementTransform(output_words.copy(), new_output_words),+ )+ self.wait()+ self.play(ReplacementTransform(+ vector.copy(), shifted_vector,+ path_arc=-TAU / 4+ ))+ self.wait()+ self.play(+ FadeOut(output_words),+ FadeOut(new_output_words),+ GrowArrow(diff_vector),+ Write(diff_words)+ )+ self.wait()+ self.play(+ vector.scale, 0, {"about_point": vector.get_start()},+ shifted_vector.scale, 0, {"about_point": shifted_vector.get_start()},+ ReplacementTransform(+ new_vector,+ diff_vector.copy().shift(-vector.get_vector()),+ remover=True+ ),+ diff_vector.shift, -vector.get_vector(),+ MaintainPositionRelativeTo(diff_words, diff_vector),+ run_time=2+ )+ self.wait()++ self.set_variables_as_attrs(+ step_vector, step_words,+ diff_vector, diff_words,+ )++ def show_dot_product(self):+ sf = self.scale_factor+ point = self.point+ step_vector = self.step_vector+ step_words = self.step_words+ diff_vector = self.diff_vector+ diff_words = self.diff_words+ vects = VGroup(step_vector, diff_vector)++ moving_step_vector = step_vector.copy()+ moving_diff_vector = diff_vector.copy()++ def update_moving_diff_vector(dv):+ step = moving_step_vector.get_vector()+ o1 = self.vector_field.get_vector(point).get_vector()+ o2 = self.vector_field.get_vector(point + step).get_vector()+ diff = o2 - o1+ dv.put_start_and_end_on(+ moving_step_vector.get_end(),+ moving_step_vector.get_end() + diff,+ )+ self.moving_diff_vector_update = ContinualUpdateFromFunc(+ moving_diff_vector,+ update_moving_diff_vector+ )+ self.add(self.moving_diff_vector_update)++ div_text = self.get_operator_text("div")++ step_words_copy = step_words.copy()+ diff_words_copy = diff_words.copy()+ copies = VGroup(step_words_copy, diff_words_copy)++ substrings = ["Step", "Difference"]+ dot_product = TextMobject(+ "(Step) $\\cdot$ (Difference)",+ substrings_to_isolate=substrings,+ arg_separator="",+ ).scale(sf)+ group = VGroup(div_text, dot_product)+ group.arrange_submobjects(RIGHT, buff=sf * MED_SMALL_BUFF)+ group.next_to(+ self.camera_frame.get_top(), DOWN,+ buff=sf * MED_SMALL_BUFF+ )++ for substring, mob, vect in zip(substrings, copies, vects):+ part = dot_product.get_part_by_tex(substring)+ mob.generate_target()+ mob.target.rotate(-vect.get_angle())+ mob.target.replace(part)+ # part.set_fill(opacity=0)+ part.match_color(mob)+ dot_product.add_background_rectangle()++ brace = Brace(+ dot_product.copy().scale(1 / sf, about_point=ORIGIN), DOWN,+ buff=SMALL_BUFF+ ).scale(sf, about_point=ORIGIN)+ dp_kwargs = {+ "include_sign": True,+ }+ dot_product_value = DecimalNumber(1.0, **dp_kwargs)+ dot_product_value.scale(sf)+ dot_product_value.next_to(brace, DOWN, sf * SMALL_BUFF)+ dot_product_value_update = ContinualChangingDecimal(+ dot_product_value,+ lambda a: np.dot(+ moving_step_vector.get_vector(),+ moving_diff_vector.get_vector(),+ ),+ **dp_kwargs+ )++ self.play(+ Write(dot_product),+ LaggedStart(MoveToTarget, copies)+ )+ self.remove(copies)+ self.play(FadeIn(div_text))+ self.play(ShowPassingFlashAround(+ div_text[1:3],+ surrounding_rectangle_config={"buff": sf * SMALL_BUFF}+ ))+ self.add(BackgroundRectangle(dot_product_value))+ self.play(+ GrowFromCenter(brace),+ Write(dot_product_value),+ )+ self.add(dot_product_value_update)+ self.wait()++ self.set_variables_as_attrs(+ div_text, dot_product,+ moving_step_vector,+ moving_diff_vector,+ dot_product_value,+ dot_product_value_update,+ brace,+ )++ def show_circle_of_values(self):+ point = self.point+ moving_step_vector = self.moving_step_vector+ moving_diff_vector = self.moving_diff_vector++ all_diff_vectors = VGroup()+ all_step_vectors = VGroup()+ # Loop around+ n_samples = 12+ angle = TAU / n_samples+ self.add_foreground_mobjects(self.step_words)+ for n in range(n_samples):+ self.play(+ Rotating(+ moving_step_vector,+ radians=angle,+ about_point=point,+ run_time=15.0 / n_samples,+ rate_func=None,+ )+ )+ step_vector_copy = moving_step_vector.copy()+ diff_vector_copy = moving_diff_vector.copy()+ diff_vector_copy.set_stroke(BLACK, 0.5)+ self.add(step_vector_copy, diff_vector_copy)+ all_step_vectors.add(step_vector_copy)+ all_diff_vectors.add(diff_vector_copy)+ self.remove(+ self.step_vector, self.diff_vector,+ self.moving_step_vector, self.moving_diff_vector,+ self.moving_diff_vector_update,+ self.dot_product_value_update+ )+ self.remove_foreground_mobjects(self.step_words)+ self.play(+ FadeOut(self.brace),+ FadeOut(self.dot_product_value),+ FadeOut(self.step_words),+ FadeOut(self.diff_words),+ )+ self.wait()++ for s in 0.6, -0.6:+ for step, diff in zip(all_step_vectors, all_diff_vectors):+ diff.generate_target()+ diff.target.put_start_and_end_on(+ step.get_end(),+ step.get_end() + s * step.get_vector()+ )+ self.play(+ all_step_vectors.set_fill, {"opacity": 0.5},+ LaggedStart(+ MoveToTarget, all_diff_vectors,+ run_time=3+ ),+ )+ self.wait()+ self.show_stream_lines(lambda p: s * (p - point))+ self.wait()++ self.set_variables_as_attrs(+ all_step_vectors, all_diff_vectors,+ )++ def switch_to_curl_words(self):+ sf = self.scale_factor+ div_text = self.div_text+ dot_product = self.dot_product++ curl_text = self.get_operator_text("curl")+ cross_product = TextMobject(+ "(Step) $\\times$ (Difference)",+ tex_to_color_map={+ "Step": TEAL,+ "Difference": RED+ },+ arg_separator="",+ ).scale(sf)+ cross_product.add_background_rectangle(opacity=1)++ group = VGroup(curl_text, cross_product)+ group.arrange_submobjects(RIGHT, buff=sf * MED_SMALL_BUFF)+ group.next_to(self.camera_frame.get_top(), sf * DOWN)++ self.play(+ dot_product.shift, sf * DOWN,+ dot_product.fade, 1,+ remover=True+ )+ self.play(FadeInAndShiftFromDirection(cross_product, sf * DOWN))+ self.play(+ div_text.shift, sf * DOWN,+ div_text.fade, 1,+ remover=True+ )+ self.play(FadeInAndShiftFromDirection(curl_text, sf * DOWN))+ self.wait()++ def rotate_difference_vectors(self):+ point = self.point+ all_step_vectors = self.all_step_vectors+ all_diff_vectors = self.all_diff_vectors++ for s in 0.6, -0.6:+ for step, diff in zip(all_step_vectors, all_diff_vectors):+ diff.generate_target()+ diff.target.put_start_and_end_on(+ step.get_end(),+ step.get_end() + s * rotate_vector(+ step.get_vector(),+ 90 * DEGREES+ )+ )+ self.play(+ LaggedStart(+ MoveToTarget, all_diff_vectors,+ run_time=2+ ),+ )+ self.wait()+ self.show_stream_lines(+ lambda p: s * rotate_vector((p - point), 90 * DEGREES)+ )+ self.wait()++ self.set_variables_as_attrs(+ all_step_vectors, all_diff_vectors,+ )++ # Helpers++ def get_operator_text(self, operator):+ text = TextMobject(+ operator + "\\,",+ "$\\textbf{F}(x_0, y_0)\\,$",+ "corresponds to average of",+ arg_separator=""+ ).scale(self.scale_factor)+ text.set_color_by_tex(operator, YELLOW)+ text.add_background_rectangle()+ return text++ def show_stream_lines(self, func):+ point = self.point+ stream_lines = StreamLines(+ func,+ start_points_generator_config={+ "x_min": point[0] - 2,+ "x_max": point[0] + 2,+ "y_min": point[1] - 1,+ "y_max": point[1] + 1,+ "delta_x": 0.025,+ "delta_y": 0.025,+ },+ virtual_time=1,+ )+ random.shuffle(stream_lines.submobjects)+ self.play(LaggedStart(+ ShowPassingFlash,+ stream_lines,+ run_time=4,+ ))+++class IncmpressibleAndIrrotational(Scene):+ def construct(self):+ div_0 = TextMobject("div$\\textbf{F} = 0$")+ curl_0 = TextMobject("curl$\\textbf{F}$ = 0")+ incompressible = TextMobject("Incompressible")+ irrotational = TextMobject("Irrotational")++ for text in [div_0, curl_0, incompressible, irrotational]:+ text.add_background_rectangle(buff=SMALL_BUFF)++ div_0.to_edge(UP)+ curl_0.next_to(div_0, DOWN, MED_LARGE_BUFF)++ for op, word in (div_0, incompressible), (curl_0, irrotational):+ op.generate_target()+ group = VGroup(op.target, word)+ group.arrange_submobjects(RIGHT, buff=LARGE_BUFF)+ group.move_to(op)++ self.play(FadeInFromDown(div_0))+ self.play(FadeInFromDown(curl_0))+ self.wait()+ self.play(+ MoveToTarget(div_0),+ FadeInFromDown(incompressible),+ )+ self.wait()+ self.play(+ MoveToTarget(curl_0),+ FadeInFromDown(irrotational),+ )+ self.wait()++ rect = SurroundingRectangle(VGroup(curl_0, irrotational))+ question = TextMobject("Does this actually happen?")+ question.next_to(rect, DOWN)+ question.match_color(rect)+ question.add_background_rectangle()++ self.play(ShowCreation(rect))+ self.play(Write(question))+ self.wait()