def construct(self): definition = TexMobject([ "\\text{HC}(", "x", ")", "=\\lim_{n \\to \\infty}\\text{PHC}_n(", "x", ")" ]) definition.to_edge(UP) definition.split()[1].highlight(BLUE) definition.split()[-2].highlight(BLUE) intro = TextMobject("Three things need to be proven") prove_that = TextMobject("Prove that HC is $\\dots$") prove_that.scale(0.7) prove_that.to_edge(LEFT) items = TextMobject([ "\\begin{enumerate}", "\\item Well-defined: ", "Points on Pseudo-Hilbert-curves really do converge", "\\item A Curve: ", "HC is continuous", "\\item Space-filling: ", "Each point in the unit square is an output of HC", "\\end{enumerate}", ]).split() items[1].highlight(GREEN) items[3].highlight(YELLOW_C) items[5].highlight(MAROON) Mobject(*items).to_edge(RIGHT) self.add(definition) self.play(ShimmerIn(intro)) self.wait() self.play(Transform(intro, prove_that)) for item in items[1:-1]: self.play(ShimmerIn(item)) self.wait()
def construct(self): low_res = ImageMobject("low_resolution_lion", invert = False) high_res = ImageMobject("Lion", invert = False) grid = get_grid().scale(0.8) for mob in low_res, high_res: mob.replace(grid, stretch = True) side_brace = Brace(low_res, LEFT) top_brace = Brace(low_res, UP) top_words = TextMobject("256 Px", size = "\\normal") side_words = top_words.copy().rotate(np.pi/2) top_words.next_to(top_brace, UP) side_words.next_to(side_brace, LEFT) self.add(high_res) self.dither() self.play(DelayByOrder(Transform(high_res, low_res))) self.dither() self.play( GrowFromCenter(top_brace), GrowFromCenter(side_brace), ShimmerIn(top_words), ShimmerIn(side_words) ) self.dither() for mob in grid, high_res: mob.sort_points(np.linalg.norm) self.play(DelayByOrder(Transform(high_res, grid))) self.dither()
def construct(self): grids = [ Grid( 2**order, 2**order, stroke_width = 1 ).shift(0.3*DOWN) for order in 6, 7 ] grid = grids[0] side_brace = Brace(grid, LEFT) top_brace = Brace(grid, UP) top_words = TextMobject("256") new_top_words = TextMobject("512") side_words = top_words.copy() new_side_words = new_top_words.copy() for words in top_words, new_top_words: words.next_to(top_brace, UP, buff = 0.1) for words in side_words, new_side_words: words.next_to(side_brace, LEFT) self.add(grid) self.play( GrowFromCenter(side_brace), GrowFromCenter(top_brace), ShimmerIn(top_words), ShimmerIn(side_words) ) self.dither() self.play( DelayByOrder(Transform(*grids)), Transform(top_words, new_top_words), Transform(side_words, new_side_words) ) self.dither()
def construct(self): words = TextMobject([ "One does not simply define the limit \\\\ \ of a sequence of", "curves", "\\dots" ]) top_words = TextMobject(["curves", "are functions"]).to_edge(UP) curves1 = words.split()[1] curves2 = top_words.split()[0] words.ingest_submobjects() number = TexMobject("0.27") pair = TexMobject("(0.53, 0.02)") pair.next_to(number, buff=2) arrow = Arrow(number, pair) Mobject(number, arrow, pair).center().shift(UP) number_line = UnitInterval() number_line.stretch_to_fit_width(5) number_line.to_edge(LEFT).shift(DOWN) grid = Grid(4, 4).scale(0.4) grid.next_to(number_line, buff=2) low_arrow = Arrow(number_line, grid) self.play(ShimmerIn(words)) self.dither() self.play(FadeOut(words), ApplyMethod(curves1.replace, curves2), ShimmerIn(top_words.split()[1])) self.dither() self.play(FadeIn(number)) self.play(ShowCreation(arrow)) self.play(FadeIn(pair)) self.dither() self.play(ShowCreation(number_line)) self.play(ShowCreation(low_arrow)) self.play(ShowCreation(grid)) self.dither()
def discontinuous_point(self): point_description = TextMobject("Point where the function jumps") point_description.shift(3 * RIGHT) discontinuous_at_A = TextMobject("``Discontinuous at A''", size="\\Large") discontinuous_at_A.shift(2 * UP).to_edge(LEFT) text = TextMobject(""" Circle around ouput \\\\ points can never \\\\ be smaller than \\\\ the jump """) text.scale(0.75) text.shift(3.5 * RIGHT) input_value = 0.5 input_radius = 0.04 vary_circles = VaryCircles( self, input_value, input_radius, run_time=5, ) for dot in self.input_dot, self.output_dot: dot.center() kwargs = { "rate_func": lambda t: interpolate(0.45, input_value, smooth(t)) } self.play(Homotopy(self.input_homotopy, self.input_dot, **kwargs), Homotopy(self.output_homotopy, self.output_dot, **kwargs)) discontinuous_arrow = Arrow(discontinuous_at_A, self.input_dot) arrow = Arrow(point_description, self.output_dot, buff=0.05, color=self.output_color) self.play(ShimmerIn(point_description), ShowCreation(arrow)) self.dither() self.remove(point_description, arrow) tup = self.get_circles_and_points(input_value - input_radius, input_value + input_radius) input_circle, input_points, output_circle, output_points = tup input_points_copy = input_points.copy() self.play(ShowCreation(input_circle)) self.play(ShowCreation(input_points)) self.play(Transform(input_points_copy, output_points), run_time=2) self.play(ShowCreation(output_circle)) self.dither() self.play(ShimmerIn(text)) self.remove(input_circle, input_points, output_circle, input_points_copy) self.play(vary_circles) self.dither() self.play(ShimmerIn(discontinuous_at_A), ShowCreation(discontinuous_arrow)) self.dither(3) self.remove(vary_circles.mobject, discontinuous_at_A, discontinuous_arrow)
def construct(self, order): if order == 2: result_tex = "(0.125, 0.75)" elif order == 3: result_tex = "(0.0758, 0.6875)" phc, arg, result = TexMobject([ "\\text{PHC}_%d"%order, "(0.3)", "= %s"%result_tex ]).to_edge(UP).split() function = TextMobject("Function", size = "\\normal") function.shift(phc.get_center()+DOWN+2*LEFT) function_arrow = Arrow(function, phc) line = Line(5*LEFT, 5*RIGHT) curve = HilbertCurve(order = order) line.match_colors(curve) grid = Grid(2**order, 2**order) grid.fade() for mob in curve, grid: mob.scale(0.7) index = int(0.3*line.get_num_points()) dot1 = Dot(line.points[index]) arrow1 = Arrow(arg, dot1, buff = 0.1) dot2 = Dot(curve.points[index]) arrow2 = Arrow(result.get_bottom(), dot2, buff = 0.1) self.add(phc) self.play( ShimmerIn(function), ShowCreation(function_arrow) ) self.wait() self.remove(function_arrow, function) self.play(ShowCreation(line)) self.wait() self.play( ShimmerIn(arg), ShowCreation(arrow1), ShowCreation(dot1) ) self.wait() self.remove(arrow1) self.play( FadeIn(grid), Transform(line, curve), Transform(dot1, dot2), run_time = 2 ) self.wait() self.play( ShimmerIn(result), ShowCreation(arrow2) ) self.wait()
def show_change_side_by_side(self): seed = TextMobject("Seed") seed.shift(3 * LEFT + 2 * DOWN) fractal = TextMobject("Fractal") fractal.shift(3 * RIGHT + 2 * DOWN) words = map(TextMobject, [ "A sharper angle results in a richer curve", "A more obtuse angle gives a sparser curve", "And as the angle approaches 0\\dots", "We have a new space-filling curve." ]) for text in words: text.to_edge(UP) sharper, duller, space_filling = [ CurveClass(order=1).shift(3 * LEFT) for CurveClass in SharperKoch, DullerKoch, SpaceFillingKoch ] shaper_f, duller_f, space_filling_f = [ CurveClass(order=self.max_order).shift(3 * RIGHT) for CurveClass in SharperKoch, DullerKoch, SpaceFillingKoch ] self.add(words[0]) left_curve = SharperKoch(order=1) right_curve = SharperKoch(order=1) self.play( Transform(left_curve, sharper), ApplyMethod(right_curve.shift, 3 * RIGHT), ) self.play( Transform(right_curve, SharperKoch(order=2).shift(3 * RIGHT)), ShimmerIn(seed), ShimmerIn(fractal)) for order in range(3, self.max_order): self.play( Transform(right_curve, SharperKoch(order=order).shift(3 * RIGHT))) self.remove(words[0]) self.add(words[1]) kwargs = { "run_time": 4, } self.play(Transform(left_curve, duller, **kwargs), Transform(right_curve, duller_f, **kwargs)) self.wait() kwargs["run_time"] = 7 kwargs["rate_func"] = None self.remove(words[1]) self.add(words[2]) self.play(Transform(left_curve, space_filling, **kwargs), Transform(right_curve, space_filling_f, **kwargs)) self.remove(words[2]) self.add(words[3]) self.wait()
def construct(self): all_points = TextMobject("$f$ is continuous at every input point") continuous = TextMobject("$f$ is continuous") all_points.shift(UP) continuous.shift(DOWN) arrow = Arrow(all_points, continuous) self.play(ShimmerIn(all_points)) self.play(ShowCreation(arrow)) self.play(ShimmerIn(continuous)) self.wait()
def construct(self): top_words = TextMobject("Different pixel-frequency association") bottom_words = TextMobject("Need to relearn sight-via-sound") top_words.shift(UP) bottom_words.shift(DOWN) arrow = Arrow(top_words, bottom_words) self.play(ShimmerIn(top_words)) self.dither() self.play(ShowCreation(arrow)) self.play(ShimmerIn(bottom_words)) self.dither()
def construct(self): mathy, bubble = get_mathy_and_bubble() squiggle_mouth = mathy.mouth.copy() squiggle_mouth.apply_function( lambda (x, y, z) : (x, y+0.02*np.sin(50*x), z) ) bubble.ingest_submobjects() bubble.write("Why not use a Hilbert curve \\textinterrobang ") words1 = bubble.content bubble.write("So, it's not one curve but an infinite family of curves \\dots") words2 = bubble.content bubble.write("Well, no, it \\emph{is} just one thing, but I need \\\\ \ to tell you about a certain infinite family first.") words3 = bubble.content description = TextMobject("Mathematician friend", size = "\\small") description.next_to(mathy, buff = 2) arrow = Arrow(description, mathy) self.add(mathy) self.play( ShowCreation(arrow), ShimmerIn(description) ) self.dither() point = Point(bubble.get_tip()) self.play( Transform(point, bubble), ) self.remove(point) self.add(bubble) self.play(ShimmerIn(words1)) self.dither() self.remove(description, arrow) self.play( Transform(mathy.mouth, squiggle_mouth), ApplyMethod(mathy.arm.wag, 0.2*RIGHT, LEFT), ) self.remove(words1) self.add(words2) self.dither(2) self.remove(words2) self.add(words3) self.dither(2) self.play( ApplyPointwiseFunction( lambda p : 15*p/np.linalg.norm(p), bubble ), ApplyMethod(mathy.shift, 5*(DOWN+LEFT)), FadeOut(words3), run_time = 3 )
def label_spaces(self): input_space = TextMobject("Input Space") input_space.to_edge(UP) input_space.shift(LEFT * SPACE_WIDTH / 2) output_space = TextMobject("Output Space") output_space.to_edge(UP) output_space.shift(RIGHT * SPACE_WIDTH / 2) line = Line(UP * SPACE_HEIGHT, DOWN * SPACE_HEIGHT, color=WHITE) self.play( ShimmerIn(input_space), ShimmerIn(output_space), ShowCreation(line), ShowCreation(self.interval), ) self.dither()
def finite_analog(self, left_mob, arrow, right_mob): self.clear() self.add(left_mob, arrow, right_mob) ex = TextMobject("\\times") ex.highlight(RED) # ex.shift(arrow.get_center()) middle = TexMobject("\\sum_{n=0}^N 2^n \\equiv -1 \\mod 2^{N+1}") finite_analog = TextMobject("Finite analog") finite_analog.scale(0.8) brace = Brace(middle, UP) finite_analog.next_to(brace, UP) new_left = left_mob.copy().to_edge(LEFT) new_right = right_mob.copy().to_edge(RIGHT) left_arrow, right_arrow = [ Arrow(mob1.get_right()[0] * RIGHT, mob2.get_left()[0] * RIGHT, buff=0) for mob1, mob2 in [(new_left, middle), (middle, new_right)] ] for mob in ex, middle: mob.sort_points(np.linalg.norm) self.play(GrowFromCenter(ex)) self.wait() self.play(Transform(left_mob, new_left), Transform(arrow.copy(), left_arrow), DelayByOrder(Transform(ex, middle)), Transform(arrow, right_arrow), Transform(right_mob, new_right)) self.play(GrowFromCenter(brace), ShimmerIn(finite_analog)) self.wait() self.equivalence(left_mob, left_arrow, Mobject(middle, brace, finite_analog))
def construct(self): scale_factor = 0.9 grid = Grid(4, 4, stroke_width=1) curve = HilbertCurve(order=2) for mob in grid, curve: mob.scale(scale_factor) words = TextMobject(""" Sequence of curves is stable $\\leftrightarrow$ existence of limit curve """, size="\\normal") words.scale(1.25) words.to_edge(UP) self.add(curve, grid) self.wait() for n in range(3, 7): if n == 5: self.play(ShimmerIn(words)) new_grid = Grid(2**n, 2**n, stroke_width=1) new_curve = HilbertCurve(order=n) for mob in new_grid, new_curve: mob.scale(scale_factor) self.play(ShowCreation(new_grid), Animation(curve)) self.remove(grid) grid = new_grid self.play(Transform(curve, new_curve)) self.wait()
def show_angles(self): words = TextMobject(""" Let's see what happens as we change the angle in this seed """) words.to_edge(UP) koch, sharper_koch, duller_koch = curves = [ CurveClass(order=1) for CurveClass in StraightKoch, SharperKoch, DullerKoch ] arcs = [ Arc(2 * (np.pi / 2 - curve.angle), radius=r, start_angle=np.pi + curve.angle).shift( curve.points[curve.get_num_points() / 2]) for curve, r in zip(curves, [0.6, 0.7, 0.4]) ] theta = TexMobject("\\theta") theta.shift(arcs[0].get_center() + 2.5 * DOWN) arrow = Arrow(theta, arcs[0]) self.add(words, koch) self.play(ShowCreation(arcs[0])) self.play(ShowCreation(arrow), ShimmerIn(theta)) self.wait(2) self.remove(theta, arrow) self.play( Transform(koch, duller_koch), Transform(arcs[0], arcs[2]), ) self.play( Transform(koch, sharper_koch), Transform(arcs[0], arcs[1]), ) self.clear()
def construct(self): mathy, bubble = get_mathy_and_bubble() bubble.write("A Hilbert curve is the \\\\ limit of all these \\dots") self.add(mathy, bubble) self.play(ShimmerIn(bubble.content)) self.dither()
def construct(self): curve = PeanoCurve(order=5) curve.stretch_to_fit_width(2 * SPACE_WIDTH) curve.stretch_to_fit_height(2 * SPACE_HEIGHT) curve_start = curve.copy() curve_start.apply_over_attr_arrays(lambda arr: arr[:200]) time_line = get_time_line() time_line.shift(-time_line.number_to_point(2000)) self.add(time_line) self.play( ApplyMethod(time_line.shift, -time_line.number_to_point(1900), run_time=3)) brace = Brace( Mobject( Point(time_line.number_to_point(1865)), Point(time_line.number_to_point(1888)), ), UP) words = TextMobject(""" Cantor drives himself (and the \\\\ mathematical community at large) \\\\ crazy with research on infinity. """) words.next_to(brace, UP) self.play(GrowFromCenter(brace), ShimmerIn(words)) self.dither() self.play(Transform(time_line, curve_start), FadeOut(brace), FadeOut(words)) self.play(ShowCreation(curve, run_time=5, rate_func=None)) self.dither()
def show_infinite_objects(self): sigma, summand, equals, result = TexMobject([ "\\sum_{n = 1}^{\\infty}", "\\dfrac{1}{n^2}", "=", "\\dfrac{\pi^2}{6}" ]).split() alt_summand = TexMobject("n").replace(summand) alt_result = TexMobject("-\\dfrac{1}{12}").replace(result) rationals, other_equals, naturals = TexMobject([ "|\\mathds{Q}|", "=", "|\\mathds{N}|" ]).scale(2).split() infinity = TexMobject("\\infty").scale(2) local_mobjects = filter( lambda m : isinstance(m, Mobject), locals().values(), ) for mob in local_mobjects: mob.sort_points(np.linalg.norm) self.play(ShimmerIn(infinity)) self.dither() self.play( ShimmerIn(summand), ShimmerIn(equals), ShimmerIn(result), DelayByOrder(Transform(infinity, sigma)) ) self.dither() self.play( Transform(summand, alt_summand), Transform(result, alt_result), ) self.dither() self.remove(infinity) self.play(*[ CounterclockwiseTransform( Mobject(summand, equals, result, sigma), Mobject(rationals, other_equals, naturals) ) ]) self.dither() self.clear() self.add(self.bubble)
def construct(self): names = [ "Johann_Bernoulli2", "Jacob_Bernoulli", "Gottfried_Wilhelm_von_Leibniz", "Newton" ] guys = [ImageMobject(name, invert=False) for name in names] johann = guys[0] johann.scale(0.8) pensive_johann = johann.copy() pensive_johann.scale(0.25) pensive_johann.to_corner(DOWN + LEFT) comparitive_johann = johann.copy() template = Square(side_length=2) comparitive_johann.replace(template) comparitive_johann.shift(UP + LEFT) greater_than = TexMobject(">") greater_than.next_to(comparitive_johann) for guy, name in zip(guys, names)[1:]: guy.replace(template) guy.next_to(greater_than) name_mob = TextMobject(name.replace("_", " ")) name_mob.scale(0.5) name_mob.next_to(guy, DOWN) guy.name_mob = name_mob guy.sort_points(lambda p: np.dot(p, DOWN + RIGHT)) bubble = ThoughtBubble(initial_width=12) bubble.stretch_to_fit_height(6) bubble.ingest_submobjects() bubble.pin_to(pensive_johann) bubble.shift(DOWN) point = Point(johann.get_corner(UP + RIGHT)) upper_point = Point(comparitive_johann.get_corner(UP + RIGHT)) lightbulb = ImageMobject("Lightbulb", invert=False) lightbulb.scale(0.1) lightbulb.sort_points(np.linalg.norm) lightbulb.next_to(upper_point, RIGHT) self.add(johann) self.wait() self.play(Transform(johann, pensive_johann), Transform(point, bubble), run_time=2) self.remove(point) self.add(bubble) weakling = guys[1] self.play(FadeIn(comparitive_johann), ShowCreation(greater_than), FadeIn(weakling)) self.wait(2) for guy in guys[2:]: self.play(DelayByOrder(Transform(weakling, upper_point))) self.play(FadeIn(guy), ShimmerIn(guy.name_mob)) self.wait(3) self.remove(guy.name_mob) weakling = guy self.play(FadeOut(weakling), FadeOut(greater_than)) self.play(ShowCreation(lightbulb)) self.wait() self.play(FadeOut(comparitive_johann), FadeOut(lightbulb)) self.play(ApplyMethod(Mobject(johann, bubble).scale, 10, run_time=3))
def construct(self): grid = get_grid() grid.sort_points(np.linalg.norm) freq_line = get_freq_line() freq_line.sort_points(lambda p : p[0]) red, blue = Color(RED), Color(BLUE) freq_line.gradient_highlight(red, blue) colors = [ Color(rgb = interpolate( np.array(red.rgb), np.array(blue.rgb), alpha )) for alpha in np.arange(4)/3. ] string = Line(3*LEFT, 3*RIGHT, color = colors[1]) vibration = Vibrate(string) vibration_copy = vibration.copy() vibration_copy.mobject.stroke_width = 1 sub_vibrations = [ Vibrate( string.copy().shift((n-1)*UP).highlight(colors[n]), overtones = 1, spatial_period = 6./(n+1), temporal_period = 1./(n+1), amplitude = 0.5/(n+1) ) for n in range(4) ] words = TexMobject("&\\vdots \\\\ \\text{thousands }& \\text{of frequencies} \\\\ &\\vdots") words.to_edge(UP, buff = 0.1) self.add(grid) self.dither() self.play(DelayByOrder(ApplyMethod( grid.gradient_highlight, red, blue ))) self.play(Transform(grid, freq_line)) self.dither() self.play( ShimmerIn( words, rate_func = squish_rate_func(smooth, 0, 0.2) ), *sub_vibrations, run_time = 5 ) self.play( *[ TransformAnimations( sub_vib, vibration ) for sub_vib in sub_vibrations ]+[FadeOut(words)] ) self.clear() self.add(freq_line) self.play(vibration)
def construct(self): text = TextMobject(""" See links in the description for more on sight via sound. """) self.play(ShimmerIn(text)) self.play(ShowCreation(Arrow(text, 3*DOWN))) self.dither(2)
def label_jump(self): jump_points = Mobject(Point(self.spiril1.points[-1]), Point(self.spiril2.points[0])) self.brace = Brace(jump_points, RIGHT) self.jump = TextMobject("Jump") self.jump.next_to(self.brace, RIGHT) self.play(GrowFromCenter(self.brace), ShimmerIn(self.jump)) self.dither() self.remove(self.brace, self.jump)
def construct(self): curve = HilbertCurve(order=1) words = TextMobject("``Hilbert Curve''") words.to_edge(UP, buff=0.2) self.play(ShimmerIn(words), Transform(curve, HilbertCurve(order=2)), run_time=2) for n in range(3, 8): self.play(Transform(curve, HilbertCurve(order=n)), run_time=5. / n)
def construct(self): val = 0.7 text = TexMobject([ "\\text{HC}(", "x", ")", "=\\lim_{n \\to \\infty}\\text{PHC}_n(", "x", ")" ]) text.to_edge(UP) x1 = text.split()[1] x2 = text.split()[-2] x2.highlight(BLUE) explanation = TextMobject("Actual Hilbert curve function") exp_arrow = Arrow(explanation, text.split()[0]) curve = UnitInterval() dot = Dot(curve.number_to_point(val)) x_arrow = Arrow(x1.get_bottom(), dot, buff = 0) curve.sort_points(lambda p : p[0]) curve.add_numbers(0, 1) self.add(*text.split()[:3]) self.play( ShimmerIn(explanation), ShowCreation(exp_arrow) ) self.wait() self.remove(explanation, exp_arrow) self.play(ShowCreation(curve)) self.play( ApplyMethod(x1.highlight, BLUE), ShowCreation(x_arrow), ShowCreation(dot) ) self.wait() self.remove(x_arrow) limit = Mobject(*text.split()[3:]).ingest_submobjects() limit.stroke_width = 1 self.play(ShimmerIn(limit)) for num in range(1, 9): new_curve = HilbertCurve(order = num) new_curve.scale(0.8) new_dot = Dot(new_curve.points[int(val*new_curve.get_num_points())]) self.play( Transform(curve, new_curve), Transform(dot, new_dot), )
def draw_circles(self): input_value = 0.45 input_radius = 0.04 for dot in self.input_dot, self.output_dot: dot.center() kwargs = { "rate_func" : lambda t : interpolate(1, input_value, smooth(t)) } self.play( Homotopy(self.input_homotopy, self.input_dot, **kwargs), Homotopy(self.output_homotopy, self.output_dot, **kwargs) ) A, B = map(Mobject.get_center, [self.input_dot, self.output_dot]) A_text = TextMobject("A") A_text.shift(A+2*(LEFT+UP)) A_arrow = Arrow( A_text, self.input_dot, color = self.input_color ) B_text = TextMobject("B") B_text.shift(B+2*RIGHT+DOWN) B_arrow = Arrow( B_text, self.output_dot, color = self.output_color ) tup = self.get_circles_and_points( input_value-input_radius, input_value+input_radius ) input_circle, input_points, output_circle, output_points = tup for text, arrow in [(A_text, A_arrow), (B_text, B_arrow)]: self.play( ShimmerIn(text), ShowCreation(arrow) ) self.wait() self.remove(A_text, A_arrow, B_text, B_arrow) self.play(ShowCreation(input_circle)) self.wait() self.play(ShowCreation(input_points)) self.wait() input_points_copy = input_points.copy() self.play( Transform(input_points_copy, output_points), run_time = 2 ) self.wait() self.play(ShowCreation(output_circle)) self.wait() self.wait() self.remove(*[ input_circle, input_points, output_circle, input_points_copy ])
def construct(self): words1 = TextMobject( "If you watched my video about Hilbert's space-filling curve\\dots" ) words2 = TextMobject( "\\dots you might be curious to see what a few other space-filling curves look like." ) words2.scale(0.8) for words in words1, words2: words.to_edge(UP, buff=0.2) self.setup(HilbertCurve) self.play(ShimmerIn(words1)) for x in range(4): self.increase_order() self.remove(words1) self.increase_order(ShimmerIn(words2)) for x in range(4): self.increase_order()
def construct(self): time_line = get_time_line() time_line.shift(-time_line.number_to_point(1900)) hilbert_curve = HilbertCurve(order = 3) peano_curve = PeanoCurve(order = 2) for curve in hilbert_curve, peano_curve: curve.scale(0.5) hilbert_curve.to_corner(DOWN+RIGHT) peano_curve.to_corner(UP+LEFT) squares = Mobject(*[ Square(side_length=3, color=WHITE).replace(curve) for curve in hilbert_curve, peano_curve ]) self.add(time_line) self.wait() for year, curve, vect, text in [ (1890, peano_curve, UP, "Peano Curve"), (1891, hilbert_curve, DOWN, "Hilbert Curve"), ]: point = time_line.number_to_point(year) point[1] = 0.2 arrow = Arrow(point+2*vect, point, buff = 0.1) arrow.gradient_highlight(curve.start_color, curve.end_color) year_mob = TexMobject(str(year)) year_mob.next_to(arrow, vect) words = TextMobject(text) words.next_to(year_mob, vect) self.play( ShowCreation(arrow), ShimmerIn(year_mob), ShimmerIn(words) ) self.play(ShowCreation(curve)) self.wait() self.play(ShowCreation(squares)) self.wait() self.play(ApplyMethod( Mobject(*self.mobjects).shift, 20*(DOWN+RIGHT) ))
def pose_question(self): infinity, rightarrow, N = TexMobject(["\\infty", "\\rightarrow", "N"]).scale(2).split() question_mark = TextMobject("?").scale(2) self.add(question_mark) self.dither() self.play(*[ShimmerIn(mob) for mob in infinity, rightarrow, N] + [ ApplyMethod(question_mark.next_to, rightarrow, UP), ]) self.dither()
def construct(self): grid = Grid(16, 16).fade() snake_curve = SnakeCurve(order=4) words = TextMobject("``Snake Curve''") words.next_to(grid, UP) self.add(grid) self.play(ShowCreation(snake_curve, run_time=7, rate_func=None)) self.dither() self.play(ShimmerIn(words)) self.dither()
def construct(self): val = 0.3 text = TextMobject([ "PHC", "$_n", "(", "%3.1f"%val, ")$", " has a ", "limit point ", "as $n \\to \\infty$" ]) func_parts = text.copy().split()[:5] Mobject(*func_parts).center().to_edge(UP) num_str, val_str = func_parts[1], func_parts[3] curve = UnitInterval() curve.sort_points(lambda p : p[0]) dot = Dot().shift(curve.number_to_point(val)) arrow = Arrow(val_str, dot, buff = 0.1) curve.add_numbers(0, 1) self.play(ShowCreation(curve)) self.play( ShimmerIn(val_str), ShowCreation(arrow), ShowCreation(dot) ) self.wait() self.play( FadeOut(arrow), *[ FadeIn(func_parts[i]) for i in 0, 1, 2, 4 ] ) for num in range(2,9): new_curve = HilbertCurve(order = num) new_curve.scale(0.8) new_dot = Dot(new_curve.points[int(val*new_curve.get_num_points())]) new_num_str = TexMobject(str(num)).replace(num_str) self.play( Transform(curve, new_curve), Transform(dot, new_dot), Transform(num_str, new_num_str) ) self.wait() text.to_edge(UP) text_parts = text.split() for index in 1, -1: text_parts[index].highlight() starters = Mobject(*func_parts + [ Point(mob.get_center(), stroke_width=1) for mob in text_parts[5:] ]) self.play(Transform(starters, text)) arrow = Arrow(text_parts[-2].get_bottom(), dot, buff = 0.1) self.play(ShowCreation(arrow)) self.wait()
def construct(self): freq_line = get_freq_line() self.add(freq_line) self.dither() for tex, vect in zip(["20 Hz", "20{,}000 Hz"], [LEFT, RIGHT]): tex_mob = TextMobject(tex) tex_mob.to_edge(vect) tex_mob.shift(UP) arrow = Arrow(tex_mob, freq_line.get_edge_center(vect)) self.play(ShimmerIn(tex_mob), ShowCreation(arrow)) self.dither()