def show_geometry(self, slider, vector):
point_a = self.point_a.get_center()
horiz_line = Line(point_a, point_a + 6*RIGHT)
ceil_point = point_a
ceil_point[0] = slider.get_center()[0]
vert_brace = Brace(
Mobject(Point(ceil_point), Point(slider.get_center())),
RIGHT,
buff = 0.5
)
vect_brace = Brace(slider)
vect_brace.stretch_to_fit_width(vector.get_length())
vect_brace.rotate(np.arctan(vector.get_slope()))
vect_brace.center().shift(vector.get_center())
nudge = 0.2*(DOWN+LEFT)
vect_brace.shift(nudge)
y_mob = TexMobject("y")
y_mob.next_to(vert_brace)
sqrt_y = TexMobject("k\\sqrt{y}")
sqrt_y.scale(0.5)
sqrt_y.shift(vect_brace.get_center())
sqrt_y.shift(3*nudge)
self.play(ShowCreation(horiz_line))
self.play(
GrowFromCenter(vert_brace),
ShimmerIn(y_mob)
)
self.play(
GrowFromCenter(vect_brace),
ShimmerIn(sqrt_y)
)
self.dither(3)
self.solve_energy()
def construct(self):
left, right = 5*LEFT, 5*RIGHT
top_words = TextMobject("The next 15 minutes of your life:")
top_words.to_edge(UP)
line = Line(left, right, color = BLUE_D)
for a in np.arange(0, 4./3, 1./3):
vect = interpolate(left, right, a)
line.add_line(vect+0.2*DOWN, vect+0.2*UP)
left_brace = Brace(
Mobject(
Point(left),
Point(interpolate(left, right, 2./3))
),
DOWN
)
right_brace = Brace(
Mobject(
Point(interpolate(left, right, 2./3)),
Point(right)
),
UP
)
left_brace.words = map(TextMobject, [
"Problem statement",
"History",
"Johann Bernoulli's cleverness"
])
curr = left_brace
right_brace.words = map(TextMobject, [
"Challenge",
"Mark Levi's cleverness",
])
for brace in left_brace, right_brace:
curr = brace
direction = DOWN if brace is left_brace else UP
for word in brace.words:
word.next_to(curr, direction)
curr = word
right_brace.words.reverse()
self.play(ShimmerIn(top_words))
self.play(ShowCreation(line))
for brace in left_brace, right_brace:
self.play(GrowFromCenter(brace))
self.dither()
for word in brace.words:
self.play(ShimmerIn(word))
self.dither()
def construct(self):
image = ImageMobject("lion", invert = False)
image.scale(0.5)
image.shift(2*LEFT)
self.add(image)
for vect, num in zip([DOWN, RIGHT], [1, 2]):
brace = Brace(image, vect)
words_mob = TextMobject("Dimension %d"%num)
words_mob.next_to(image, vect, buff = 1)
self.play(
Transform(Point(brace.get_center()), brace),
ShimmerIn(words_mob),
run_time = 2
)
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 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 rearrange(self):
sqrt_nudge = 0.2*LEFT
y, equals = self.y_equals.split()
d, sin, squared, theta = self.y_expression.split()
y_sqrt = TexMobject("\\sqrt{\\phantom{y}}")
d_sqrt = y_sqrt.copy()
y_sqrt.shift(y.get_center()+sqrt_nudge)
d_sqrt.shift(d.get_center()+sqrt_nudge)
self.play(
ShimmerIn(y_sqrt),
ShimmerIn(d_sqrt),
ApplyMethod(squared.shift, 4*UP),
ApplyMethod(theta.shift, 1.5* squared.get_width()*LEFT)
)
self.wait()
y_sqrt.add(y)
d_sqrt.add(d)
sin.add(theta)
sin_over = TexMobject("\\dfrac{\\phantom{\\sin(\\theta)}}{\\quad}")
sin_over.next_to(sin, DOWN, 0.15)
new_eq = equals.copy()
new_eq.next_to(sin_over, LEFT)
one_over = TexMobject("\\dfrac{1}{\\quad}")
one_over.next_to(new_eq, LEFT)
one_over.shift(
(sin_over.get_bottom()[1]-one_over.get_bottom()[1])*UP
)
self.play(
Transform(equals, new_eq),
ShimmerIn(sin_over),
ShimmerIn(one_over),
ApplyMethod(
d_sqrt.next_to, one_over, DOWN,
path_func = path_along_arc(-np.pi)
),
ApplyMethod(
y_sqrt.next_to, sin_over, DOWN,
path_func = path_along_arc(-np.pi)
),
run_time = 2
)
self.wait()
brace = Brace(d_sqrt, DOWN)
constant = TextMobject("Constant")
constant.next_to(brace, DOWN)
self.play(
GrowFromCenter(brace),
ShimmerIn(constant)
)
class BraceLabel(VMobject):
CONFIG = {
"label_constructor": TexMobject,
"label_scale": 1,
}
def __init__(self, obj, text, brace_direction=DOWN, **kwargs):
VMobject.__init__(self, **kwargs)
self.brace_direction = brace_direction
if isinstance(obj, list): obj = VMobject(*obj)
self.brace = Brace(obj, brace_direction, **kwargs)
if isinstance(text, tuple) or isinstance(text, list):
self.label = self.label_constructor(*text, **kwargs)
else:
self.label = self.label_constructor(str(text))
if self.label_scale != 1: self.label.scale(self.label_scale)
self.brace.put_at_tip(self.label)
self.submobjects = [self.brace, self.label]
def creation_anim(self, label_anim=FadeIn, brace_anim=GrowFromCenter):
return AnimationGroup(brace_anim(self.brace), label_anim(self.label))
def shift_brace(self, obj, **kwargs):
if isinstance(obj, list): obj = VMobject(*obj)
self.brace = Brace(obj, self.brace_direction, **kwargs)
self.brace.put_at_tip(self.label)
self.submobjects[0] = self.brace
return self
def change_label(self, *text, **kwargs):
self.label = self.label_constructor(*text, **kwargs)
if self.label_scale != 1: self.label.scale(self.label_scale)
self.brace.put_at_tip(self.label)
self.submobjects[1] = self.label
return self
def change_brace_label(self, obj, *text):
self.shift_brace(obj)
self.change_label(*text)
return self
def copy(self):
copy_mobject = copy.copy(self)
copy_mobject.brace = self.brace.copy()
copy_mobject.label = self.label.copy()
copy_mobject.submobjects = [copy_mobject.brace, copy_mobject.label]
return copy_mobject
def construct(self):
self.add_layers()
v_equations = []
start_ys = []
end_ys = []
center_paths = []
braces = []
for layer, x in zip(self.layers[:3], it.count(1)):
eq_mob = TexMobject(
["v_%d"%x, "=", "\sqrt{\phantom{y_1}}"],
size = "\\Large"
)
eq_mob.shift(layer.get_center()+2*LEFT)
v_eq = eq_mob.split()
v_eq[0].highlight(layer.get_color())
path = Line(SPACE_WIDTH*LEFT, SPACE_WIDTH*RIGHT)
path.shift(layer.get_center())
brace_endpoints = Mobject(
Point(self.top),
Point(layer.get_bottom())
)
brace = Brace(brace_endpoints, RIGHT)
brace.shift(x*RIGHT)
start_y = TexMobject("y_%d"%x, size = "\\Large")
end_y = start_y.copy()
start_y.next_to(brace, RIGHT)
end_y.shift(v_eq[-1].get_center())
nudge = 0.2*RIGHT
end_y.shift(nudge)
v_equations.append(v_eq)
start_ys.append(start_y)
end_ys.append(end_y)
center_paths.append(path)
braces.append(brace)
for v_eq, path, time in zip(v_equations, center_paths, [2, 1, 0.5]):
photon_run = self.photon_run_along_path(
path,
rate_func = None
)
self.play(
FadeToColor(v_eq[0], WHITE),
photon_run,
run_time = time
)
self.dither()
starts = [0, 0.3, 0.6]
self.play(*it.chain(*[
[
GrowFromCenter(
mob,
rate_func=squish_rate_func(smooth, start, 1)
)
for mob, start in zip(mobs, starts)
]
for mobs in start_ys, braces
]))
self.dither()
triplets = zip(v_equations, start_ys, end_ys)
anims = []
for v_eq, start_y, end_y in triplets:
anims += [
ShowCreation(v_eq[1]),
ShowCreation(v_eq[2]),
Transform(start_y.copy(), end_y)
]
self.play(*anims)
self.dither()
