def generate_points(self):
self.main_line = Line(self.x_min * RIGHT, self.x_max * RIGHT)
self.tick_marks = VGroup()
self.add(self.main_line, self.tick_marks)
rounding_value = int(-np.log10(0.1 * self.tick_frequency))
rounded_numbers_with_elongated_ticks = np.round(
self.numbers_with_elongated_ticks, rounding_value)
for x in self.get_tick_numbers():
rounded_x = np.round(x, rounding_value)
if rounded_x in rounded_numbers_with_elongated_ticks:
tick_size_used = self.longer_tick_multiple * self.tick_size
else:
tick_size_used = self.tick_size
self.add_tick(x, tick_size_used)
self.stretch(self.unit_size, 0)
self.shift(-self.number_to_point(self.number_at_center))
def get_number_design(self, value, symbol):
num = int(value)
n_rows = {
2: 2,
3: 3,
4: 2,
5: 2,
6: 3,
7: 3,
8: 3,
9: 4,
10: 4,
}[num]
n_cols = 1 if num in [2, 3] else 2
insertion_indices = {
5: [0],
7: [0],
8: [0, 1],
9: [1],
10: [0, 2],
}.get(num, [])
top = self.get_top() + symbol.get_height() * DOWN
bottom = self.get_bottom() + symbol.get_height() * UP
column_points = [
interpolate(top, bottom, alpha)
for alpha in np.linspace(0, 1, n_rows)
]
design = VGroup(
*[symbol.copy().move_to(point) for point in column_points])
if n_cols == 2:
space = 0.2 * self.get_width()
column_copy = design.copy().shift(space * RIGHT)
design.shift(space * LEFT)
design.add(*column_copy)
design.add(*[
symbol.copy().move_to(center_of_mass(column_points[i:i + 2]))
for i in insertion_indices
])
for symbol in design:
if symbol.get_center()[1] < self.get_center()[1]:
symbol.rotate_in_place(np.pi)
return design
def __init__(self, matrix, **kwargs):
"""
Matrix can either either include numbres, tex_strings,
or mobjects
"""
VMobject.__init__(self, **kwargs)
matrix = np.array(matrix, ndmin=1)
mob_matrix = self.matrix_to_mob_matrix(matrix)
self.organize_mob_matrix(mob_matrix)
self.elements = VGroup(*mob_matrix.flatten())
self.add(self.elements)
self.add_brackets()
self.center()
self.mob_matrix = mob_matrix
if self.add_background_rectangles_to_entries:
for mob in self.elements:
mob.add_background_rectangle()
if self.include_background_rectangle:
self.add_background_rectangle()
def setup(self):
pos_axis = NumberLine(x_min=-4.5, x_max=2.5, color=WHITE)
pos_axis.rotate(np.pi / 2)
pos_axis.add_tip()
time_axis = NumberLine(x_min=0, x_max=9.5, color=WHITE)
time_axis.add_tip()
vec = pos_axis.number_to_point(0) - time_axis.number_to_point(0)
time_axis.shift(vec)
pos_text = TextMobject("位置")
pos_text.next_to(pos_axis.number_to_point(2.5), LEFT)
time_text = TextMobject("时间")
time_text.next_to(time_axis.number_to_point(9.5), DOWN)
axes_group = VGroup(pos_axis, time_axis, pos_text, time_text)
axes_group.center()
title_pq = TexMobject("P_4", "570", "Q_4")
title_pq.scale(1.5)
title_pq.to_corner(UP + RIGHT)
for part, color in zip(title_pq, [ORANGE, BLACK, GREEN]):
part.set_color(color)
r_arrow = TexMobject("\\rightarrow")
l_arrow = TexMobject("\\leftarrow")
for arrow in (r_arrow, l_arrow):
arrow.scale(1.5)
arrow.move_to(title_pq[1])
sequence_p, sequence_q = sequences = ["UDUUDUDD", "DDUDDUDD"]
colors = [ORANGE, GREEN]
walk_p, walk_q = walks = [
RandomWalk1DArrow(sequence, up_color = color, down_color = color) \
.move_start_to(pos_axis.number_to_point(0))
for sequence, color in zip(sequences, colors)
]
parts_p, parts_q = [walk.split_at(3) for walk in walks]
self.axes_group = axes_group
self.title_pq = title_pq
self.walk_p = walk_p
self.walk_q = walk_q
self.parts_p = parts_p
self.parts_q = parts_q
self.r_arrow = r_arrow
self.l_arrow = l_arrow
def setup_in_uv_space(self):
res = tuplify(self.resolution)
if len(res) == 1:
u_res = v_res = res[0]
else:
u_res, v_res = res
u_min = self.u_min
u_max = self.u_max
v_min = self.v_min
v_max = self.v_max
u_values = np.linspace(u_min, u_max, u_res + 1)
v_values = np.linspace(v_min, v_max, v_res + 1)
faces = VGroup()
for i in range(u_res):
for j in range(v_res):
u1, u2 = u_values[i:i + 2]
v1, v2 = v_values[j:j + 2]
face = ThreeDVMobject()
face.set_points_as_corners([
[u1, v1, 0],
[u2, v1, 0],
[u2, v2, 0],
[u1, v2, 0],
[u1, v1, 0],
])
faces.add(face)
face.u_index = i
face.v_index = j
face.u1 = u1
face.u2 = u2
face.v1 = v1
face.v2 = v2
faces.set_fill(color=self.fill_color, opacity=self.fill_opacity)
faces.set_stroke(
color=self.stroke_color,
width=self.stroke_width,
opacity=self.stroke_opacity,
)
self.add(*faces)
if self.checkerboard_colors:
self.set_fill_by_checkerboard(*self.checkerboard_colors)
def get_coordinate_labels(self, x_vals=None, y_vals=None):
coordinate_labels = VGroup()
if x_vals is None:
x_vals = list(range(-int(self.x_radius), int(self.x_radius) + 1))
if y_vals is None:
y_vals = list(range(-int(self.y_radius), int(self.y_radius) + 1))
for index, vals in enumerate([x_vals, y_vals]):
num_pair = [0, 0]
for val in vals:
if val == 0:
continue
num_pair[index] = val
point = self.coords_to_point(*num_pair)
num = TexMobject(str(val))
num.add_background_rectangle()
num.set_height(self.written_coordinate_height)
num.next_to(point, DOWN + LEFT, buff=SMALL_BUFF)
coordinate_labels.add(num)
self.coordinate_labels = coordinate_labels
return coordinate_labels
def add_T_label(self, x_val, color=WHITE, animated=False, **kwargs):
triangle = RegularPolygon(n=3, start_angle=np.pi / 2)
triangle.scale_to_fit_height(MED_SMALL_BUFF)
triangle.move_to(self.coords_to_point(x_val, 0), UP)
triangle.set_fill(color, 1)
triangle.set_stroke(width=0)
T_label = TexMobject(self.variable_point_label, fill_color=color)
T_label.next_to(triangle, DOWN)
v_line = self.get_vertical_line_to_graph(x_val,
self.v_graph,
color=YELLOW)
if animated:
self.play(DrawBorderThenFill(triangle), ShowCreation(v_line),
Write(T_label, run_time=1), **kwargs)
else:
self.add(triangle, v_line, T_label)
self.T_label_group = VGroup(T_label, triangle)
self.right_v_line = v_line
def get_face_card_design(self, value, symbol):
from for_3b1b_videos.pi_creature import PiCreature
sub_rect = Rectangle(
stroke_color = BLACK,
fill_opacity = 0,
height = 0.9*self.get_height(),
width = 0.6*self.get_width(),
)
sub_rect.move_to(self)
# pi_color = average_color(symbol.get_color(), GREY)
pi_color = symbol.get_color()
pi_mode = {
"J" : "plain",
"Q" : "thinking",
"K" : "hooray"
}[value]
pi_creature = PiCreature(
mode = pi_mode,
color = pi_color,
)
pi_creature.scale_to_fit_width(0.8*sub_rect.get_width())
if value in ["Q", "K"]:
prefix = "king" if value == "K" else "queen"
crown = SVGMobject(file_name = prefix + "_crown")
crown.set_stroke(width = 0)
crown.set_fill(YELLOW, 1)
crown.stretch_to_fit_width(0.5*sub_rect.get_width())
crown.stretch_to_fit_height(0.17*sub_rect.get_height())
crown.move_to(pi_creature.eyes.get_center(), DOWN)
pi_creature.add_to_back(crown)
to_top_buff = 0
else:
to_top_buff = SMALL_BUFF*sub_rect.get_height()
pi_creature.next_to(sub_rect.get_top(), DOWN, to_top_buff)
# pi_creature.shift(0.05*sub_rect.get_width()*RIGHT)
pi_copy = pi_creature.copy()
pi_copy.rotate(np.pi, about_point = sub_rect.get_center())
return VGroup(sub_rect, pi_creature, pi_copy)
def get_mobjects_from(self, element, fill_color=None):
result = []
if not isinstance(element, minidom.Element):
return result
if element.tagName == 'defs':
self.update_ref_to_element(element)
elif element.tagName == 'style':
pass # TODO, handle style
elif element.tagName in ['g', 'svg']:
if element.hasAttribute("fill"):
fill_color = element.getAttribute("fill")
result += it.chain(*[
self.get_mobjects_from(child, fill_color=fill_color)
for child in element.childNodes
])
elif element.tagName == 'path':
result.append(self.path_string_to_mobject(
element.getAttribute('d'),
fill_color=fill_color,
))
elif element.tagName == 'use':
result += self.use_to_mobjects(element, fill_color=fill_color)
elif element.tagName == 'rect':
result.append(self.rect_to_mobject(element))
elif element.tagName == 'circle':
result.append(self.circle_to_mobject(element))
elif element.tagName == 'ellipse':
result.append(self.ellipse_to_mobject(element))
elif element.tagName in ['polygon', 'polyline']:
result.append(self.polygon_to_mobject(element))
else:
pass # TODO
# warnings.warn("Unknown element type: " + element.tagName)
result = [m for m in result if m is not None]
self.handle_transforms(element, VMobject(*result))
if len(result) > 1 and not self.unpack_groups:
result = [VGroup(*result)]
return result
def generate_points(self):
self.add(Rectangle(
height = self.height,
width = self.height/self.height_to_width,
stroke_color = WHITE,
stroke_width = 2,
fill_color = self.color,
fill_opacity = 1,
))
if self.turned_over:
self.set_fill(DARK_GREY)
self.set_stroke(LIGHT_GREY)
contents = VectorizedPoint(self.get_center())
else:
value = self.get_value()
symbol = self.get_symbol()
design = self.get_design(value, symbol)
corner_numbers = self.get_corner_numbers(value, symbol)
contents = VGroup(design, corner_numbers)
self.design = design
self.corner_numbers = corner_numbers
self.add(contents)
def add_iris_back(self):
blue_iris_back = AnnularSector(
inner_radius=self.pupil_radius,
outer_radius=self.outer_radius,
angle=270 * DEGREES,
start_angle=180 * DEGREES,
fill_color=self.iris_background_blue,
fill_opacity=1,
stroke_width=0,
)
brown_iris_back = AnnularSector(
inner_radius=self.pupil_radius,
outer_radius=self.outer_radius,
angle=90 * DEGREES,
start_angle=90 * DEGREES,
fill_color=self.iris_background_brown,
fill_opacity=1,
stroke_width=0,
)
self.iris_background = VGroup(
blue_iris_back,
brown_iris_back,
)
self.add(self.iris_background)
def generate_points(self):
self.ring = Annulus(inner_radius=self.inner_radius,
outer_radius=self.outer_radius,
fill_color=self.color)
self.symbol = self.generate_symbol()
self.add(VGroup(self.ring, self.symbol))
def create_pi_creatures(self):
"""
Likely updated for subclasses
"""
return VGroup(self.create_pi_creature())
def get_lights(self):
return VGroup(self.get_front_light(), self.get_rear_light())
def split_at(self, n):
if n < 0:
return VGroup(), self.arrow_group
else:
return VGroup(self.arrow_group[:n + 1]), VGroup(
self.arrow_group[n + 1:])
def get_entries(self):
return VGroup(*self.get_mob_matrix().flatten())
def setup_axes(self, animate=False):
# TODO, once eoc is done, refactor this to be less redundant.
x_num_range = float(self.x_max - self.x_min)
self.space_unit_to_x = self.x_axis_width / x_num_range
if self.x_labeled_nums is None:
self.x_labeled_nums = []
if self.x_leftmost_tick is None:
self.x_leftmost_tick = self.x_min
x_axis = NumberLine(x_min=self.x_min,
x_max=self.x_max,
unit_size=self.space_unit_to_x,
tick_frequency=self.x_tick_frequency,
leftmost_tick=self.x_leftmost_tick,
numbers_with_elongated_ticks=self.x_labeled_nums,
color=self.axes_color)
x_axis.shift(self.graph_origin - x_axis.number_to_point(0))
if len(self.x_labeled_nums) > 0:
if self.exclude_zero_label:
self.x_labeled_nums = filter(lambda x: x != 0,
self.x_labeled_nums)
x_axis.add_numbers(*self.x_labeled_nums)
if self.x_axis_label:
x_label = TextMobject(self.x_axis_label)
x_label.next_to(x_axis.get_tick_marks(),
UP + RIGHT,
buff=SMALL_BUFF)
x_label.shift_onto_screen()
x_axis.add(x_label)
self.x_axis_label_mob = x_label
y_num_range = float(self.y_max - self.y_min)
self.space_unit_to_y = self.y_axis_height / y_num_range
if self.y_labeled_nums is None:
self.y_labeled_nums = []
if self.y_bottom_tick is None:
self.y_bottom_tick = self.y_min
y_axis = NumberLine(
x_min=self.y_min,
x_max=self.y_max,
unit_size=self.space_unit_to_y,
tick_frequency=self.y_tick_frequency,
leftmost_tick=self.y_bottom_tick,
numbers_with_elongated_ticks=self.y_labeled_nums,
color=self.axes_color,
line_to_number_vect=LEFT,
)
y_axis.shift(self.graph_origin - y_axis.number_to_point(0))
y_axis.rotate(np.pi / 2, about_point=y_axis.number_to_point(0))
if len(self.y_labeled_nums) > 0:
if self.exclude_zero_label:
self.y_labeled_nums = filter(lambda y: y != 0,
self.y_labeled_nums)
y_axis.add_numbers(*self.y_labeled_nums)
if self.y_axis_label:
y_label = TextMobject(self.y_axis_label)
y_label.next_to(y_axis.get_tick_marks(),
UP + RIGHT,
buff=SMALL_BUFF)
y_label.shift_onto_screen()
y_axis.add(y_label)
self.y_axis_label_mob = y_label
if animate:
self.play(Write(VGroup(x_axis, y_axis)))
else:
self.add(x_axis, y_axis)
self.x_axis, self.y_axis = self.axes = VGroup(x_axis, y_axis)
self.default_graph_colors = it.cycle(self.default_graph_colors)
def construct(self):
colors = ["#FF0000", "#FF8000", "#FFFF00", "#00FF00", "#0080FF"]
wallis_rects_4 = WallisRectangles(
order=5,
rect_colors=colors,
)
vert_lines = VGroup(*[
Line(3.5*UP, 3.5*DOWN, color = GREY, stroke_width = 3) \
.next_to(wallis_rects_4.get_rectangle(0, k), direction, buff = 0)
for k, direction in zip(list(range(5))+[4], [LEFT]*5+[RIGHT])
])
horiz_lines = VGroup(*[
Line(3.5*LEFT, 3.5*RIGHT, color = GREY, stroke_width = 3) \
.next_to(wallis_rects_4.get_rectangle(k, 0), direction, buff = 0)
for k, direction in zip(list(range(5))+[4], [DOWN]*5+[UP])
])
for vert_line in vert_lines:
vert_line.vertically_center()
for horiz_line in horiz_lines:
horiz_line.horizontally_center()
vert_labels = VGroup(*[
TexMobject("a_%d" % k) \
.move_to((vert_lines[k].get_center() + vert_lines[k+1].get_center())/2) \
.shift(3.5*DOWN)
for k in range(5)
])
horiz_labels = VGroup(*[
TexMobject("a_%d" % k) \
.move_to((horiz_lines[k].get_center() + horiz_lines[k+1].get_center())/2) \
.shift(3.5*LEFT)
for k in range(5)
])
area_texs = VGroup()
factors = [1.25, 1, 0.9, 0.7, 0.6]
for p in range(5):
for q in range(5 - p):
rect = wallis_rects_4.get_rectangle(p, q)
tex = TexMobject("{a_%d} {a_%d}" % (q, p))
tex.scale(factors[p + q])
tex.move_to(rect)
area_texs.add(tex)
figure = VGroup()
figure.add(wallis_rects_4, vert_lines, horiz_lines, vert_labels,
horiz_labels, area_texs)
figure.to_edge(LEFT)
self.add(figure)
tex_list = VGroup()
for p in range(5):
formula_string = (
" + ".join(["a_%d a_%d" % (q, p - q)
for q in range(p + 1)]) + "=1")
formula = TexMobject(formula_string)
tex_list.add(formula)
# tex_list.add(TexMobject("\\vdots"))
tex_factors = np.linspace(1, 0.7, 5)
for tex, color, factor in zip(tex_list, colors, tex_factors):
tex.set_color(color)
tex.scale(factor)
tex_list.arrange_submobjects(DOWN, aligned_edge=LEFT)
tex_list.to_edge(RIGHT)
self.add(tex_list)
self.wait()
def construct(self):
# Setup
axes_group = self.axes_group
title_pq = self.title_pq
walk_p = self.walk_p
parts_p = self.parts_p
r_arrow = self.r_arrow
self.add(axes_group, title_pq, walk_p, r_arrow)
walk_p_copy = walk_p.copy()
# P_4 -> Q_4
steps_pq = VGroup(*[
TextMobject(text) for text in [
"1. 第一步是沿着正方向走的", "2. 找到第一次到达最大值的时刻", "3. 在这个时刻上进行分割",
"4. 将第一段水平翻转", "5. 拼接两个片段"
]
])
for step in steps_pq:
step.set_color(YELLOW)
step.add_background_rectangle()
step1_pq, step2_pq, step3_pq, step4_pq, step5_pq = steps_pq
# 1. Check the first step of the walk
step1_circle = Circle(color=YELLOW)
first_arrow = walk_p.get_arrow_by_number(0)
step1_circle.surround(first_arrow)
step1_pq.next_to(step1_circle, RIGHT + DOWN)
self.play(ShowCreation(step1_circle), Write(step1_pq), run_time=1)
self.wait(1.5)
self.play(FadeOut(step1_circle), FadeOut(step1_pq))
# 2. Find the first time it reaches the maximum
peak = walk_p.get_arrow_end_point(3)
horiz_line = DashedLine(2.5 * LEFT, 2.5 * RIGHT, color=YELLOW)
horiz_line.move_to(peak)
dot = Dot(color=YELLOW)
dot.move_to(peak)
step2_pq.next_to(horiz_line, UP)
self.play(ShowCreation(horiz_line),
DrawBorderThenFill(dot),
Write(step2_pq),
run_time=1)
self.wait(1.5)
self.play(FadeOut(horiz_line), FadeOut(step2_pq))
# 3. Split
vert_line = DashedLine(2.5 * UP, 2.5 * DOWN, color=YELLOW)
vert_line.move_to(peak)
step3_pq.next_to(vert_line, DOWN)
left_part_p, right_part_p = parts_p
self.play(ShowCreation(vert_line), Write(step3_pq), run_time=1)
self.play(
FadeOut(dot),
left_part_p.shift,
0.5 * DOWN + 0.5 * LEFT,
right_part_p.shift,
DOWN + 0.5 * RIGHT,
)
self.wait(1.5)
self.play(FadeOut(vert_line), FadeOut(step3_pq))
# 4. Flip the first segment horizontally
flip_axis = DashedLine(2 * UP, 2 * DOWN, color=GREY)
flip_axis.move_to(left_part_p)
step4_pq.next_to(flip_axis, DOWN)
self.play(
ShowCreation(flip_axis),
Write(step4_pq),
run_time=1,
)
self.play(
left_part_p.flip,
Animation(flip_axis),
)
self.wait(1.5)
self.play(FadeOut(step4_pq), FadeOut(flip_axis))
# 5. Put the pieces together
step5_pq.move_to(dot)
flip_arrow_anims = walk_p.get_flip_arrows_animation(3, color=GREEN)
self.play(Write(step5_pq), run_time=1)
self.wait(0.5)
self.play(flip_arrow_anims, right_part_p.set_color, GREEN)
self.wait(0.5)
self.play(
left_part_p.shift,
1.5 * DOWN + 0.5 * RIGHT,
right_part_p.shift,
3 * DOWN + 0.5 * LEFT,
Animation(step5_pq),
)
self.wait(0.5)
self.play(FadeOut(step5_pq))
self.wait(1.5)
# Now Reset
self.play(FadeOut(walk_p))
self.play(FadeIn(walk_p_copy))
self.wait()
def get_on_screen_pi_creatures(self):
mobjects = self.get_mobjects()
return VGroup(
*filter(lambda pi: pi in mobjects, self.get_pi_creatures()))
def construct(self):
# Chart on the left
colors = [WHITE, ORANGE, GREEN]
titles = VGroup(*[
TexMobject(text).set_color(color)
for text, color in zip(["n", "p_n", "q_n"], colors)
])
contents = VGroup(*[
VGroup(*[
TexMobject("%d" % num) for num in
[k, central_binomial_coeff(k),
central_binomial_coeff(k)]
]) for k in range(8)
])
titles.arrange_submobjects(RIGHT, buff=1)
for num, line in enumerate(contents):
for k, element in enumerate(line):
buff = 0.6 + 0.8 * num
element.next_to(titles[k], DOWN, aligned_edge=LEFT, buff=buff)
element.set_color(colors[k])
sep_line = Line(ORIGIN, 4.5 * RIGHT, stroke_width=5)
sep_line.next_to(titles, DOWN)
chart = VGroup(titles, contents, sep_line)
chart.set_height(7)
chart.center().to_edge(LEFT)
self.add(chart)
# Figures on the right
std_zero_pos_axis = NumberLine(x_min=-2,
x_max=2,
color=GREY,
unit_size=0.25,
tick_size=0.05)
std_zero_pos_axis.rotate(np.pi / 2)
std_nocross_pos_axis = NumberLine(x_min=-4,
x_max=4,
color=GREY,
unit_size=0.25,
tick_size=0.05)
std_nocross_pos_axis.rotate(np.pi / 2)
std_time_axis = NumberLine(x_min=0,
x_max=5.5,
color=GREY,
unit_size=0.25,
tick_size=0.05)
std_zero_axes = VGroup(std_zero_pos_axis, std_time_axis)
std_nocross_axes = VGroup(std_nocross_pos_axis, std_time_axis)
zero_walks = VGroup()
for sequence in ["UUDD", "UDUD", "UDDU", "DDUU", "DUDU", "DUUD"]:
axes = std_zero_axes.copy()
zero_walk = RandomWalk1DArrow(sequence, step_size=0.25)
zero_walk.move_start_to(axes[0].number_to_point(0))
zero_walks.add(VGroup(axes, zero_walk))
zero_walks.arrange_submobjects_in_grid(2, 3, buff=0.5)
zero_rect = SurroundingRectangle(zero_walks, color=ORANGE, buff=0.4)
zero_walks.add(zero_rect)
nocross_walks = VGroup()
for sequence in ["DDDD", "DDUD", "DDDU", "UUUU", "UUDU", "UUUD"]:
axes = std_nocross_axes.copy()
nocross_walk = RandomWalk1DArrow(sequence, step_size=0.25)
nocross_walk.move_start_to(axes[0].number_to_point(0))
nocross_walks.add(VGroup(axes, nocross_walk))
nocross_walks.arrange_submobjects_in_grid(2, 3, buff=0.5)
nocross_rect = SurroundingRectangle(nocross_walks,
color=GREEN,
buff=0.4)
nocross_walks.add(nocross_rect)
relation = TexMobject("p_2", "=", "q_2", "=", "6")
relation[0].set_color(ORANGE)
relation[2].set_color(GREEN)
relation.scale(1.5)
figure = VGroup(zero_walks, relation, nocross_walks)
figure.arrange_submobjects(DOWN)
figure.set_height(7)
figure.center().to_edge(RIGHT)
self.add(figure)
self.wait()
def construct(self):
# Setup
pos_axis = NumberLine(x_min=-3.5, x_max=3.5, color=WHITE)
pos_axis.rotate(np.pi / 2)
pos_axis.add_tip()
time_axis = NumberLine(x_min=0, x_max=9.5, color=WHITE)
time_axis.add_tip()
pos_text = TextMobject("位置")
pos_text.next_to(pos_axis.number_to_point(3.5), LEFT)
time_text = TextMobject("时间")
time_text.next_to(time_axis.number_to_point(9.5), DOWN)
group = VGroup(pos_axis, time_axis, pos_text, time_text)
group.to_edge(LEFT, buff=2)
self.add(group)
# Some preparations
sequences = [
"UDDDUDUD", "DUUDDDUD", "DDUUUDUD", "UUUDDUDU", "UDDDUDUD"
]
nums = [1, 3, 7, -1, 1]
walks = [
RandomWalk1DArrow(sequence).move_start_to(
pos_axis.number_to_point(0)) for sequence in sequences
]
parts = [walk.split_at(num) for walk, num in zip(walks, nums)]
split_lines = [
DashedLine(TOP, BOTTOM, color = GREY) \
.move_to(time_axis.number_to_point(num+1))
for num in nums
]
zero_words = [
TextMobject("“正点到家” \\\\ $P_%s$" % str((num+1)//2)) \
.next_to(line, LEFT).shift(2.8 * DOWN).set_color(ORANGE)
for num, line in zip(nums, split_lines)
]
nocross_words = [
TextMobject("“不经过家门” \\\\ $Q_%s$" % str(4-(num+1)//2)) \
.next_to(line, RIGHT).shift(2.8 * DOWN).set_color(GREEN)
for num, line in zip(nums, split_lines)
]
for words, direction in zip([zero_words, nocross_words],
[RIGHT, LEFT]):
for word in words:
text, symbol = VGroup(word[:-2]), VGroup(word[-2:])
symbol.scale(1.5)
symbol.next_to(text, DOWN, aligned_edge=direction)
word.add_background_rectangle()
# Demonstrate how to split
self.add(walks[0], split_lines[0], zero_words[0], nocross_words[0])
l = len(walks)
for k in range(l - 1):
cur_walk = walks[k]
cur_line = split_lines[k]
cur_zero_word = zero_words[k]
cur_nocross_word = nocross_words[k]
next_walk = walks[k + 1]
next_line = split_lines[k + 1]
next_zero_word = zero_words[k + 1]
next_nocross_word = nocross_words[k + 1]
part1, part2 = parts[k]
cur_walk.save_state()
self.play(
part1.set_color,
ORANGE,
part2.set_color,
GREEN,
)
self.wait()
self.play(cur_walk.restore)
self.wait()
self.play(
ReplacementTransform(cur_walk, next_walk),
ReplacementTransform(cur_line, next_line),
ReplacementTransform(cur_zero_word, next_zero_word),
ReplacementTransform(cur_nocross_word, next_nocross_word),
)
self.wait()
def setup(self):
self.pi_creatures = VGroup(*self.create_pi_creatures())
self.pi_creature = self.get_primary_pi_creature()
if self.pi_creatures_start_on_screen:
self.add(*self.pi_creatures)
def organize_matrices(self, left, right, result):
equals = TexMobject("=")
everything = VGroup(left, right, equals, result)
everything.arrange_submobjects()
everything.scale_to_fit_width(FRAME_WIDTH - 1)
self.add(everything)
def get_secant_slope_group(
self,
x,
graph,
dx=None,
dx_line_color=None,
df_line_color=None,
dx_label=None,
df_label=None,
include_secant_line=True,
secant_line_color=None,
secant_line_length=10,
):
"""
Resulting group is of the form VGroup(
dx_line,
df_line,
dx_label, (if applicable)
df_label, (if applicable)
secant_line, (if applicable)
)
with attributes of those names.
"""
kwargs = locals()
kwargs.pop("self")
group = VGroup()
group.kwargs = kwargs
dx = dx or float(self.x_max - self.x_min) / 10
dx_line_color = dx_line_color or self.default_input_color
df_line_color = df_line_color or graph.get_color()
p1 = self.input_to_graph_point(x, graph)
p2 = self.input_to_graph_point(x + dx, graph)
interim_point = p2[0] * RIGHT + p1[1] * UP
group.dx_line = Line(p1, interim_point, color=dx_line_color)
group.df_line = Line(interim_point, p2, color=df_line_color)
group.add(group.dx_line, group.df_line)
labels = VGroup()
if dx_label is not None:
group.dx_label = TexMobject(dx_label)
labels.add(group.dx_label)
group.add(group.dx_label)
if df_label is not None:
group.df_label = TexMobject(df_label)
labels.add(group.df_label)
group.add(group.df_label)
if len(labels) > 0:
max_width = 0.8 * group.dx_line.get_width()
max_height = 0.8 * group.df_line.get_height()
if labels.get_width() > max_width:
labels.scale_to_fit_width(max_width)
if labels.get_height() > max_height:
labels.scale_to_fit_height(max_height)
if dx_label is not None:
group.dx_label.next_to(group.dx_line,
np.sign(dx) * DOWN,
buff=group.dx_label.get_height() / 2)
group.dx_label.set_color(group.dx_line.get_color())
if df_label is not None:
group.df_label.next_to(group.df_line,
np.sign(dx) * RIGHT,
buff=group.df_label.get_height() / 2)
group.df_label.set_color(group.df_line.get_color())
if include_secant_line:
secant_line_color = secant_line_color or self.default_derivative_color
group.secant_line = Line(p1, p2, color=secant_line_color)
group.secant_line.scale_in_place(secant_line_length /
group.secant_line.get_length())
group.add(group.secant_line)
return group
def move_tip_to(self, point):
VGroup(self, self.content).shift(point - self.get_tip())
return self
def get_prior_rectangles(self):
return VGroup(*[
self.sample_space.horizontal_parts[i].vertical_parts[0]
for i in range(2)
])
def get_tires(self):
return VGroup(self[1][1], self[1][3])
def construct(self):
# Setup
axes_group = self.axes_group
pos_axis, time_axis = axes_group[:2]
title_pq = self.title_pq
walk_q = self.walk_q
parts_q = self.parts_q
l_arrow = self.l_arrow
self.add(axes_group, title_pq, walk_q, l_arrow)
walk_q_copy = walk_q.copy()
# Q_4 -> P_4
steps_qp = VGroup(*[
TextMobject(text) for text in [
"1. 找到路径终点的位置坐标$h$", "2. 找到最晚一次穿过$\\frac{h}{2}$的时刻",
"3. 在这个时刻上进行分割", "4. 将第一段水平翻转", "5. 拼接两个片段"
]
])
for step in steps_qp:
step.set_color(YELLOW)
step.add_background_rectangle()
step1_qp, step2_qp, step3_qp, step4_qp, step5_qp = steps_qp
# 1. Find the endpoint
step1_qp.next_to(time_axis.number_to_point(4.5), UP)
end_horiz_line = DashedLine(LEFT_SIDE, RIGHT_SIDE, color=YELLOW)
end_horiz_line.move_to(pos_axis.number_to_point(-4))
end_horiz_line.horizontally_center()
end_brace_line = DashedLine(time_axis.number_to_point(8),
walk_q.get_end_point())
end_brace = Brace(end_brace_line, direction=RIGHT, color=YELLOW)
h = TexMobject("h").set_color(YELLOW)
end_brace.put_at_tip(h)
self.play(Write(step1_qp), ShowCreation(end_horiz_line), run_time=1)
self.play(GrowFromCenter(end_brace), GrowFromCenter(h))
self.wait(1.5)
self.play(FadeOut(step1_qp))
# 2. Find the last time it GOES THROUGH half its final value
half_point = walk_q.get_arrow_end_point(3)
step2_qp.next_to(time_axis.number_to_point(4.5), UP)
half_horiz_line = end_horiz_line.copy().shift(2 * UP)
half_brace_line = DashedLine(time_axis.number_to_point(4), half_point)
half_brace = Brace(half_brace_line, direction=RIGHT, color=YELLOW)
half_h = TexMobject("\\frac{h}{2}").set_color(YELLOW)
half_brace.put_at_tip(half_h)
half_dot = Dot(half_point, color=YELLOW)
self.play(FadeIn(step2_qp), run_time=1)
self.wait(0.5)
self.play(
ReplacementTransform(end_brace, half_brace),
ReplacementTransform(end_horiz_line, half_horiz_line),
ReplacementTransform(h, half_h[0]),
Write(half_h[1:]),
)
self.play(DrawBorderThenFill(half_dot))
self.wait(1.5)
self.play(
FadeOut(VGroup(step2_qp, half_horiz_line, half_brace, half_h)))
# 3. Split
vert_line = DashedLine(2.5 * UP, 2.5 * DOWN, color=YELLOW)
vert_line.move_to(half_point)
step3_qp.next_to(vert_line, UP)
left_part_q, right_part_q = parts_q
self.play(ShowCreation(vert_line), Write(step3_qp), run_time=1)
self.play(
FadeOut(half_dot),
left_part_q.shift,
0.5 * DOWN + 0.5 * LEFT,
right_part_q.shift,
0.5 * UP + 0.5 * RIGHT,
)
self.wait(1.5)
self.play(FadeOut(vert_line), FadeOut(step3_qp))
# 4. Flip the first segment horizontally
flip_axis = DashedLine(2 * UP, 2 * DOWN, color=GREY)
flip_axis.move_to(left_part_q)
step4_qp.next_to(flip_axis, DOWN)
self.play(
ShowCreation(flip_axis),
Write(step4_qp),
run_time=1,
)
self.play(
left_part_q.flip,
Animation(flip_axis),
)
self.wait(1.5)
self.play(FadeOut(step4_qp), FadeOut(flip_axis))
# 5. Put the pieces together
step5_qp.shift(2.5 * DOWN)
flip_arrow_anims = walk_q.get_flip_arrows_animation(3, color=ORANGE)
self.play(Write(step5_qp), run_time=1)
self.wait(0.5)
self.play(flip_arrow_anims, right_part_q.set_color, ORANGE)
self.wait(0.5)
self.play(
left_part_q.shift,
2.5 * UP + 0.5 * RIGHT,
right_part_q.shift,
3.5 * UP + 0.5 * LEFT,
Animation(step5_qp),
)
self.wait(0.5)
self.play(FadeOut(step5_qp))
self.wait(1.5)
# Now Reset
self.play(FadeOut(walk_q))
self.play(FadeIn(walk_q_copy))
self.wait()
def get_dots_by_number(self, n):
return VGroup(self.dot_group[n:n + 2])
