A community-maintained Python framework for creating mathematical animations.
More clack animations
Grant Sandersonff87e2bfbcf0
diff --git a/active_projects/clacks_solution1.py b/active_projects/clacks_solution1.pyindex 0e6beee80..5a99f54b5 100644--- a/active_projects/clacks_solution1.py+++ b/active_projects/clacks_solution1.py@@ -1045,10 +1045,23 @@ class CircleDiagramFromSlidingBlocks(Scene):"stroke_color": YELLOW,"stroke_width": 2,},- "line_style": {+ "lines_style": {"stroke_color": WHITE,"stroke_width": 1,- }+ },+ "axes_config": {+ "style": {+ "stroke_color": LIGHT_GREY,+ "stroke_width": 1,+ },+ "width": 5,+ "height": 4.5,+ },+ "end_zone_style": {+ "stroke_width": 0,+ "fill_color": GREEN,+ "fill_opacity": 0.3,+ },}def construct(self):@@ -1059,20 +1072,48 @@ class CircleDiagramFromSlidingBlocks(Scene):)blocks = sliding_blocks_scene.blockstimes = [pair[1] for pair in blocks.clack_data]+ self.mass_ratio = 1 / blocks.mass_ratioself.show_circle_lines(times=times,slope=(-1 / np.sqrt(blocks.mass_ratio)))def show_circle_lines(self, times, slope):+ circle = self.get_circle()+ axes = self.get_axes()+ lines = self.get_lines(circle.radius, slope)+ end_zone = self.get_end_zone()++ dot = Dot(color=RED, radius=0.06)+ dot.move_to(lines[0].get_start())++ self.add(end_zone, axes, circle, dot)++ last_time = 0+ for time, line in zip(times, lines):+ if time > 300:+ time = last_time + 1+ self.wait(time - last_time)+ last_time = time+ dot.move_to(line.get_end())+ self.add(line, dot)++ def get_circle(self):circle = Circle(**self.circle_config)- radius = circle.radius- theta = np.arctan(-1 / slope)- axes = VGroup(Line(LEFT, RIGHT), Line(DOWN, UP))- axes.set_width(circle.get_width() + 1, stretch=True)- axes.set_height(circle.get_height() + 0.5, stretch=True)- axes.set_stroke(LIGHT_GREY, 1)+ circle.rotate(PI) # Nice to have start point on left+ return circle++ def get_axes(self):+ config = self.axes_config+ axes = VGroup(+ Line(LEFT, RIGHT).set_width(config["width"]),+ Line(DOWN, UP).set_height(config["height"])+ )+ axes.set_style(**config["style"])+ return axes+ def get_lines(self, radius, slope):+ theta = np.arctan(-1 / slope)n_clacks = int(PI / theta)points = []for n in range(n_clacks + 1):@@ -1085,22 +1126,21 @@ class CircleDiagramFromSlidingBlocks(Scene):])points.append(new_point)- dot = Dot(color=RED)- dot.move_to(points[0])-- self.add(axes, circle, dot)-- last_time = 0- for time, p1, p2 in zip(times, points, points[1:]):- if time > 300:- time = last_time + 1- self.wait(time - last_time)- last_time = time-- line = Line(p1, p2)- line.set_style(**self.line_style)- dot.move_to(p2)- self.add(line, dot)+ lines = VGroup(*[+ Line(p1, p2)+ for p1, p2 in zip(points, points[1:])+ ])+ lines.set_style(**self.lines_style)+ return lines++ def get_end_zone(self):+ slope = 1 / np.sqrt(self.mass_ratio)+ x = self.axes_config["width"] / 2+ zone = Polygon(+ ORIGIN, x * RIGHT, x * RIGHT + slope * x * UP,+ )+ zone.set_style(**self.end_zone_style)+ return zoneclass CircleDiagramFromSlidingBlocksSameMass(CircleDiagramFromSlidingBlocks):@@ -1125,3 +1165,1117 @@ class CircleDiagramFromSlidingBlocks1e4(CircleDiagramFromSlidingBlocks):CONFIG = {"BlocksAndWallSceneClass": BlocksAndWallExampleMass1e4}+++class AnnouncePhaseDiagram(CircleDiagramFromSlidingBlocks):+ def construct(self):+ pd_words = TextMobject("Phase diagram")+ pd_words.scale(1.5)+ pd_words.move_to(self.hold_up_spot, DOWN)+ pd_words_border = pd_words.copy()+ pd_words_border.set_stroke(YELLOW, 2)+ pd_words_border.set_fill(opacity=0)++ simple_words = TextMobject("Simple but powerful")+ simple_words.next_to(pd_words, UP, LARGE_BUFF)+ simple_words.shift(LEFT)+ simple_words.set_color(BLUE)+ simple_arrow = Arrow(+ simple_words.get_bottom(),+ pd_words.get_top(),+ color=simple_words.get_color(),+ )++ self.play(+ self.teacher.change, "raise_right_hand",+ FadeInFromDown(pd_words)+ )+ self.change_student_modes(+ "pondering", "thinking", "pondering",+ added_anims=[ShowCreationThenFadeOut(pd_words_border)]+ )+ self.wait()+ self.play(+ FadeInFrom(simple_words, RIGHT),+ GrowArrow(simple_arrow),+ self.teacher.change, "hooray",+ )+ self.change_student_modes(+ "thinking", "happy", "thinking",+ )+ self.wait(3)+++class AnalyzeCircleGeometry(CircleDiagramFromSlidingBlocks, MovingCameraScene):+ CONFIG = {+ "mass_ratio": 16,+ "circle_config": {+ "radius": 3,+ },+ "axes_config": {+ "width": FRAME_WIDTH,+ "height": FRAME_HEIGHT,+ },+ "lines_style": {+ "stroke_width": 2,+ },+ }++ def construct(self):+ self.add_mass_ratio_label()+ self.add_circle_with_lines()+ self.show_equal_arc_lengths()+ self.use_arc_lengths_to_count()+ self.focus_on_three_points()+ self.show_likewise_for_all_jumps()+ self.drop_arc_for_each_hop()+ self.try_adding_one_more_arc()+ self.zoom_out()++ def add_mass_ratio_label(self, mass_ratio=None):+ mass_ratio = mass_ratio or self.mass_ratio+ mass_ratio_label = TextMobject(+ "Mass ratio =", "{:,} : 1".format(mass_ratio)+ )+ mass_ratio_label.to_corner(UL, buff=MED_SMALL_BUFF)+ self.add(mass_ratio_label)+ self.mass_ratio_label = mass_ratio_label++ def add_circle_with_lines(self):+ circle = self.get_circle()+ axes = self.get_axes()+ axes_labels = self.get_axes_labels(axes)+ slope = -np.sqrt(self.mass_ratio)+ lines = self.get_lines(+ radius=circle.radius,+ slope=slope,+ )+ end_zone = self.get_end_zone()++ end_zone_words = TextMobject("End zone")+ end_zone_words.set_height(0.25)+ end_zone_words.next_to(ORIGIN, UP, SMALL_BUFF)+ end_zone_words.to_edge(RIGHT, buff=MED_SMALL_BUFF)+ end_zone_words.set_color(GREEN)++ self.add(+ axes, axes_labels,+ circle, end_zone, end_zone_words,+ )+ self.play(ShowCreation(lines, run_time=3, rate_func=None))+ self.wait()++ self.set_variables_as_attrs(+ circle, axes, lines,+ end_zone, end_zone_words,+ )++ def show_equal_arc_lengths(self):+ circle = self.circle+ radius = circle.radius+ theta = self.theta = np.arctan(1 / np.sqrt(self.mass_ratio))+ n_arcs = int(PI / (2 * theta))++ lower_arcs = VGroup(*[+ Arc(+ start_angle=(PI + n * 2 * theta),+ angle=(2 * theta),+ radius=radius+ )+ for n in range(n_arcs + 1)+ ])+ lower_arcs[0::2].set_color(RED)+ lower_arcs[1::2].set_color(BLUE)++ upper_arcs = lower_arcs.copy()+ upper_arcs.rotate(PI, axis=RIGHT, about_point=ORIGIN)+ upper_arcs[0::2].set_color(BLUE)+ upper_arcs[1::2].set_color(RED)++ all_arcs = VGroup(*it.chain(*zip(lower_arcs, upper_arcs)))+ if int(PI / theta) % 2 == 1:+ all_arcs.remove(all_arcs[-1])++ arc_copies = lower_arcs.copy()+ for arc_copy in arc_copies:+ arc_copy.generate_target()+ for arc in arc_copies:+ arc.target.rotate(-(arc.start_angle - PI + theta))++ equal_signs = VGroup(*[+ TexMobject("=") for x in range(len(lower_arcs))+ ])+ equal_signs.scale(0.8)+ for sign in equal_signs:+ sign.generate_target()++ movers = VGroup(*it.chain(*zip(+ arc_copies, equal_signs+ )))+ movers.remove(movers[-1])+ mover_targets = VGroup(*[mover.target for mover in movers])+ mover_targets.arrange_submobjects(RIGHT, buff=SMALL_BUFF)+ mover_targets.next_to(ORIGIN, DOWN)+ mover_targets.to_edge(LEFT)++ equal_signs.scale(0)+ equal_signs.fade(1)+ equal_signs.move_to(mover_targets)++ all_arcs.save_state()+ for arc in all_arcs:+ arc.rotate(90 * DEGREES)+ arc.fade(1)+ arc.set_stroke(width=20)+ self.play(Restore(+ all_arcs, submobject_mode="lagged_start",+ run_time=2,+ ))+ self.wait()+ self.play(LaggedStart(MoveToTarget, movers))+ self.wait()++ self.arcs_equation = movers+ self.lower_arcs = lower_arcs+ self.upper_arcs = upper_arcs+ self.all_arcs = all_arcs++ def use_arc_lengths_to_count(self):+ all_arcs = self.all_arcs+ lines = self.lines++ arc_counts = VGroup()+ for n, arc in enumerate(all_arcs):+ count_mob = Integer(n + 1)+ count_mob.scale(0.75)+ point = arc.point_from_proportion(0.5)+ count_mob.next_to(point, normalize(point), SMALL_BUFF)+ arc_counts.add(count_mob)++ self.play(+ FadeOut(lines),+ FadeOut(all_arcs),+ FadeOut(self.arcs_equation),+ )+ self.play(+ ShowIncreasingSubsets(all_arcs),+ ShowIncreasingSubsets(lines),+ ShowIncreasingSubsets(arc_counts),+ run_time=5,+ rate_func=bezier([0, 0, 1, 1])+ )+ self.wait()++ for group in all_arcs, arc_counts:+ targets = VGroup()+ for elem in group:+ elem.generate_target()+ targets.add(elem.target)+ targets.space_out_submobjects(1.2)++ kwargs = {+ "rate_func": there_and_back,+ "run_time": 3,+ }+ self.play(+ LaggedStart(MoveToTarget, all_arcs, **kwargs),+ LaggedStart(MoveToTarget, arc_counts, **kwargs),+ )++ self.arc_counts = arc_counts++ def focus_on_three_points(self):+ lines = self.lines+ arcs = self.all_arcs+ arc_counts = self.arc_counts+ theta = self.theta++ arc = arcs[4]++ lines.save_state()+ line_pair = lines[3:5]+ lines_to_fade = VGroup(*lines[:3], *lines[5:])++ three_points = [+ line_pair[0].get_start(),+ line_pair[1].get_start(),+ line_pair[1].get_end(),+ ]+ three_dots = VGroup(*map(Dot, three_points))+ three_dots.set_color(RED)++ theta_arc = Arc(+ radius=1,+ start_angle=-90 * DEGREES,+ angle=theta+ )+ theta_arc.shift(three_points[1])+ theta_label = TexMobject("\\theta")+ theta_label.next_to(theta_arc, DOWN, SMALL_BUFF)++ center_lines = VGroup(+ Line(three_points[0], ORIGIN),+ Line(ORIGIN, three_points[2]),+ )+ center_lines.match_style(line_pair)++ two_theta_arc = Arc(+ radius=1,+ start_angle=(center_lines[0].get_angle() + PI),+ angle=2 * theta+ )+ two_theta_label = TexMobject("2\\theta")+ arc_center = two_theta_arc.point_from_proportion(0.5)+ two_theta_label.next_to(+ arc_center, normalize(arc_center), SMALL_BUFF+ )+ two_theta_label.shift(SMALL_BUFF * RIGHT)++ to_fade = VGroup(arc_counts, arcs, lines_to_fade)++ self.play(+ LaggedStart(+ FadeOut, VGroup(*to_fade.family_members_with_points())+ )+ )+ lines_to_fade.fade(1)+ self.play(FadeInFromLarge(three_dots[0]))+ self.play(TransformFromCopy(*three_dots[:2]))+ self.play(TransformFromCopy(*three_dots[1:3]))+ self.wait()+ self.play(+ ShowCreation(theta_arc),+ FadeInFrom(theta_label, UP)+ )+ self.wait()+ self.play(+ line_pair.set_stroke, WHITE, 1,+ TransformFromCopy(line_pair, center_lines),+ TransformFromCopy(theta_arc, two_theta_arc),+ TransformFromCopy(theta_label, two_theta_label),+ )+ self.wait()+ self.play(+ TransformFromCopy(two_theta_arc, arc),+ two_theta_label.move_to, 2.7 * arc_center,+ )+ self.wait()++ self.three_dots = three_dots+ self.theta_group = VGroup(theta_arc, theta_label)+ self.center_lines_group = VGroup(+ center_lines, two_theta_arc,+ )+ self.two_theta_label = two_theta_label++ def show_likewise_for_all_jumps(self):+ lines = self.lines+ arcs = self.all_arcs++ every_other_line = lines[::2]++ self.play(+ Restore(+ lines,+ submobject_mode="lagged_start",+ run_time=2+ ),+ FadeOut(self.center_lines_group),+ FadeOut(self.three_dots),+ )+ self.play(LaggedStart(+ ApplyFunction, every_other_line,+ lambda line: (+ lambda l: l.scale(10 / l.get_length()).set_stroke(BLUE, 3),+ line+ )+ ))+ self.play(Restore(lines))+ self.wait()++ # Shift theta label+ last_point = lines[3].get_end()+ last_arc = arcs[4]+ two_theta_label = self.two_theta_label+ theta_group_copy = self.theta_group.copy()+ for line, arc in zip(lines[5:10:2], arcs[6:11:2]):+ new_point = line.get_end()+ arc_point = arc.point_from_proportion(0.5)+ self.play(+ theta_group_copy.shift, new_point - last_point,+ two_theta_label.move_to, 1.1 * arc_point,+ FadeIn(arc),+ FadeOut(last_arc),+ )+ self.wait()+ last_point = new_point+ last_arc = arc+ self.play(+ FadeOut(theta_group_copy),+ FadeOut(two_theta_label),+ FadeOut(last_arc),+ )+ self.wait()++ def drop_arc_for_each_hop(self):+ lines = self.lines+ arcs = self.all_arcs++ two_theta_labels = VGroup()+ wedges = VGroup()+ for arc in arcs:+ label = TexMobject("2\\theta")+ label.scale(0.8)+ label.move_to(1.1 * arc.point_from_proportion(0.5))+ two_theta_labels.add(label)++ wedge = arc.copy()+ wedge.add_control_points([+ *3 * [ORIGIN],+ *3 * [wedge.points[0]]+ ])+ wedge.set_stroke(width=0)+ wedge.set_fill(arc.get_color(), 0.2)+ wedges.add(wedge)++ self.remove(lines)+ for line, arc, label, wedge in zip(lines, arcs, two_theta_labels, wedges):+ self.play(+ ShowCreation(line),+ FadeInFrom(arc, normalize(arc.get_center())),+ FadeInFrom(label, normalize(arc.get_center())),+ FadeIn(wedge),+ )++ self.wedges = wedges+ self.two_theta_labels = two_theta_labels++ def try_adding_one_more_arc(self):+ wedges = self.wedges+ theta = self.theta++ last_wedge = wedges[-1]+ new_wedge = last_wedge.copy()+ new_wedge.set_color(PURPLE)+ new_wedge.set_stroke(WHITE, 1)++ self.play(FadeIn(new_wedge))+ for angle in [-2 * theta, 4 * DEGREES, -2 * DEGREES]:+ self.play(Rotate(new_wedge, angle, about_point=ORIGIN))+ self.wait()+ self.play(+ new_wedge.shift, 10 * RIGHT,+ rate_func=running_start,+ path_arc=-30 * DEGREES,+ )+ self.remove(new_wedge)++ def zoom_out(self):+ frame = self.camera_frame+ self.play(+ frame.scale, 2, {"about_point": (TOP + RIGHT_SIDE)},+ run_time=3+ )+ self.wait()++ # Helpers+ def get_axes_labels(self, axes):+ axes_labels = VGroup(+ TexMobject("x = ", "\\sqrt{m_1}", "\\cdot", "v_1"),+ TexMobject("y = ", "\\sqrt{m_2}", "\\cdot", "v_2"),+ )+ for label in axes_labels:+ label.set_height(0.4)+ axes_labels[0].next_to(ORIGIN, DOWN, SMALL_BUFF)+ axes_labels[0].to_edge(RIGHT, MED_SMALL_BUFF)+ axes_labels[1].next_to(ORIGIN, RIGHT, SMALL_BUFF)+ axes_labels[1].to_edge(UP, SMALL_BUFF)+ return axes_labels+++class InscribedAngleTheorem(Scene):+ def construct(self):+ self.add_title()+ self.show_circle()+ self.let_point_vary()++ def add_title(self):+ title = TextMobject("Inscribed angle theorem")+ title.scale(1.5)+ title.to_edge(UP)+ self.add(title)+ self.title = title++ def show_circle(self):+ # Boy is this over engineered...+ circle = self.circle = Circle(+ color=BLUE,+ radius=2,+ )+ center_dot = Dot(circle.get_center(), color=WHITE)+ self.add(circle, center_dot)++ angle_trackers = self.angle_trackers = VGroup(+ ValueTracker(TAU / 8),+ ValueTracker(PI),+ ValueTracker(-TAU / 8),+ )++ def get_point(angle):+ return circle.point_from_proportion(+ (angle % TAU) / TAU+ )++ def get_dot(angle):+ dot = Dot(get_point(angle))+ dot.set_color(RED)+ dot.set_stroke(BLACK, 3, background=True)+ return dot++ def get_dots():+ return VGroup(*[+ get_dot(at.get_value())+ for at in angle_trackers+ ])++ def update_labels(labels):+ center = circle.get_center()+ for dot, label in zip(dots, labels):+ label.move_to(+ center + 1.2 * (dot.get_center() - center)+ )++ def get_lines():+ lines = VGroup(*[+ Line(d1.get_center(), d2.get_center())+ for d1, d2 in zip(dots, dots[1:])+ ])+ lines.set_stroke(WHITE, 3)+ return lines++ def get_center_lines():+ points = [+ dots[0].get_center(),+ circle.get_center(),+ dots[2].get_center(),+ ]+ lines = VGroup(*[+ Line(p1, p2)+ for p1, p2 in zip(points, points[1:])+ ])+ lines.set_stroke(LIGHT_GREY, 3)+ return lines++ def get_angle_label(lines, tex, reduce_angle=True):+ a1 = (lines[0].get_angle() + PI) % TAU+ a2 = lines[1].get_angle()+ diff = (a2 - a1)+ if reduce_angle:+ diff = ((diff + PI) % TAU) - PI+ point = lines[0].get_end()+ arc = Arc(+ start_angle=a1,+ angle=diff,+ radius=0.5,+ )+ arc.shift(point)+ arc_center = arc.point_from_proportion(0.5)+ label = TexMobject(tex)+ vect = (arc_center - point)+ vect = (0.3 + get_norm(vect)) * normalize(vect)+ label.move_to(point + vect)+ return VGroup(arc, label)++ def get_theta_label():+ return get_angle_label(lines, "\\theta")++ def get_2theta_label():+ return get_angle_label(center_lines, "2\\theta", False)++ dots = get_dots()+ lines = get_lines()+ center_lines = get_center_lines()+ labels = VGroup(*[+ TexMobject("P_{}".format(n + 1))+ for n in range(3)+ ])+ update_labels(labels)+ theta_label = get_theta_label()+ two_theta_label = get_2theta_label()++ self.play(+ FadeInFromDown(labels[0]),+ FadeInFromLarge(dots[0]),+ )+ self.play(+ TransformFromCopy(*labels[:2]),+ TransformFromCopy(*dots[:2]),+ ShowCreation(lines[0]),+ )+ self.play(+ ShowCreation(lines[1]),+ TransformFromCopy(*labels[1:3]),+ TransformFromCopy(*dots[1:3]),+ Write(theta_label),+ )+ self.wait()+ self.play(+ TransformFromCopy(lines, center_lines),+ TransformFromCopy(theta_label, two_theta_label),+ )+ self.wait()++ # Add updaters+ labels.add_updater(update_labels)+ dots.add_updater(lambda m: m.become(get_dots()))+ lines.add_updater(lambda m: m.become(get_lines()))+ center_lines.add_updater(lambda m: m.become(get_center_lines()))+ theta_label.add_updater(lambda m: m.become(get_theta_label()))+ two_theta_label.add_updater(lambda m: m.become(get_2theta_label()))++ self.add(+ labels, lines, center_lines, dots,+ theta_label, two_theta_label,+ )++ def let_point_vary(self):+ p1_tracker, p2_tracker, p3_tracker = self.angle_trackers++ kwargs = {"run_time": 2}+ for angle in [TAU / 4, 3 * TAU / 4]:+ self.play(+ p2_tracker.set_value, angle,+ **kwargs+ )+ self.wait()+ self.play(+ p1_tracker.set_value, PI,+ **kwargs+ )+ self.wait()+ self.play(+ p3_tracker.set_value, TAU / 3,+ **kwargs+ )+ self.wait()+ self.play(+ p2_tracker.set_value, 7 * TAU / 8,+ **kwargs+ )+ self.wait()+++class AddTwoThetaManyTimes(Scene):+ def construct(self):+ expression = TexMobject(+ "2\\theta", "+",+ "2\\theta", "+",+ "2\\theta", "+",+ "\\cdots", "+",+ "2\\theta",+ "<", "2\\pi",+ )+ expression.to_corner(UL)++ brace = Brace(expression[:-2], DOWN)+ question = brace.get_text("Max number of times?")+ question.set_color(YELLOW)++ central_question_group = self.get_central_question()+ simplified, lil_brace, new_question = central_question_group+ central_question_group.next_to(question, DOWN, LARGE_BUFF)+ new_question.align_to(question, LEFT)++ for n in range(5):+ self.add(expression[:2 * n + 1])+ self.wait(0.25)+ self.play(+ FadeInFrom(expression[-2:], LEFT),+ GrowFromCenter(brace),+ FadeInFrom(question, UP)+ )+ self.wait(3)+ self.play(+ TransformFromCopy(expression[:-2], simplified[:3]),+ TransformFromCopy(expression[-2:], simplified[3:]),+ TransformFromCopy(brace, lil_brace),+ )+ self.play(Write(new_question))+ self.wait()++ self.central_question_group = central_question_group+ self.show_example()++ def get_central_question(self, brace_vect=DOWN):+ expression = TexMobject(+ "N", "\\cdot", "\\theta", "<", "\\pi"+ )+ N = expression[0]+ N.set_color(BLUE)+ brace = Brace(N, brace_vect, buff=SMALL_BUFF)+ question = brace.get_text(+ "Maximal integer?",+ )+ question.set_color(YELLOW)+ result = VGroup(expression, brace, question)+ result.to_corner(UL)+ return result++ def show_example(self):+ expression, brace, question = self.central_question_group+ N_mob = Integer(1)+ N_mob.match_height(expression[0])+ N_mob.set_color(BLUE)+ dot_theta_eq = TexMobject("\\cdot", "(0.01)", "=")+ rhs = DecimalNumber(0, num_decimal_places=2)+ rhs.set_color(RED)+ dot_theta_eq.move_to(expression[1:4])+ dot_theta_eq.shift(2 * DOWN)++ def align_value(mob):+ mob.align_to(dot_theta_eq[1][1:-1], DOWN)++ N_mob.add_updater(+ lambda m: m.next_to(dot_theta_eq, LEFT, SMALL_BUFF)+ )+ N_mob.add_updater(align_value)+ rhs.add_updater(+ lambda m: m.set_value(0.01 * N_mob.get_value())+ )+ rhs.add_updater(+ lambda m: m.next_to(dot_theta_eq, RIGHT, 2 * SMALL_BUFF)+ )+ rhs.add_updater(align_value)++ self.play(+ TransformFromCopy(expression[0], N_mob),+ TransformFromCopy(expression[1:4], dot_theta_eq),+ TransformFromCopy(expression[4], rhs),+ )+ self.wait()+ self.play(+ ChangeDecimalToValue(N_mob, 314, run_time=5)+ )+ self.wait()+ self.play(ChangeDecimalToValue(N_mob, 315))+ self.wait()+ self.play(ChangeDecimalToValue(N_mob, 314))+ self.wait()+ self.play(ShowCreationThenFadeAround(N_mob))+++class AskAboutTheta(TeacherStudentsScene):+ def construct(self):+ self.student_says(+ "But what is $\\theta$?",+ target_mode="raise_left_hand",+ )+ self.change_student_modes(+ "confused", "sassy", "raise_left_hand",+ added_anims=[self.teacher.change, "happy"]+ )+ self.wait(3)+++class ComputeThetaFor1e4(AnalyzeCircleGeometry):+ CONFIG = {+ "mass_ratio": 100,+ }++ def construct(self):+ self.add_mass_ratio_label()+ self.add_circle_with_three_lines()+ self.write_slope()+ self.show_tangent()++ def add_circle_with_three_lines(self):+ circle = self.get_circle()+ axes = self.get_axes()+ slope = -np.sqrt(self.mass_ratio)+ lines = self.get_lines(+ radius=circle.radius,+ slope=slope,+ )+ end_zone = self.get_end_zone()+ axes_labels = self.get_axes_labels(axes)+ axes.add(axes_labels)++ lines_to_fade = VGroup(*lines[:11], *lines[13:])+ two_lines = lines[11:13]++ theta = self.theta = np.arctan(-1 / slope)+ arc = Arc(+ start_angle=(-90 * DEGREES),+ angle=theta,+ radius=2,+ arc_center=two_lines[0].get_end(),+ )+ theta_label = TexMobject("\\theta")+ theta_label.scale(0.8)+ theta_label.next_to(arc, DOWN, SMALL_BUFF)++ self.add(end_zone, axes, circle)+ self.play(ShowCreation(lines, rate_func=None))+ self.play(+ lines_to_fade.set_stroke, WHITE, 1, 0.3,+ ShowCreation(arc),+ FadeInFrom(theta_label, UP)+ )++ self.two_lines = two_lines+ self.lines = lines+ self.circle = circle+ self.axes = axes+ self.theta_label_group = VGroup(theta_label, arc)++ def write_slope(self):+ line = self.two_lines[1]+ slope_label = TexMobject(+ "\\text{Slope}", "=",+ "\\frac{\\text{rise}}{\\text{run}}", "=",+ "\\frac{-\\sqrt{m_1}}{\\sqrt{m_2}}", "=", "-10"+ )+ for mob in slope_label:+ mob.add_to_back(mob.copy().set_stroke(BLACK, 6))+ slope_label.next_to(line.get_center(), UR, buff=1)+ slope_arrow = Arrow(+ slope_label[0].get_bottom(),+ line.point_from_proportion(0.45),+ color=RED,+ buff=SMALL_BUFF,+ )+ new_line = line.copy().set_color(RED)++ self.play(+ FadeInFromDown(slope_label[:3]),+ ShowCreation(new_line),+ GrowArrow(slope_arrow),+ )+ self.remove(new_line)+ line.match_style(new_line)+ self.play(+ FadeInFrom(slope_label[3:5], LEFT)+ )+ self.wait()+ self.play(+ Write(slope_label[5]),+ TransformFromCopy(+ self.mass_ratio_label[1][:3],+ slope_label[6]+ )+ )+ self.wait()++ self.slope_label = slope_label+ self.slope_arrow = slope_arrow++ def show_tangent(self):+ l1, l2 = self.two_lines+ theta = self.theta+ theta_label_group = self.theta_label_group++ tan_equation = TexMobject(+ "\\tan", "(", "\\theta", ")", "=",+ "{\\text{run}", "\\over", "-\\text{rise}}", "=",+ "\\frac{1}{10}",+ )+ tan_equation.scale(0.9)+ tan_equation.to_edge(LEFT, buff=MED_SMALL_BUFF)+ tan_equation.shift(2 * UP)+ run_word = tan_equation.get_part_by_tex("run")+ rise_word = tan_equation.get_part_by_tex("rise")++ p1, p2 = l1.get_start(), l1.get_end()+ p3 = p1 + get_norm(p2 - p1) * np.tan(theta) * RIGHT+ triangle = Polygon(p1, p2, p3)+ triangle.set_stroke(width=0)+ triangle.set_fill(GREEN, 0.5)++ opposite = Line(p1, p3)+ adjacent = Line(p1, p2)+ opposite.set_stroke(BLUE, 3)+ adjacent.set_stroke(PINK, 3)++ arctan_equation = TexMobject(+ "\\theta", "=", "\\arctan", "(", "1 / 10", ")"+ )+ arctan_equation.next_to(tan_equation, DOWN, MED_LARGE_BUFF)++ self.play(+ FadeInFromDown(tan_equation[:8]),+ )+ self.play(+ TransformFromCopy(theta_label_group[1], opposite),+ run_word.set_color, opposite.get_color()+ )+ self.play(WiggleOutThenIn(run_word))+ self.play(+ TransformFromCopy(opposite, adjacent),+ rise_word.set_color, adjacent.get_color()+ )+ self.play(WiggleOutThenIn(rise_word))+ self.wait()+ self.play(TransformFromCopy(+ self.slope_label[-1],+ tan_equation[-2:],+ ))+ self.wait(2)++ indices = [2, 4, 0, 1, -1, 3]+ movers = VGroup(*[tan_equation[i] for i in indices]).copy()+ for mover, target in zip(movers, arctan_equation):+ mover.target = target+ # Swap last two+ sm = movers.submobjects+ sm[-1], sm[-2] = sm[-2], sm[-1]+ self.play(LaggedStart(+ Transform, movers,+ lambda m: (m, m.target),+ lag_ratio=0.3,+ run_time=2,+ ))+ self.remove(movers)+ self.add(arctan_equation)+ self.play(ShowCreationThenFadeAround(arctan_equation))+ self.wait()+++class ThetaChart(Scene):+ def construct(self):+ self.create_columns()+ self.populate_columns()+ self.show_values()+ self.highlight_example(2)+ self.highlight_example(3)++ def create_columns(self):+ titles = VGroup(*[+ TextMobject("Mass ratio"),+ TextMobject("$\\theta$ formula"),+ TextMobject("$\\theta$ value"),+ ])+ titles.scale(1.5)+ titles.arrange_submobjects(RIGHT, buff=1.5)+ titles[-1].shift(MED_SMALL_BUFF * RIGHT)+ titles.to_corner(UL)++ lines = VGroup()+ for t1, t2 in zip(titles, titles[1:]):+ line = Line(TOP, BOTTOM)+ x = np.mean([t1.get_center()[0], t2.get_center()[0]])+ line.shift(x * RIGHT)+ lines.add(line)++ h_line = Line(LEFT_SIDE, RIGHT_SIDE)+ h_line.next_to(titles, DOWN)+ h_line.to_edge(LEFT, buff=0)+ lines.add(h_line)+ lines.set_stroke(WHITE, 1)++ self.play(+ LaggedStart(FadeInFromDown, titles),+ LaggedStart(ShowCreation, lines, lag_ratio=0.8),+ )++ self.h_line = h_line+ self.titles = titles++ def populate_columns(self):+ top_h_line = self.h_line+ x_vals = [t.get_center()[0] for t in self.titles]++ entries = [+ (+ "$m_1$ : $m_2$",+ "$\\arctan(\\sqrt{m2} / \\sqrt{m1})$",+ ""+ )+ ] + [+ (+ "{:,} : 1".format(10**(2 * exp)),+ "$\\arctan(1 / {:,})$".format(10**exp),+ "{:0.10f}".format(np.arctan(10**(-exp)))+ )+ for exp in [1, 2, 3, 4, 5]+ ]++ h_lines = VGroup(top_h_line)+ entry_mobs = VGroup()+ for entry in entries:+ mobs = VGroup(*map(TextMobject, entry))+ for mob, x in zip(mobs, x_vals):+ mob.shift(x * RIGHT)+ delta_y = (mobs.get_height() / 2) + MED_SMALL_BUFF+ y = h_lines[-1].get_center()[1] - delta_y+ mobs.shift(y * UP)+ mobs[0].set_color(BLUE)+ mobs[2].set_color(YELLOW)+ entry_mobs.add(mobs)++ h_line = DashedLine(LEFT_SIDE, RIGHT_SIDE)+ h_line.shift((y - delta_y) * UP)+ h_lines.add(h_line)++ self.play(+ LaggedStart(+ FadeInFromDown,+ VGroup(*[em[:2] for em in entry_mobs])+ ),+ LaggedStart(ShowCreation, h_lines[1:])+ )++ self.entry_mobs = entry_mobs+ self.h_lines = h_lines++ def show_values(self):+ values = VGroup(*[em[2] for em in self.entry_mobs])+ for value in values:+ self.play(LaggedStart(+ FadeIn, value,+ lag_ratio=0.1,+ run_time=0.5+ ))+ self.wait(0.5)++ def highlight_example(self, exp):+ entry_mobs = self.entry_mobs+ example = entry_mobs[exp]+ other_entries = VGroup(*entry_mobs[:exp], *entry_mobs[exp + 1:])++ value = example[-1]+ rhs = TexMobject("\\approx {:}".format(10**(-exp)))+ rhs.next_to(value, RIGHT)+ rhs.to_edge(RIGHT, buff=MED_SMALL_BUFF)+ value.generate_target()+ value.target.set_fill(opacity=1)+ value.target.next_to(rhs, LEFT, SMALL_BUFF)++ self.play(+ other_entries.set_fill, {"opacity": 0.25},+ example.set_fill, {"opacity": 1},+ ShowCreationThenFadeAround(example)+ )+ self.wait()+ self.play(+ MoveToTarget(value),+ Write(rhs),+ )+ self.wait()+ value.add(rhs)+++class CentralQuestionFor1e2(AddTwoThetaManyTimes):+ CONFIG = {+ "exp": 2,+ }++ def construct(self):+ exp = self.exp+ question = self.get_central_question(UP)+ pi_value = TexMobject(" = {:0.10f}\\dots".format(PI))+ pi_value.next_to(question[0][-1], RIGHT, SMALL_BUFF)+ pi_value.shift(0.3 * SMALL_BUFF * UP)+ question.add(pi_value)++ max_count = int(PI * 10**exp)++ question.center().to_edge(UP)+ self.add(question)++ b10_equation = self.get_changable_equation(+ 10**(-exp), n_decimal_places=exp+ )+ b10_equation.next_to(question, DOWN, buff=1.5)+ arctan_equation = self.get_changable_equation(+ np.arctan(10**(-exp)), n_decimal_places=10,+ )+ arctan_equation.next_to(b10_equation, DOWN, MED_LARGE_BUFF)+ eq_centers = [+ eq[1][2].get_center()+ for eq in [b10_equation, arctan_equation]+ ]+ arctan_equation.shift((eq_centers[1][0] - eq_centers[1][0]) * RIGHT)++ # b10_brace = Brace(b10_equation[1][1][1:-1], UP)+ arctan_brace = Brace(arctan_equation[1][1][1:-1], DOWN)+ # b10_tex = b10_brace.get_tex("1 / 10")+ arctan_tex = arctan_brace.get_tex(+ "\\theta = \\arctan(1 / {:,})".format(10**exp)+ )++ int_mobs = b10_equation[0], arctan_equation[0]++ self.add(*b10_equation, *arctan_equation)+ # self.add(b10_brace, b10_tex)+ self.add(arctan_brace, arctan_tex)++ self.wait()+ self.play(*[+ ChangeDecimalToValue(int_mob, max_count, run_time=3)+ for int_mob in int_mobs+ ])+ self.wait()+ self.play(*[+ ChangeDecimalToValue(int_mob, max_count + 1, run_time=1)+ for int_mob in int_mobs+ ])+ self.wait()+ self.play(*[+ ChangeDecimalToValue(int_mob, max_count, run_time=1)+ for int_mob in int_mobs+ ])+ self.play(ShowCreationThenFadeAround(int_mobs[1]))+ self.wait()++ #+ def get_changable_equation(self, value, tex_string=None, n_decimal_places=10):+ int_mob = Integer(1)+ int_mob.set_color(BLUE)+ formatter = "({:0." + str(n_decimal_places) + "f})"+ tex_string = tex_string or formatter.format(value)+ tex_mob = TexMobject("\\cdot", tex_string, "=")+ rhs = DecimalNumber(value, num_decimal_places=n_decimal_places)++ def align_number(mob):+ y0 = mob[0].get_center()[1]+ y1 = tex_mob[1][1:-1].get_center()[1]+ mob.shift((y1 - y0) * UP)++ int_mob.add_updater(+ lambda m: m.next_to(tex_mob, LEFT, SMALL_BUFF)+ )+ int_mob.add_updater(align_number)+ rhs.add_updater(+ lambda m: m.set_value(value * int_mob.get_value())+ )+ rhs.add_updater(+ lambda m: m.next_to(tex_mob, RIGHT, SMALL_BUFF)+ )+ rhs.add_updater(align_number)++ def get_comp_pi():+ if rhs.get_value() < np.pi:+ result = TexMobject("< \\pi")+ result.set_color(GREEN)+ elif rhs.get_value() > np.pi:+ result = TexMobject("> \\pi")+ result.set_color(RED)+ else:+ result = TexMobject("= \\pi")+ result.next_to(rhs, RIGHT, 2 * SMALL_BUFF)+ result[1].scale(1.5, about_edge=LEFT)+ return result++ comp_pi = updating_mobject_from_func(get_comp_pi)++ return VGroup(int_mob, tex_mob, rhs, comp_pi)+++class AnalyzeCircleGeometry1e2(AnalyzeCircleGeometry):+ CONFIG = {+ "mass_ratio": 100,+ }+++class CentralQuestionFor1e3(CentralQuestionFor1e2):+ CONFIG = {"exp": 3}diff --git a/manimlib/mobject/numbers.py b/manimlib/mobject/numbers.pyindex 6bda2b95f..6813c46b4 100644--- a/manimlib/mobject/numbers.py+++ b/manimlib/mobject/numbers.py@@ -105,7 +105,10 @@ class DecimalNumber(VMobject):full_config.update(self.initial_config)full_config.update(config)new_decimal = DecimalNumber(number, **full_config)- new_decimal.match_height(self)+ # new_decimal.match_height(self)+ new_decimal.scale(+ self[0].get_height() / new_decimal[0].get_height()+ )new_decimal.move_to(self, self.edge_to_fix)new_decimal.match_style(self)@@ -129,3 +132,6 @@ class Integer(DecimalNumber):def increment_value(self):self.set_value(self.get_value() + 1)++ def get_value(self):+ return int(np.round(super().get_value()))