A community-maintained Python framework for creating mathematical animations.
tweaking some diffyq content
Grant Sandersond6876b995d40
diff --git a/.gitignore b/.gitignoreindex 9c9818386..5055cdfb1 100644--- a/.gitignore+++ b/.gitignore@@ -7,6 +7,7 @@ cairo_test.pymayavi_test.pyrandom_scenes/files/+assets/ben_playground.pyben_cairo_test.py.floodiff --git a/active_projects/diffyq/name_animations.py b/active_projects/diffyq/name_animations.pydeleted file mode 100644index 456874de2..000000000--- a/active_projects/diffyq/name_animations.py+++ /dev/null@@ -1,40 +0,0 @@-#!/usr/bin/env python-from manimlib.imports import *-from active_projects.diffyq.part2.fourier_series import FourierOfName--name_color_pairs = [--]--circle_counts = [- # 10,- # 25,- 100,-]--if __name__ == "__main__":- for name, color in name_color_pairs:- for n_circles in circle_counts:- try:- first_name = name.split(" ")[0]- scene = FourierOfName(- name_text=name,- name_color=color,- n_circles=n_circles,- file_writer_config={- "write_to_movie": True,- "output_directory": os.path.join(- "patron_fourier_names",- first_name,- ),- "file_name": "{}_Fouierified_{}_Separate_paths".format(- first_name,- n_circles- ),- },- camera_config={- "frame_rate": 24,- },- )- except:- passdiff --git a/active_projects/diffyq/part1/phase_space.py b/active_projects/diffyq/part1/phase_space.pyindex e59e2af04..ff8486048 100644--- a/active_projects/diffyq/part1/phase_space.py+++ b/active_projects/diffyq/part1/phase_space.py@@ -2012,11 +2012,18 @@ class ManyStepsFromDifferentStartingPoints(TakeManyTinySteps):class Thumbnail(IntroduceVectorField):CONFIG = {"vector_field_config": {- "delta_x": 0.5,- "delta_y": 0.5,+ # "delta_x": 0.5,+ # "delta_y": 0.5,+ # "max_magnitude": 5,+ # "length_func": lambda norm: 0.5 * sigmoid(norm),+ "delta_x": 1,+ "delta_y": 1,"max_magnitude": 5,- "length_func": lambda norm: 0.5 * sigmoid(norm),- }+ "length_func": lambda norm: 0.9 * sigmoid(norm),+ },+ "big_pendulum_config": {+ "damping": 0.4,+ },}def construct(self):@@ -2027,7 +2034,7 @@ class Thumbnail(IntroduceVectorField):field = self.vector_fieldfield.set_stroke(width=5)for vector in field:- vector.set_stroke(width=3)+ vector.set_stroke(width=8)vector.tip.set_stroke(width=0)vector.tip.scale(1.5, about_point=vector.get_last_point())vector.set_opacity(1)@@ -2063,17 +2070,43 @@ class Thumbnail(IntroduceVectorField):new_mob.set_stroke(width=0)black_parts.add(new_mob)- for vect in field:- for mob in title.family_members_with_points():- for p in [vect.get_start(), vect.get_end()]:- x, y = p[:2]- x0, y0 = mob.get_corner(DL)[:2]- x1, y1 = mob.get_corner(UR)[:2]- if x0 < x < x1 and y0 < y < y1:- vect.set_opacity(0.25)- vect.tip.set_stroke(width=0)+ # for vect in field:+ # for mob in title.family_members_with_points():+ # for p in [vect.get_start(), vect.get_end()]:+ # x, y = p[:2]+ # x0, y0 = mob.get_corner(DL)[:2]+ # x1, y1 = mob.get_corner(UR)[:2]+ # if x0 < x < x1 and y0 < y < y1:+ # vect.set_opacity(0.25)+ # vect.tip.set_stroke(width=0)self.add(self.plane)self.add(field)- self.add(black_parts)- self.add(title)+ # self.add(black_parts)+ # self.add(title)++ self.add_line(self.plane)++ def add_line(self, axes):+ func = self.vector_field_func++ line = VMobject()+ line.start_new_path(axes.c2p(-TAU, 3.5))++ dt = 0.1+ t = 0+ total_time = 40++ while t < total_time:+ t += dt+ last_point = line.get_last_point()+ new_point = last_point + dt * func(last_point)+ if new_point[0] > FRAME_WIDTH / 2:+ new_point = last_point + FRAME_WIDTH * LEFT+ line.start_new_path(new_point)+ else:+ line.add_smooth_curve_to(new_point)++ line.set_stroke(WHITE, 6)+ line.make_smooth()+ self.add(line)diff --git a/active_projects/diffyq/part2/fourier_series.py b/active_projects/diffyq/part2/fourier_series.pyindex cf4e2c0ca..932b376e5 100644--- a/active_projects/diffyq/part2/fourier_series.py+++ b/active_projects/diffyq/part2/fourier_series.py@@ -379,6 +379,7 @@ class FourierOfName(FourierOfPiSymbol):"name_text": "Abc","time_per_symbol": 5,"slow_factor": 1 / 5,+ "parametric_function_step_size": 0.01,}def construct(self):@@ -389,31 +390,49 @@ class FourierOfName(FourierOfPiSymbol):if name.get_height() > max_height:name.set_height(max_height)+ vectors = VGroup(VectorizedPoint())circles = VGroup(VectorizedPoint())for path in name.family_members_with_points():for subpath in path.get_subpaths():sp_mob = VMobject()sp_mob.set_points(subpath)coefs = self.get_coefficients_of_path(sp_mob)- new_circles = self.get_circles(+ new_vectors = self.get_rotating_vectors(coefficients=coefs)+ new_circles = self.get_circles(new_vectors)self.set_decreasing_stroke_widths(new_circles)- drawn_path = self.get_drawn_path(new_circles)++ drawn_path = self.get_drawn_path(new_vectors)drawn_path.clear_updaters()drawn_path.set_stroke(self.name_color, 3)- new_circles.suspend_updating()- self.play(ReplacementTransform(circles, new_circles))- new_circles.resume_updating()- circles = new_circles+ static_vectors = VMobject().become(new_vectors)+ static_circles = VMobject().become(new_circles)+ # static_circles = new_circles.deepcopy()+ # static_vectors.clear_updaters()+ # static_circles.clear_updaters()++ self.play(+ Transform(vectors, static_vectors, remover=True),+ Transform(circles, static_circles, remover=True),+ )++ self.add(new_vectors, new_circles)+ self.vector_clock.set_value(0)self.play(ShowCreation(drawn_path),rate_func=linear,run_time=self.time_per_symbol)- circles.suspend_updating()- self.play(FadeOut(circles))+ self.remove(new_vectors, new_circles)+ self.add(static_vectors, static_circles)++ vectors = static_vectors+ circles = static_circles+ self.play(+ FadeOut(vectors)+ )self.wait(3)diff --git a/active_projects/diffyq/part5/staging.py b/active_projects/diffyq/part5/staging.pyindex 5f71d23c6..baf34ba14 100644--- a/active_projects/diffyq/part5/staging.py+++ b/active_projects/diffyq/part5/staging.py@@ -1,22 +1,24 @@from manimlib.imports import *+T_COLOR = LIGHT_GREY+VELOCITY_COLOR = GREEN+POSITION_COLOR = BLUE+CONST_COLOR = YELLOW+tex_config = {"tex_to_color_map": {- "{t}": YELLOW,- "{0}": YELLOW,+ "{t}": T_COLOR,+ "{0}": T_COLOR,"e^": WHITE,"=": WHITE,}}-VELOCITY_COLOR = RED-POSITION_COLOR = GREEN-class IntroductionOfExp(Scene):def construct(self):questions = VGroup(- TextMobject("What", "is", "$e^{t}$"),+ TextMobject("What", "is", "$e^{t}$", "?"),TextMobject("What", "properties", "does", "$e^{t}$", "have?"),TextMobject("What", "property", "defines", "$e^{t}$", "?",@@ -29,7 +31,7 @@ class IntroductionOfExp(Scene):questions.to_edge(UP)for question in questions:part = question.get_part_by_tex("e^{t}")- part[1].set_color(YELLOW)+ part[1].set_color(T_COLOR)top_cross = Cross(questions[0])@@ -63,7 +65,7 @@ class IntroductionOfExp(Scene):self.play(TransformFromCopy(questions[1].get_part_by_tex("$e^{t}$"),- derivative[3:5],+ derivative[3:7],),FadeIn(derivative[:2]),FadeIn(derivative.get_part_by_tex("=")),@@ -87,9 +89,9 @@ class IntroductionOfExp(Scene):self.wait()self.play(TransformFromCopy(- derivative[3:5],- derivative[-2:],- path_arc=-PI+ derivative[3:7:3],+ derivative[-5:],+ path_arc=-60 * DEGREES,),)self.wait()@@ -107,15 +109,35 @@ class IntroductionOfExp(Scene):self.wait()def get_deriv_and_ic(self, const=None):- # TODO, use const+ if const:+ const_str = "{" + str(const) + "}"+ mult_str = "\\cdot"+ else:+ const_str = "{}"+ mult_str = "{}"+ args = [+ "{d \\over d{t}}",+ "e^{",+ const_str,+ "{t}}",+ "=",+ const_str,+ mult_str,+ "e^{",+ const_str,+ "{t}}"+ ]derivative = TexMobject(- "{d \\over d{t}} e^{t} = e^{t}",+ *args,**tex_config)+ if const:+ derivative.set_color_by_tex(const_str, CONST_COLOR)+ic = TexMobject("e^{0} = 1", **tex_config)group = VGroup(derivative, ic)group.arrange(RIGHT, buff=LARGE_BUFF)- ic.align_to(derivative[-2], DOWN)+ ic.align_to(derivative.get_part_by_tex("e^"), DOWN)group.scale(1.5)group.to_edge(UP)return group@@ -126,14 +148,18 @@ class IntroducePhysicalModel(IntroductionOfExp):"number_line_config": {"x_min": 0,"x_max": 100,- "unit_size": 1,+ "unit_size": 1.5,"numbers_with_elongated_ticks": [0],- "numbers_to_show": list(range(0, 15))+ "numbers_to_show": list(range(0, 15)),+ "label_direction": UP,},"number_line_y": -2,"const": 1,"const_str": "","num_decimal_places": 2,+ "output_label_config": {+ "show_ellipsis": True,+ },}def construct(self):@@ -141,6 +167,7 @@ class IntroducePhysicalModel(IntroductionOfExp):self.setup_movers()self.show_number_line()self.show_formulas()+ self.let_time_pass()def setup_number_line(self):nl = self.number_line = NumberLine(@@ -156,6 +183,7 @@ class IntroducePhysicalModel(IntroductionOfExp):self.setup_vector_labels()self.setup_tip()self.setup_tip_label()+ self.setup_output_label()def setup_value_trackers(self):number_line = self.number_line@@ -163,6 +191,15 @@ class IntroducePhysicalModel(IntroductionOfExp):input_tracker = ValueTracker(0)get_input = input_tracker.get_value+ def complex_number_to_point(z):+ zero = number_line.n2p(0)+ unit = number_line.n2p(1) - zero+ perp = rotate_vector(unit, TAU / 4)+ z = complex(z)+ return zero + unit * z.real + perp * z.imag++ number_line.cn2p = complex_number_to_point+def get_output():return np.exp(self.const * get_input())@@ -187,46 +224,16 @@ class IntroducePhysicalModel(IntroductionOfExp):def setup_tip(self):tip = ArrowTip(start_angle=-PI / 2)- tip.set_height(0.4)- tip.stretch(0.25, 0)+ tip.set_height(0.6)+ tip.set_width(0.1, stretch=True)tip.add_updater(lambda m: m.move_to(self.get_output_point(), DOWN))- tip.set_color(WHITE)+ # tip.set_color(WHITE)+ tip.set_fill(GREY, 1)self.tip = tip- def setup_vectors(self):- number_line = self.number_line-- position_vect = Vector(color=POSITION_COLOR)- velocity_vect = Vector(color=VELOCITY_COLOR)-- position_vect.add_updater(- lambda m: m.put_start_and_end_on(- number_line.n2p(0),- number_line.n2p(self.get_output()),- )- )-- def update_velocity_vect(vect):- vect.put_start_and_end_on(- *position_vect.get_start_and_end()- )- vect.scale(abs(self.const))- vect.rotate(np.log(self.const).imag)- vect.shift(self.get_output_point() - vect.get_start())- return vect-- velocity_vect.add_updater(update_velocity_vect)-- self.position_vect = position_vect- self.velocity_vect = velocity_vect-- def setup_vector_labels(self):- position_vect = self.position_vect- velocity_vect = self.velocity_vect-def setup_tip_label(self):tip = self.tipconst_str = self.const_str@@ -239,17 +246,18 @@ class IntroducePhysicalModel(IntroductionOfExp):tip_label = TexMobject(*args, arg_separator="")if const_str:- tip_label[1].set_color(BLUE)+ tip_label[1].set_color(CONST_COLOR)template_decimal = tip_label[-1]# parens = tip_label[-3::2]template_decimal.set_opacity(0)tip_label.add_updater(lambda m: m.next_to(tip, UP,+ buff=2 * SMALL_BUFF,index_of_submobject_to_align=0))decimal = DecimalNumber(num_decimal_places=ndp)- decimal.set_color(YELLOW)+ decimal.set_color(T_COLOR)decimal.match_height(template_decimal)decimal.add_updater(lambda m: m.set_value(self.get_input()))decimal.add_updater(@@ -259,21 +267,1320 @@ class IntroducePhysicalModel(IntroductionOfExp):self.tip_label = tip_label+ def setup_output_label(self):+ label = VGroup(+ TexMobject("="),+ DecimalNumber(1, **self.output_label_config)+ )+ label.set_color(POSITION_COLOR)+ label.add_updater(+ lambda m: m[1].set_value(+ self.get_output()+ )+ )+ label.add_updater(+ lambda m: m.arrange(RIGHT, buff=SMALL_BUFF)+ )+ label.add_updater(+ lambda m: m.next_to(+ self.tip_label, RIGHT,+ buff=SMALL_BUFF,+ aligned_edge=DOWN,+ )+ )++ self.output_label = label++ def setup_vectors(self):+ number_line = self.number_line++ position_vect = Vector(color=POSITION_COLOR)+ velocity_vect = Vector(color=VELOCITY_COLOR)++ position_vect.add_updater(+ lambda m: m.put_start_and_end_on(+ number_line.cn2p(0),+ number_line.cn2p(self.get_output()),+ )+ )++ def update_velocity_vect(vect):+ vect.put_start_and_end_on(+ number_line.cn2p(0),+ number_line.cn2p(self.const * self.get_output())+ )+ vect.shift(+ number_line.cn2p(self.get_output()) - number_line.n2p(0)+ )+ return vect++ velocity_vect.add_updater(update_velocity_vect)++ self.position_vect = position_vect+ self.velocity_vect = velocity_vect++ def setup_vector_labels(self):+ position_vect = self.position_vect+ velocity_vect = self.velocity_vect++ max_width = 1.5+ p_label = TextMobject("Position")+ p_label.set_color(POSITION_COLOR)+ p_label.vect = position_vect+ v_label = TextMobject("Velocity")+ v_label.set_color(VELOCITY_COLOR)+ v_label.vect = velocity_vect++ # for label in [p_label, v_label]:+ # label.add_background_rectangle()++ def update_label(label):+ label.set_width(min(+ max_width,+ 0.8 * label.vect.get_length(),+ ))+ direction = normalize(label.vect.get_vector())+ perp_direction = rotate_vector(direction, -TAU / 4)+ label.next_to(+ label.vect.get_center(),+ np.round(perp_direction),+ buff=MED_SMALL_BUFF,+ )+ p_label.add_updater(update_label)+ v_label.add_updater(update_label)++ self.position_label = p_label+ self.velocity_label = v_label+def show_number_line(self):number_line = self.number_line- self.add(number_line)+ self.play(+ LaggedStartMap(+ FadeIn,+ number_line.numbers.copy(),+ remover=True,+ ),+ Write(number_line),+ run_time=2+ )+ self.wait()++ def show_formulas(self):+ deriv, ic = self.get_deriv_and_ic()+ eq_index = deriv.index_of_part_by_tex("=")+ lhs = deriv[:eq_index - 1]+ rhs = deriv[eq_index + 1:]++ rhs_rect = SurroundingRectangle(rhs)+ lhs_rect = SurroundingRectangle(lhs)+ rects = VGroup(rhs_rect, lhs_rect)+ rhs_rect.set_stroke(POSITION_COLOR, 2)+ lhs_rect.set_stroke(VELOCITY_COLOR, 2)++ rhs_word = TextMobject("Position")+ lhs_word = TextMobject("Velocity")+ words = VGroup(rhs_word, lhs_word)+ for word, rect in zip(words, rects):+ word.match_color(rect)+ word.next_to(rect, DOWN)++ self.add(deriv, ic)++ self.play(+ ShowCreation(rhs_rect),+ FadeInFrom(rhs_word, UP),+ ShowCreation(self.position_vect)+ )+ self.add(+ self.tip,+ self.number_line,+ self.position_vect,+ )+ self.number_line.numbers.set_stroke(BLACK, 3, background=True)+ self.play(+ Transform(+ rhs.copy(),+ self.tip_label.copy().clear_updaters(),+ remover=True,+ ),+ GrowFromPoint(self.tip, rhs.get_bottom()),+ TransformFromCopy(rhs_word, self.position_label),+ )+ self.add(self.tip_label)+ self.wait()+ self.play(+ ShowCreation(lhs_rect),+ FadeInFrom(lhs_word, UP),+ )+ self.wait()+ self.play(+ TransformFromCopy(+ self.position_vect,+ self.velocity_vect,+ path_arc=PI,+ )+ )+ self.play(+ TransformFromCopy(+ lhs_word,+ self.velocity_label,+ )+ )+ self.wait()++ def let_time_pass(self):+ # Sort of a quick and dirty implementation,+ # not the best for reusability++ rate = 0.25+ t_tracker = self.input_tracker+ t_tracker.add_updater(+ lambda m, dt: m.increment_value(rate * dt)+ )++ nl = self.number_line+ zero_point = nl.n2p(0)++ nl_copy = nl.copy()+ nl_copy.submobjects = []+ nl_copy.stretch(100, 0, about_point=zero_point)+ nl.add(nl_copy)++ # For first zoom+ xs1 = range(25, 100, 25)+ nl.add(*[+ nl.get_tick(x, size=1.5)+ for x in xs1+ ])+ nl.add_numbers(+ *xs1,+ number_config={"height": 5},+ buff=2,+ )++ # For second zoom+ xs2 = range(200, 1000, 200)+ nl.add(*[+ nl.get_tick(x, size=15)+ for x in xs2+ ])+ nl.add_numbers(+ *xs2,+ number_config={"height": 50},+ buff=20,+ )++ # For third zoom+ xs3 = range(2000, 10000, 2000)+ nl.add(*[+ nl.get_tick(x, size=150)+ for x in xs3+ ])+ nl.add_numbers(+ *xs3,+ number_config={+ "height": 300,+ },+ buff=200,+ )+ for n in nl.numbers:+ n[1].scale(0.5)self.add(self.tip)++ self.add(self.output_label)+ self.play(VFadeIn(self.output_label))+ self.wait(5)+ self.play(+ nl.scale, 0.1, {"about_point": zero_point},+ run_time=1,+ )+ self.wait(6)+ self.play(+ nl.scale, 0.1, {"about_point": zero_point},+ run_time=1,+ )+ self.wait(8)+ self.play(+ nl.scale, 0.1, {"about_point": zero_point},+ run_time=1,+ )+ self.wait(12)+++class ConstantEquals2(IntroducePhysicalModel):+ CONFIG = {+ "const": 2,+ "const_str": "2",+ "const_text": "Double",+ }++ def construct(self):+ self.setup_number_line()+ self.setup_movers()++ self.add_initial_objects()+ self.point_out_chain_rule()+ self.show_double_vector()+ self.let_time_pass()++ def add_initial_objects(self):+ deriv, ic = self.get_deriv_and_ic(+ const=self.const+ )+ self.deriv = deriv+ self.ic = ic+ self.add(ic)++ self.add(self.tip)+ self.add(self.number_line)self.add(self.position_vect)- self.add(self.velocity_vect)+ self.add(self.position_label)self.add(self.tip_label)+ def point_out_chain_rule(self):+ deriv = self.deriv++ eq = deriv.get_part_by_tex("=")+ dot = deriv.get_part_by_tex("\\cdot")+ eq_index = deriv.index_of_part(eq)+ dot_index = deriv.index_of_part(dot)+ v_part = deriv[:eq_index - 1]+ c_part = deriv[eq_index + 1: dot_index]+ p_part = deriv[dot_index + 1:]+ parts = VGroup(v_part, c_part, p_part)++ rects = VGroup(*map(SurroundingRectangle, parts))+ words = VGroup(*map(TextMobject, [+ "Velocity", self.const_text, "Position"+ ]))+ colors = [VELOCITY_COLOR, CONST_COLOR, POSITION_COLOR]+ for rect, word, color in zip(rects, words, colors):+ rect.set_stroke(color, 2)+ word.set_color(color)+ word.next_to(rect, DOWN)++ v_rect, c_rect, p_rect = rects+ v_word, c_word, p_word = words+ self.readjust_const_label(c_word, c_rect)++ self.add(v_part, eq)+ self.add(v_rect, v_word)++ p_part.save_state()+ p_part.replace(v_part[-4:])+ c_part.save_state()+ c_part.replace(p_part.saved_state[2])++ self.play(ShowCreationThenFadeAround(+ v_part[-2],+ surrounding_rectangle_config={+ "color": CONST_COLOR+ },+ ))+ self.wait()+ self.play(+ Restore(p_part, path_arc=-TAU / 6),+ FadeIn(p_rect),+ FadeIn(p_word),+ )+ self.play(+ Restore(c_part, path_arc=TAU / 6),+ FadeIn(dot)+ )self.play(- self.input_tracker.set_value, 0.56,- run_time=3,+ FadeIn(c_rect),+ FadeIn(c_word),)+ self.wait()- def show_formulas(self):- deriv, ic = self.get_deriv_and_ic()+ self.v_word = v_word- self.add(deriv, ic)+ def show_double_vector(self):+ v_vect = self.velocity_vect+ p_vect = self.position_vect+ p_copy = p_vect.copy()+ p_copy.clear_updaters()+ p_copy.generate_target()+ p_copy.target.shift(2 * UR)++ times_2 = TexMobject("\\times", "2")+ times_2.set_color_by_tex("2", CONST_COLOR)+ times_2.next_to(p_copy.target.get_end(), UP, MED_SMALL_BUFF)++ self.play(+ MoveToTarget(p_copy),+ FadeIn(times_2),+ )+ self.play(+ p_copy.scale, 2, {"about_edge": LEFT},+ p_copy.match_color, v_vect,+ )+ self.play(FadeOut(times_2))+ self.play(+ ReplacementTransform(p_copy, v_vect),+ TransformFromCopy(+ self.v_word,+ self.velocity_label,+ )+ )+ self.wait()++ def let_time_pass(self):+ # Largely copying from the above scene.+ # Note to self: If these are reused anymore,+ # factor this out properly+ rate = 0.25+ t_tracker = self.input_tracker+ t_tracker.add_updater(+ lambda m, dt: m.increment_value(rate * dt)+ )++ nl = self.number_line+ zero_point = nl.n2p(0)++ nl_copy = nl.copy()+ nl_copy.submobjects = []+ nl_copy.stretch(1000, 0, about_point=zero_point)+ nl.add(nl_copy)++ # For first zoom+ xs1 = range(25, 100, 25)+ nl.add(*[+ nl.get_tick(x, size=1.5)+ for x in xs1+ ])+ nl.add_numbers(+ *xs1,+ number_config={"height": 5},+ buff=2,+ )++ # For second zoom+ xs2 = range(200, 1000, 200)+ nl.add(*[+ nl.get_tick(x, size=15)+ for x in xs2+ ])+ nl.add_numbers(+ *xs2,+ number_config={"height": 50},+ buff=20,+ )++ # For third zoom+ xs3 = range(2000, 10000, 2000)+ nl.add(*[+ nl.get_tick(x, size=150)+ for x in xs3+ ])+ nl.add_numbers(+ *xs3,+ number_config={+ "height": 300,+ },+ buff=200,+ )+ for n in nl.numbers:+ n[1].scale(0.5)++ # For fourth zoom+ xs3 = range(20000, 100000, 20000)+ nl.add(*[+ nl.get_tick(x, size=1500)+ for x in xs3+ ])+ nl.add_numbers(+ *xs3,+ number_config={+ "height": 3000,+ },+ buff=2000,+ )+ for n in nl.numbers:+ n[2].scale(0.5)++ self.add(self.tip)+ self.add(self.output_label)+ self.play(VFadeIn(self.output_label))+ for x in range(4):+ self.wait_until(+ lambda: self.position_vect.get_end()[0] > 0+ )+ self.play(+ nl.scale, 0.1, {"about_point": zero_point},+ run_time=1,+ )+ self.wait(5)++ #+ def readjust_const_label(self, c_word, c_rect):+ c_rect.stretch(1.2, 1, about_edge=DOWN)+ c_word.next_to(c_rect, UP)+++class NegativeConstant(ConstantEquals2):+ CONFIG = {+ "const": -0.5,+ "const_str": "-0.5",+ "const_text": "Flip and squish",+ "number_line_config": {+ "unit_size": 2.5,+ }+ }++ def construct(self):+ self.setup_number_line()+ self.setup_movers()++ self.add_initial_objects()+ self.point_out_chain_rule()+ self.show_vector_manipulation()+ self.let_time_pass()++ def show_vector_manipulation(self):+ p_vect = self.position_vect+ v_vect = self.velocity_vect++ p_copy = p_vect.copy()+ p_copy.clear_updaters()+ p_copy.generate_target()+ p_copy.target.shift(5 * RIGHT + 2 * UP)++ times_neg1 = TexMobject("\\times", "(\\cdot 1)")+ temp_neg = times_neg1[1][-3]+ neg = TexMobject("-")+ neg.set_width(0.2, stretch=True)+ neg.move_to(temp_neg)+ temp_neg.become(neg)++ times_point5 = TexMobject("\\times", "0.5")+ terms = VGroup(times_neg1, times_point5)+ for term in terms:+ term[1].set_color(CONST_COLOR)+ terms.arrange(LEFT, buff=SMALL_BUFF)++ terms.next_to(p_copy.target.get_start(), UP)++ v_vect.add_updater(+ lambda m: m.shift(SMALL_BUFF * UP)+ )+ self.velocity_label.add_updater(+ lambda m: m.next_to(+ self.velocity_vect,+ UP, buff=SMALL_BUFF,+ )+ )++ v_vect_back = v_vect.copy()+ v_vect_back.set_stroke(BLACK, 3)++ self.play(+ MoveToTarget(p_copy),+ FadeIn(times_neg1),+ )+ self.play(+ Rotate(+ p_copy,+ angle=PI,+ about_point=p_copy.get_start(),+ )+ )+ self.wait()+ self.play(+ p_copy.scale, 0.5,+ {"about_point": p_copy.get_start()},+ p_copy.match_color, v_vect,+ FadeIn(times_point5)+ )+ self.wait()+ self.play(+ ReplacementTransform(p_copy, v_vect),+ FadeOut(terms),+ TransformFromCopy(+ self.v_word,+ self.velocity_label,+ ),+ )+ self.add(v_vect_back, v_vect)+ self.add(self.velocity_label)++ def let_time_pass(self):+ nl = self.number_line+ t_tracker = self.input_tracker+ zero_point = nl.n2p(0)++ scale_factor = 4.5+ nl.generate_target(use_deepcopy=True)+ nl.target.scale(scale_factor, about_point=zero_point)+ for tick in [*nl.target.tick_marks, *nl.target.big_tick_marks]:+ tick.scale(1 / scale_factor)+ nl.target.tick_marks[1].scale(2)++ for number in nl.target.numbers:+ number.scale(1.5 / scale_factor, about_edge=DOWN)+ number.align_to(zero_point + 0.3 * UP, DOWN)++ new_ticks = VGroup(*[+ nl.get_tick(x)+ for x in np.arange(0.1, 1.5, 0.1)+ ])++ self.play(+ MoveToTarget(nl),+ new_ticks.stretch, scale_factor, 0,+ {"about_point": zero_point},+ VFadeIn(new_ticks),+ )+ self.wait()++ rate = 0.25+ t_tracker.add_updater(+ lambda m, dt: m.increment_value(rate * dt)+ )+ self.play(VFadeIn(self.output_label))+ self.wait(20)++ #+ def readjust_const_label(self, c_word, c_rect):+ super().readjust_const_label(c_word, c_rect)+ c_word.shift(SMALL_BUFF * DOWN)+ c_word.shift(MED_SMALL_BUFF * RIGHT)+++class ImaginaryConstant(ConstantEquals2):+ CONFIG = {+ "const": complex(0, 1),+ "const_str": "i",+ "const_text": "Rotate $90^\\circ$",+ "number_line_config": {+ "x_min": -5,+ "unit_size": 2.5,+ },+ "output_label_config": {+ "show_ellipsis": False,+ },+ "plane_unit_size": 2.5,+ }++ def construct(self):+ self.setup_number_line()+ self.setup_movers()+ self.add_initial_objects()+ self.show_vector_manipulation()+ self.transition_to_complex_plane()+ self.show_vector_field()+ self.show_circle()++ def setup_number_line(self):+ super().setup_number_line()+ nl = self.number_line+ nl.shift(nl.n2p(-5) - nl.n2p(0))+ nl.shift(0.5 * DOWN)+ shift_distance = (4 * nl.tick_size + nl.numbers.get_height() + SMALL_BUFF)+ nl.numbers.shift(shift_distance * DOWN)++ def add_initial_objects(self):+ deriv, ic = self.get_deriv_and_ic("i")+ VGroup(deriv, ic).shift(0.5 * DOWN)+ ic.shift(RIGHT)+ self.deriv = deriv+ self.ic = ic++ self.add(self.number_line)+ self.add(self.position_vect)+ self.add(self.position_label)++ # self.tip_label.clear_updaters()+ self.tip_label.shift_vect = VectorizedPoint(0.2 * UP)+ self.tip_label.add_updater(+ lambda m: m.next_to(+ self.position_vect.get_end(), UP,+ buff=0,+ index_of_submobject_to_align=0,+ ).shift(m.shift_vect.get_location())+ )++ eq = deriv.get_part_by_tex("=")+ dot = deriv.get_part_by_tex("\\cdot")+ eq_index = deriv.index_of_part(eq)+ dot_index = deriv.index_of_part(dot)+ v_term = deriv[:eq_index - 1]+ c_term = deriv[eq_index + 1: dot_index]+ p_term = deriv[dot_index + 1:]++ terms = VGroup(v_term, c_term, p_term)+ rects = VGroup(*map(SurroundingRectangle, terms))+ colors = [VELOCITY_COLOR, CONST_COLOR, POSITION_COLOR]+ labels = VGroup(*map(+ TextMobject,+ ["Velocity", self.const_text, "Position"]+ ))+ for rect, color, label in zip(rects, colors, labels):+ rect.set_stroke(color, 2)+ label.set_color(color)+ label.next_to(rect, DOWN)++ v_label, c_label, p_label = labels+ v_rect, c_rect, p_rect = rects+ self.term_rects = rects+ self.term_labels = labels++ randy = Randolph()+ randy.next_to(deriv, DOWN, LARGE_BUFF)+ point = VectorizedPoint(p_term.get_center())+ randy.add_updater(lambda r: r.look_at(point))++ self.play(+ FadeInFromDown(p_term),+ VFadeIn(randy),+ )+ self.play(randy.change, "confused")+ self.play(+ ShowCreation(p_rect),+ FadeInFrom(p_label, UP)+ )+ self.add(self.number_line, self.position_vect)+ self.play(+ Transform(+ p_label.copy(),+ self.tip_label.copy().clear_updaters(),+ remover=True,+ ),+ point.move_to, self.position_vect.get_end(),+ FadeIn(ic),+ )+ self.add(self.tip_label)+ self.play(Blink(randy))+ self.play(FadeOut(randy))++ # Velocity+ self.play(+ LaggedStartMap(FadeIn, [+ v_term, eq, v_rect, v_label,+ ]),+ run_time=1+ )+ c_term.save_state()+ c_term.replace(p_term[2])+ self.play(+ Restore(c_term, path_arc=TAU / 4),+ FadeIn(dot),+ )++ c_rect.stretch(1.2, 1, about_edge=DOWN)+ c_label.next_to(c_rect, UP)+ c_label.shift(0.5 * RIGHT)+ self.c_rect = c_rect+ self.c_label = c_label+ self.v_label = v_label++ def show_vector_manipulation(self):+ p_vect = self.position_vect+ v_vect = self.velocity_vect++ p_copy = p_vect.copy()+ p_copy.clear_updaters()+ p_copy.generate_target()+ p_copy.target.center()+ p_copy.target.shift(1.5 * DOWN)++ rot_p = p_copy.target.copy()+ rot_p.rotate(TAU / 4, about_point=rot_p.get_start())+ rot_p.match_style(v_vect)++ arc = Arc(+ angle=TAU / 4,+ radius=0.5,+ arc_center=p_copy.target.get_start(),+ )+ arc.add_tip(tip_length=0.1)+ angle_label = TexMobject("90^\\circ")+ angle_label.scale(0.5)+ angle_label.next_to(arc.point_from_proportion(0.5), UR, SMALL_BUFF)++ times_i = TexMobject("\\times", "i")+ times_i.set_color_by_tex("i", CONST_COLOR)+ times_i.next_to(p_copy.target, UP, buff=0)++ rot_v_label = TextMobject("Velocity")+ rot_v_label.set_color(VELOCITY_COLOR)+ rot_v_label.add_background_rectangle()+ rot_v_label.scale(0.8)+ rot_v_label.curr_angle = 0++ def update_rot_v_label(label):+ label.rotate(-label.curr_angle)+ label.next_to(ORIGIN, DOWN, 2 * SMALL_BUFF)+ # angle = PI + self.velocity_vect.get_angle()+ angle = 0+ label.rotate(angle, about_point=ORIGIN)+ label.curr_angle = angle+ # label.shift(self.velocity_vect.get_center())+ label.next_to(+ self.velocity_vect.get_end(),+ RIGHT,+ buff=SMALL_BUFF+ )++ rot_v_label.add_updater(update_rot_v_label)++ self.play(+ MoveToTarget(p_copy),+ FadeIn(times_i),+ )+ self.play(+ FadeIn(self.c_rect),+ FadeInFromDown(self.c_label),+ )+ self.play(+ ShowCreation(arc),+ FadeIn(angle_label),+ ApplyMethod(+ times_i.next_to, rot_p, RIGHT, {"buff": 0},+ path_arc=TAU / 4,+ ),+ TransformFromCopy(+ p_copy, rot_p,+ path_arc=-TAU / 4,+ ),+ )+ self.wait()++ temp_rot_v_label = rot_v_label.copy()+ temp_rot_v_label.clear_updaters()+ temp_rot_v_label.replace(self.v_label, dim_to_match=0)+ self.play(+ TransformFromCopy(rot_p, v_vect),+ TransformFromCopy(temp_rot_v_label, rot_v_label),+ self.tip_label.shift_vect.move_to, 0.1 * UP + 0.2 * RIGHT,+ )+ self.play(FadeOut(VGroup(+ p_copy, arc, angle_label,+ times_i, rot_p,+ )))++ self.velocity_label = rot_v_label++ def transition_to_complex_plane(self):+ nl = self.number_line+ background_rects = VGroup(*[+ BackgroundRectangle(rect)+ for rect in self.term_rects+ ])+ self.ic.add_background_rectangle()+ for label in self.term_labels:+ label.add_background_rectangle()++ corner_group = VGroup(+ background_rects,+ self.deriv,+ self.term_rects,+ self.term_labels,+ self.ic,+ )+ corner_group.generate_target()+ corner_group.target.to_corner(UL)+ corner_group.target[-1].next_to(+ corner_group.target, DOWN,+ buff=0.75,+ aligned_edge=LEFT+ )++ plane = ComplexPlane()+ plane.unit_size = self.plane_unit_size+ plane.scale(plane.unit_size)+ plane.add_coordinates()+ plane.shift(DOWN + 0.25 * RIGHT)++ nl.generate_target(use_deepcopy=True)+ nl.target.numbers.set_opacity(0)+ nl.target.scale(+ plane.unit_size / nl.unit_size+ )+ nl.target.shift(plane.n2p(0) - nl.target.n2p(0))++ plane_title = TextMobject("Complex plane")+ plane_title.set_stroke(BLACK, 3, background=True)+ plane_title.scale(2)+ plane_title.to_corner(UR)++ self.add(+ plane,+ corner_group,+ self.position_vect,+ self.velocity_vect,+ self.position_label,+ self.velocity_label,+ self.tip_label,+ )+ plane.save_state()+ plane.set_opacity(0)+ self.play(+ VFadeIn(background_rects),+ MoveToTarget(corner_group),+ MoveToTarget(nl),+ )+ self.play(+ Restore(plane, lag_ratio=0.01),+ FadeInFromDown(plane_title)+ )+ self.play(FadeOut(nl))+ self.play(FadeOut(plane_title))+ self.wait()++ self.plane = plane+ self.corner_group = corner_group++ def show_vector_field(self):+ plane = self.plane+ temp_faders = VGroup(+ self.position_vect,+ self.position_label,+ self.velocity_vect,+ self.velocity_label,+ self.tip_label,+ )+ foreground = VGroup(+ self.corner_group,+ )++ # Initial examples+ n = 12+ zs = [+ np.exp(complex(0, k * TAU / n))+ for k in range(n)+ ]+ points = map(plane.n2p, zs)+ vects = VGroup(*[+ Arrow(+ plane.n2p(0), point,+ buff=0,+ color=POSITION_COLOR,+ )+ for point in points+ ])+ vects.set_opacity(0.75)+ attached_vects = VGroup(*[+ vect.copy().shift(vect.get_vector())+ for vect in vects+ ])+ attached_vects.set_color(VELOCITY_COLOR)+ v_vects = VGroup(*[+ av.copy().rotate(+ 90 * DEGREES,+ about_point=av.get_start()+ )+ for av in attached_vects+ ])++ self.play(+ LaggedStartMap(GrowArrow, vects),+ FadeOut(temp_faders),+ )+ self.wait()+ self.play(+ TransformFromCopy(+ vects, attached_vects,+ path_arc=20 * DEGREES,+ )+ )+ self.play(+ ReplacementTransform(+ attached_vects,+ v_vects,+ path_arc=90 * DEGREES,+ )+ )+ self.wait()++ # Vector fields+ zero_point = plane.n2p(0)++ def func(p):+ vect = p - zero_point+ return rotate_vector(vect, 90 * DEGREES)++ vf_config = {+ # "x_min": plane.n2p(-3)[0],+ # "x_max": plane.n2p(3)[0],+ # "y_min": plane.c2p(0, -2)[1],+ # "y_max": plane.c2p(0, 2)[1],+ "max_magnitude": 8,+ "opacity": 0.5,+ }+ vf0 = VectorField(+ lambda p: np.array(p) - zero_point,+ length_func=lambda x: x,+ # opacity=0.5,+ **vf_config,+ )+ vf1 = VectorField(+ func,+ length_func=lambda x: x,+ # opacity=0.5,+ **vf_config,+ )+ vf2 = VectorField(+ func,+ **vf_config,+ )+ for vf in [vf0, vf1, vf2]:+ vf.submobjects.sort(+ key=lambda m: get_norm(m.get_start())+ )++ self.play(+ FadeIn(vf0, lag_ratio=0.01, run_time=3),+ FadeOut(vects),+ FadeOut(v_vects),+ FadeOut(foreground),+ )+ self.play(+ Transform(vf0, vf1, path_arc=90 * DEGREES)+ )+ self.play(+ Transform(+ vf0, vf2,+ lag_ratio=0.001,+ run_time=2,+ ),+ )+ self.play(+ FadeIn(foreground)+ )+ self.play(FadeIn(temp_faders))++ self.vector_field = vf0+ self.foreground = foreground++ def show_circle(self):+ t_tracker = self.input_tracker+ ic = self.ic+ output_label = self.output_label+ plane = self.plane+ tip_label = self.tip_label++ output_label.update(0)+ # output_rect = BackgroundRectangle(output_label)+ # output_rect.add_updater(+ # lambda m: m.move_to(output_label)+ # )+ # output_rect.set_opacity(0)+ output_label.set_stroke(BLACK, 5, background=True)++ ic_rect = SurroundingRectangle(ic)+ ic_rect.set_color(BLUE)++ circle = Circle(+ radius=get_norm(plane.n2p(1) - plane.n2p(0)),+ stroke_color=TEAL,+ )+ circle.move_to(plane.n2p(0))++ epii, eti = results = [+ TexMobject(+ "e^{{i}" + s1 + "} = " + s2,+ tex_to_color_map={+ "{i}": CONST_COLOR,+ "\\pi": T_COLOR,+ "\\tau": T_COLOR,+ "-1": POSITION_COLOR,+ "1": POSITION_COLOR,+ }+ )+ for s1, s2 in [("\\pi", "-1"), ("\\tau", "1")]+ ]+ for result in results:+ rect = SurroundingRectangle(result)+ rect.set_stroke(WHITE, 1)+ rect.set_fill(BLACK, 0.75)+ result.add_to_back(rect)+ # result.set_stroke(BLACK, 5, background=True)+ result.scale(2)+ result.to_corner(UR)+ result.save_state()+ result.fade(1)+ eti.saved_state.next_to(epii, DOWN, buff=MED_LARGE_BUFF)++ epii.move_to(plane.n2p(-1), LEFT)+ eti.move_to(plane.n2p(1), LEFT)++ self.play(ShowCreation(ic_rect))+ self.play(FadeOut(ic_rect))+ self.play(+ Transform(+ ic[-1].copy(),+ output_label.deepcopy().clear_updaters(),+ remover=True+ ),+ FadeOut(self.position_label),+ FadeOut(self.velocity_label),+ )+ self.add(output_label)+ self.wait()++ circle_copy = circle.copy()+ circle_copy.save_state()+ self.play(+ ShowCreation(circle),+ t_tracker.set_value, TAU,+ run_time=TAU,+ rate_func=linear,+ )+ self.wait()+ self.play(+ t_tracker.set_value, 0,+ circle.set_stroke, {"width": 1},+ )+ self.wait()+ self.add(circle_copy, self.tip_label, self.output_label)+ self.play(+ ApplyMethod(+ t_tracker.set_value, PI,+ rate_func=linear,+ ),+ tip_label.shift_vect.move_to, 0.25 * UR,+ ShowCreation(+ circle_copy,+ rate_func=lambda t: 0.5 * t,+ ),+ run_time=PI,+ )+ self.wait()+ self.play(Restore(epii, run_time=2))+ self.wait()+ circle_copy.restore()+ self.play(+ ApplyMethod(+ t_tracker.set_value, TAU,+ rate_func=linear,+ ),+ tip_label.shift_vect.move_to, 0.1 * UR,+ ShowCreation(+ circle_copy,+ rate_func=lambda t: 0.5 + 0.5 * t,+ ),+ run_time=PI,+ )+ self.wait()+ self.play(Restore(eti, run_time=2))+ self.wait()++ rate = 1+ t_tracker.add_updater(+ lambda m, dt: m.increment_value(rate * dt)+ )+ # self.play(VFadeOut(output_label))+ self.wait(16)+++class PiMinuteMark(Scene):+ def construct(self):+ text = TexMobject(+ "\\pi \\text{ minutes} \\approx \\text{3:08}"+ )+ rect = SurroundingRectangle(text)+ rect.set_fill(BLACK, 1)+ rect.set_stroke(WHITE, 2)++ self.play(+ FadeInFromDown(rect),+ FadeInFromDown(text),+ )+ self.wait()+++class ReferenceWhatItMeans(PiCreatureScene):+ def construct(self):+ randy = self.pi_creature++ tex_config = {+ "tex_to_color_map": {+ "{i}": CONST_COLOR,+ "\\pi": T_COLOR,+ "-1": POSITION_COLOR,+ },+ }+ epii = TexMobject(+ "e^{{i} \\pi} = -1",+ **tex_config+ )+ epii.scale(2)++ many_es = TexMobject("e \\cdot e \\cdots e", "= -1", **tex_config)+ many_es.scale(2)+ brace = Brace(many_es[0], DOWN)+ pi_i = TexMobject("{i} \\pi \\text{ times}", **tex_config)+ pi_i.next_to(brace, DOWN, SMALL_BUFF)+ repeated_mult = VGroup(many_es, brace, pi_i)++ # arrow = Vector(2 * RIGHT)+ arrow = TexMobject("\\Rightarrow")+ arrow.scale(2)++ group = VGroup(epii, arrow, repeated_mult)+ group.arrange(+ RIGHT, buff=LARGE_BUFF,+ )+ for mob in group[1:]:+ mob.shift(+ (epii[0].get_bottom() - mob[0].get_bottom())[1] * UP+ )+ group.to_edge(UP)++ does_not_mean = TextMobject("Does \\emph{not}\\\\mean")+ does_not_mean.set_color(RED)+ does_not_mean.move_to(arrow)+ # cross = Cross(repeated_mult)++ nonsense = TextMobject(+ "\\dots because that's "+ "literal nonsense!"+ )+ nonsense.next_to(repeated_mult, DOWN)+ nonsense.to_edge(RIGHT, buff=MED_SMALL_BUFF)+ nonsense.set_color(RED)++ down_arrow = TexMobject("\\Downarrow")+ down_arrow.scale(2)+ down_arrow.stretch(1.5, 1)+ down_arrow.set_color(GREEN)+ down_arrow.next_to(epii, DOWN, LARGE_BUFF)+ actually_means = TextMobject("It actually\\\\means")+ actually_means.next_to(down_arrow, RIGHT)+ actually_means.set_color(GREEN)++ series = TexMobject(+ "{({i} \\pi )^0 \\over 0!} + ",+ "{({i} \\pi )^1 \\over 1!} + ",+ "{({i} \\pi )^2 \\over 2!} + ",+ "{({i} \\pi )^3 \\over 3!} + ",+ "{({i} \\pi )^4 \\over 4!} + ",+ "\\cdots = -1",+ **tex_config+ )+ series.set_width(FRAME_WIDTH - 1)+ series.next_to(down_arrow, DOWN, LARGE_BUFF)+ series.set_x(0)++ self.add(epii)+ self.play(+ FadeInFrom(arrow, LEFT),+ FadeInFrom(repeated_mult, 2 * LEFT),+ randy.change, "maybe",+ )+ self.wait()+ self.play(randy.change, "confused")+ self.play(+ FadeOutAndShift(arrow, DOWN),+ FadeInFrom(does_not_mean, UP),+ )+ self.play(Write(nonsense))+ self.play(randy.change, "angry")+ # self.play(ShowCreation(cross))+ self.wait()+ self.play(+ FadeOutAndShift(randy, DOWN),+ FadeInFrom(down_arrow, UP),+ FadeInFrom(actually_means, LEFT),+ FadeIn(series, lag_ratio=0.1, run_time=2)+ )+ self.wait()+++class VideoWrapper(Scene):+ def construct(self):+ fade_rect = FullScreenFadeRectangle()+ fade_rect.set_fill(DARK_GREY, 1)+ screen_rects = VGroup(+ ScreenRectangle(),+ ScreenRectangle(),+ )+ screen_rects.set_height(3)+ screen_rects.set_fill(BLACK, 1)+ screen_rects.set_stroke(width=0)+ screen_rects.arrange(RIGHT, buff=LARGE_BUFF)+ screen_rects.shift(1.25 * UP)++ boundary = VGroup(*map(AnimatedBoundary, screen_rects))++ titles = VGroup(+ TextMobject("Want more?"),+ TextMobject("Learn calculus"),+ )+ titles.scale(1.5)+ for rect, title, in zip(screen_rects, titles):+ title.next_to(rect, UP)++ self.add(fade_rect)+ self.add(screen_rects)++ self.add(boundary[0])+ self.play(FadeInFromDown(titles[0]))+ self.add(boundary[1])+ self.play(FadeInFromDown(titles[1]))+ self.wait(18)+++class Thumbnail(Scene):+ def construct(self):+ epii = TexMobject(+ "e^{{i} \\pi} = -1",+ tex_to_color_map={+ "{i}": CONST_COLOR,+ "\\pi": T_COLOR,+ "-1": POSITION_COLOR,+ }+ )+ epii.set_width(8)+ epii.to_edge(UP)++ words = VGroup(+ TextMobject("in"),+ TextMobject(+ "in",+ "3.14", " minutes"+ ),+ )+ # words.set_width(FRAME_WIDTH - 4)+ words.set_stroke(BLACK, 6, background=True)+ words.set_width(FRAME_WIDTH - 2)+ words.arrange(DOWN, buff=LARGE_BUFF)+ words.next_to(epii, DOWN, LARGE_BUFF)+ words[1].set_color_by_tex("3.14", YELLOW)+ words.shift(-words[0].get_center())+ words[0].set_opacity(0)++ unit_size = 1.5+ plane = ComplexPlane()+ plane.scale(unit_size)+ plane.add_coordinates()++ circle = Circle(+ radius=unit_size,+ color=YELLOW,+ )+ # half_circle = VMobject()+ # half_circle.pointwise_become_partial(circle, 0, 0.5)+ # half_circle.set_stroke(RED, 6)+ p_vect = Arrow(+ plane.n2p(0),+ plane.n2p(1),+ buff=0,+ color=POSITION_COLOR,+ )+ v_vect = Arrow(+ plane.n2p(1),+ plane.n2p(complex(1, 1)),+ buff=0,+ color=VELOCITY_COLOR,+ )+ vects = VGroup(p_vect, v_vect)+ vects.set_stroke(width=10)++ self.add(plane)+ self.add(circle)+ self.add(vects)+ self.add(epii)+ self.add(words)diff --git a/stage_scenes.py b/stage_scenes.pyindex ddb179ceb..e86c4f38f 100644--- a/stage_scenes.py+++ b/stage_scenes.py@@ -45,7 +45,7 @@ def stage_scenes(module_name):animation_dir = os.path.join(os.path.expanduser('~'),"Dropbox (3Blue1Brown)/3Blue1Brown Team Folder/videos",- "diffyq", "part4", "1440p60"+ "diffyq", "part5", "1440p60")#files = os.listdir(animation_dir)