def show_equation(self, chopped_cycloid, ref_mob):
point2, point1 = chopped_cycloid.points[-2:]
arc, theta, vert_line, tangent_line = self.get_marks(point1, point2)
equation = TexMobject([
"\\sin(\\theta)",
"\\over \\sqrt{y}",
])
sin, sqrt_y = equation.split()
equation.next_to(ref_mob)
const = TexMobject(" = \\text{constant}")
const.next_to(equation)
ceil_point = np.array(point1)
ceil_point[1] = self.top[1]
brace = Brace(Mobject(Point(point1), Point(ceil_point)), RIGHT)
y_mob = TexMobject("y").next_to(brace)
self.play(GrowFromCenter(sin), ShowCreation(arc),
GrowFromCenter(theta))
self.play(ShowCreation(vert_line))
self.play(ShowCreation(tangent_line))
self.dither()
self.play(GrowFromCenter(sqrt_y), GrowFromCenter(brace),
GrowFromCenter(y_mob))
self.dither()
self.play(Transform(Point(const.get_left()), const))
self.dither()
def get_coordinate_labels(self, *numbers):
result = VGroup()
nudge = 0.1 * (DOWN + RIGHT)
if len(numbers) == 0:
numbers = range(-int(self.x_radius), int(self.x_radius) + 1)
numbers += [
complex(0, y) for y in range(-int(self.y_radius),
int(self.y_radius) + 1)
]
for number in numbers:
point = self.number_to_point(number)
num_str = str(number).replace("j", "i")
if num_str.startswith("0"):
num_str = "0"
elif num_str in ["1i", "-1i"]:
num_str = num_str.replace("1", "")
num_mob = TexMobject(num_str)
num_mob.add_background_rectangle()
num_mob.scale(self.number_scale_factor)
if complex(number).imag != 0:
vect = DOWN + RIGHT
else:
vect = DOWN + RIGHT
num_mob.next_to(point, vect, SMALL_BUFF)
result.add(num_mob)
return result
def get_x_slider(self, x):
numbers = range(int(self.slider_x_max) + 1)
line = NumberLine(
x_min=0,
x_max=self.slider_x_max,
space_unit_to_num=float(self.slider_width) / self.slider_x_max,
color=GREY,
numbers_with_elongated_ticks=numbers,
tick_frequency=0.25,
)
line.add_numbers(*numbers)
line.numbers.next_to(line, UP, buff=SMALL_BUFF)
for number in line.numbers:
number.add_background_rectangle()
line.move_to(self.slider_center)
triangle = RegularPolygon(
3,
start_angle=np.pi / 2,
fill_color=self.slider_handle_color,
fill_opacity=0.8,
stroke_width=0,
)
triangle.scale_to_fit_height(self.x_slider_handle_height)
triangle.move_to(line.number_to_point(x), UP)
x_mob = TexMobject("x")
x_mob.next_to(triangle, DOWN, buff=SMALL_BUFF)
result = VGroup(line, triangle, x_mob)
result.x_val = x
return result
def get_graph_label(
self,
graph,
label = "f(x)",
x_val = None,
direction = RIGHT,
buff = MED_SMALL_BUFF,
color = None,
):
label = TexMobject(label)
color = color or graph.get_color()
label.highlight(color)
if x_val is None:
#Search from right to left
for x in np.linspace(self.x_max, self.x_min, 100):
point = self.input_to_graph_point(x, graph)
if point[1] < SPACE_HEIGHT:
break
x_val = x
label.next_to(
self.input_to_graph_point(x_val, graph),
direction,
buff = buff
)
label.shift_onto_screen()
return label
def add_point(self):
point = self.plane.coords_to_point(3, 2)
dot = Dot(point, color=self.dot_color)
line = Line(self.plane.get_center_point(), point)
line.highlight(dot.get_color())
number_label = TexMobject("3+2i")
number_label.add_background_rectangle()
number_label.next_to(dot, RIGHT, SMALL_BUFF)
distance_labels = VGroup()
for tex in "3^2 + 2^2", "13":
pre_label = TexMobject("\\sqrt{%s}" % tex)
label = VGroup(
BackgroundRectangle(pre_label),
VGroup(*pre_label[:2]),
VGroup(*pre_label[2:]),
)
label.scale(0.75)
label.next_to(line.get_center(), UP, SMALL_BUFF)
label.rotate(line.get_angle(), about_point=line.get_center())
distance_labels.add(label)
self.play(FadeIn(number_label), ShowCreation(line),
DrawBorderThenFill(dot))
self.play(Write(distance_labels[0]))
self.dither()
self.play(ReplacementTransform(*distance_labels))
self.dither()
self.distance_label = distance_labels[1]
self.line = line
self.dot = dot
self.number_label = number_label
def construct(self):
cycloid = Cycloid()
index = cycloid.get_num_points()/3
point = cycloid.points[index]
vect = cycloid.points[index+1]-point
vect /= np.linalg.norm(vect)
vect *= 3
vect_mob = Vector(point, vect)
dot = Dot(point)
xy = TexMobject("\\big( x(t), y(t) \\big)")
xy.next_to(dot, UP+RIGHT, buff = 0.1)
vert_line = Line(2*DOWN, 2*UP)
vert_line.shift(point)
angle = vect_mob.get_angle() + np.pi/2
arc = Arc(angle, radius = 1, start_angle = -np.pi/2)
arc.shift(point)
theta = TexMobject("\\theta(t)")
theta.next_to(arc, DOWN, buff = 0.1, aligned_edge = LEFT)
theta.shift(0.2*RIGHT)
self.play(ShowCreation(cycloid))
self.play(ShowCreation(dot))
self.play(ShimmerIn(xy))
self.dither()
self.play(
FadeOut(xy),
ShowCreation(vect_mob)
)
self.play(
ShowCreation(arc),
ShowCreation(vert_line),
ShimmerIn(theta)
)
self.dither()
def put_it_first(self):
poker_example = self.get_poker_example()
music_example = self.get_music_example()
disease_group = self.disease_group
self.play(disease_group.restore, disease_group.to_edge, LEFT,
RemovePiCreatureBubble(self.teacher, target_mode="hesitant"))
self.change_student_modes(*["pondering"] * 3,
look_at_arg=disease_group)
poker_example.next_to(self.example, RIGHT)
music_example.next_to(poker_example, RIGHT)
examples = VGroup(poker_example, music_example)
brace = Brace(examples, UP)
bayes_to_intuition = VGroup(
*map(TextMobject, ["Bayes", "$\\leftrightarrow$", "Intuition"]))
bayes_to_intuition.arrange_submobjects(RIGHT, buff=SMALL_BUFF)
bayes_to_intuition.next_to(brace, UP, SMALL_BUFF)
check = TexMobject("\\checkmark")
check.highlight(GREEN)
check.next_to(bayes_to_intuition[1], UP, SMALL_BUFF)
for example in examples:
self.play(FadeIn(example))
self.dither()
self.play(GrowFromCenter(brace))
self.play(FadeIn(bayes_to_intuition))
self.play(Write(check))
self.dither(2)
self.intuitive_examples = VGroup(examples, brace, bayes_to_intuition,
check)
def show_d_sine(self):
ss_group = self.get_secant_slope_group(self.example_input,
self.sine_graph,
dx=self.dx,
dx_label="dx",
df_label="\\cos(0.5)dx",
include_secant_line=False)
for mob, vect in (ss_group.dx_label, UP), (ss_group.df_label, LEFT):
mob.scale(4, about_point=mob.get_edge_center(vect))
d_sine = self.deriv[2]
brace = Brace(d_sine)
cosine_dx = TexMobject("\\cos(x)", "dx")
cosine_dx.scale(self.tex_scale_factor)
cosine_dx.next_to(brace, DOWN)
cosine_dx.highlight(d_sine.get_color())
self.play(GrowFromCenter(brace), Write(cosine_dx))
self.dither()
self.play(
self.little_rectangle.move_to,
ss_group,
)
self.dither()
self.play(Write(ss_group))
self.dither()
self.cosine = cosine_dx[0]
self.sine_ss_group = ss_group
def complete_derivative(self):
cosine = self.cosine.copy()
two_x = self.two_x.copy()
lhs = VGroup(*self.deriv_q[:3])
to_fade = VGroup(*self.deriv_q[3:])
for mob in cosine, two_x, lhs:
mob.generate_target()
lhs.target.next_to(self.func_mob, DOWN, aligned_edge=LEFT)
cosine.target.next_to(lhs.target)
plus = TexMobject("+").scale(self.tex_scale_factor)
plus.next_to(cosine.target)
two_x.target.next_to(plus)
box = Rectangle(color=YELLOW)
box.replace(VGroup(lhs.target, two_x.target), stretch=True)
box.scale_in_place(1.2)
self.play(FocusOn(self.deriv_q))
self.play(Write(plus),
FadeOut(to_fade, rate_func=squish_rate_func(smooth, 0, 0.5)),
*map(MoveToTarget, [cosine, two_x, lhs]),
run_time=2)
to_fade.highlight(BLACK)
self.play(ShowCreation(box))
self.dither(2)
def get_label_group(self, t):
graph = self.graph
v_line = self.get_vertical_line_to_graph(
t,
graph,
color=YELLOW,
)
brace = Brace(v_line, RIGHT)
height_label = brace.get_text("$2^%d$" % t)
ss_group = self.get_secant_slope_group(
t,
graph,
dx=0.01,
df_label="dM",
dx_label="dt",
dx_line_color=GREEN,
secant_line_color=RED,
)
slope_label = TexMobject("\\text{Slope}", "=", "2^%d" % t,
"(%.7f\\dots)" % np.log(2))
slope_label.next_to(ss_group.secant_line.point_from_proportion(0.65),
DOWN + RIGHT,
buff=0)
slope_label.highlight_by_tex("Slope", RED)
return VGroup(v_line, brace, height_label, ss_group, slope_label)
def construct(self):
t_axis = NumberLine()
theta_axis = NumberLine().rotate(np.pi / 2)
theta_mob = TexMobject("\\theta(t)")
t_mob = TexMobject("t")
theta_mob.next_to(theta_axis, RIGHT)
theta_mob.to_edge(UP)
t_mob.next_to(t_axis, UP)
t_mob.to_edge(RIGHT)
graph = ParametricFunction(
lambda t: 4 * t * RIGHT + 2 * smooth(t) * UP)
line = Line(graph.points[0], graph.points[-1], color=WHITE)
q_mark = TextMobject("?")
q_mark.next_to(Point(graph.get_center()), LEFT)
stars = Stars(color=BLACK)
stars.scale(0.1).shift(q_mark.get_center())
squiggle = ParametricFunction(lambda t: t * RIGHT + 0.2 * t * (5 - t) *
(np.sin(t)**2) * UP,
start=0,
end=5)
self.play(ShowCreation(t_axis), ShowCreation(theta_axis),
ShimmerIn(theta_mob), ShimmerIn(t_mob))
self.play(ShimmerIn(q_mark), ShowCreation(graph))
self.wait()
self.play(Transform(q_mark, stars), Transform(graph, line))
self.wait()
self.play(Transform(graph, squiggle))
self.wait()
def get_subdivision_braces_and_labels(
self, parts, labels, direction,
buff = SMALL_BUFF,
min_num_quads = 1
):
label_mobs = VGroup()
braces = VGroup()
for label, part in zip(labels, parts):
brace = Brace(
part, direction,
min_num_quads = min_num_quads,
buff = buff
)
if isinstance(label, Mobject):
label_mob = label
else:
label_mob = TexMobject(label)
label_mob.scale(self.default_label_scale_val)
label_mob.next_to(brace, direction, buff)
braces.add(brace)
label_mobs.add(label_mob)
parts.braces = braces
parts.labels = label_mobs
parts.label_kwargs = {
"labels" : label_mobs.copy(),
"direction" : direction,
"buff" : buff,
}
return VGroup(parts.braces, parts.labels)
def get_matrices(self):
m1_mob = Matrix(np.array(self.t_matrix1).transpose())
m2_mob = Matrix(np.array(self.t_matrix2).transpose())
comp_matrix = Matrix([["?", "?"], ["?", "?"]])
m1_mob.highlight(YELLOW)
m2_mob.highlight(PINK)
comp_matrix.get_entries().submobject_gradient_highlight(YELLOW, PINK)
equals = TexMobject("=")
equals.next_to(comp_matrix, LEFT)
comp_matrix.add(equals)
m1_mob = VMobject(BackgroundRectangle(m1_mob), m1_mob)
m2_mob = VMobject(BackgroundRectangle(m2_mob), m2_mob)
comp_matrix = VMobject(BackgroundRectangle(comp_matrix), comp_matrix)
VMobject(
m2_mob, m1_mob, comp_matrix
).arrange_submobjects(buff = 0.1).to_corner(UP+LEFT).shift(DOWN)
for i, mob in enumerate([m1_mob, m2_mob]):
brace = Brace(mob, UP)
text = TexMobject("M_%d"%(i+1))
text.next_to(brace, UP)
brace.add_background_rectangle()
text.add_background_rectangle()
brace.add(text)
mob.label = brace
return m1_mob, m2_mob, comp_matrix
def show_proportionality_to_dx_squared(self):
ddf = self.ddf.copy()
ddf.generate_target()
ddf.target.next_to(self.ddf, UP, LARGE_BUFF)
rhs = TexMobject(
"\\approx", "(\\text{Some constant})", "(dx)^2"
)
rhs.scale(0.8)
rhs.next_to(ddf.target, RIGHT)
example_dx = TexMobject(
"dx = 0.01 \\Rightarrow (dx)^2 = 0.0001"
)
example_dx.scale(0.8)
example_dx.to_corner(UP+RIGHT)
self.play(MoveToTarget(ddf))
self.play(Write(rhs))
self.dither()
self.play(Write(example_dx))
self.dither(2)
self.play(FadeOut(example_dx))
self.ddf = ddf
self.dx_squared = rhs.get_part_by_tex("dx")
def get_subdivision_braces_and_labels(
self, parts, labels, direction,
buff = SMALL_BUFF,
min_num_quads = 1
):
label_mobs = VGroup()
braces = VGroup()
for label, part in zip(labels, parts):
brace = Brace(
part, direction,
min_num_quads = min_num_quads,
buff = buff
)
if isinstance(label, Mobject):
label_mob = label
else:
label_mob = TexMobject(label)
label_mob.scale(self.default_label_scale_val)
label_mob.next_to(brace, direction, buff)
braces.add(brace)
label_mobs.add(label_mob)
parts.braces = braces
parts.labels = label_mobs
parts.label_kwargs = {
"labels" : label_mobs.copy(),
"direction" : direction,
"buff" : buff,
}
return VGroup(parts.braces, parts.labels)
def add_axes(self):
x_axis = Line(self.tick_width*LEFT/2, self.width*RIGHT)
y_axis = Line(MED_LARGE_BUFF*DOWN, self.height*UP)
ticks = VGroup()
heights = np.linspace(0, self.height, self.n_ticks+1)
values = np.linspace(0, self.max_value, self.n_ticks+1)
for y, value in zip(heights, values):
tick = Line(LEFT, RIGHT)
tick.scale_to_fit_width(self.tick_width)
tick.move_to(y*UP)
ticks.add(tick)
y_axis.add(ticks)
self.add(x_axis, y_axis)
self.x_axis, self.y_axis = x_axis, y_axis
if self.label_y_axis:
labels = VGroup()
for tick, value in zip(ticks, values):
label = TexMobject(str(np.round(value, 2)))
label.scale_to_fit_height(self.y_axis_label_height)
label.next_to(tick, LEFT, SMALL_BUFF)
labels.add(label)
self.y_axis_labels = labels
self.add(labels)
def show_derivative(self):
deriv = TexMobject("\\frac{df}{dx}")
deriv.next_to(self.graph_label, DOWN, MED_LARGE_BUFF)
deriv.highlight(self.deriv_color)
ss_group = self.get_secant_slope_group(
1, self.graph,
dx = 0.01,
secant_line_color = self.deriv_color
)
self.play(
Write(deriv),
*map(ShowCreation, ss_group)
)
self.animate_secant_slope_group_change(
ss_group, target_x = self.x3,
run_time = 5
)
self.dither()
self.animate_secant_slope_group_change(
ss_group, target_x = self.x2,
run_time = 3
)
self.dither()
self.ss_group = ss_group
self.deriv = deriv
def get_label_group(self, t):
graph = self.graph
v_line = self.get_vertical_line_to_graph(
t, graph,
color = YELLOW,
)
brace = Brace(v_line, RIGHT)
height_label = brace.get_text("$2^%d$"%t)
ss_group = self.get_secant_slope_group(
t, graph, dx = 0.01,
df_label = "dM",
dx_label = "dt",
dx_line_color = GREEN,
secant_line_color = RED,
)
slope_label = TexMobject(
"\\text{Slope}", "=",
"2^%d"%t,
"(%.7f\\dots)"%np.log(2)
)
slope_label.next_to(
ss_group.secant_line.point_from_proportion(0.65),
DOWN+RIGHT,
buff = 0
)
slope_label.highlight_by_tex("Slope", RED)
return VGroup(
v_line, brace, height_label,
ss_group, slope_label
)
def get_matrices(self):
m1_mob = Matrix(np.array(self.t_matrix1).transpose())
m2_mob = Matrix(np.array(self.t_matrix2).transpose())
comp_matrix = Matrix([["?", "?"], ["?", "?"]])
m1_mob.highlight(YELLOW)
m2_mob.highlight(PINK)
comp_matrix.get_entries().submobject_gradient_highlight(YELLOW, PINK)
equals = TexMobject("=")
equals.next_to(comp_matrix, LEFT)
comp_matrix.add(equals)
m1_mob = VMobject(BackgroundRectangle(m1_mob), m1_mob)
m2_mob = VMobject(BackgroundRectangle(m2_mob), m2_mob)
comp_matrix = VMobject(BackgroundRectangle(comp_matrix), comp_matrix)
VMobject(m2_mob, m1_mob, comp_matrix).arrange_submobjects(
buff=0.1).to_corner(UP + LEFT).shift(DOWN)
for i, mob in enumerate([m1_mob, m2_mob]):
brace = Brace(mob, UP)
text = TexMobject("M_%d" % (i + 1))
text.next_to(brace, UP)
brace.add_background_rectangle()
text.add_background_rectangle()
brace.add(text)
mob.label = brace
return m1_mob, m2_mob, comp_matrix
def construct(self):
eq1 = TexMobject(
"\\text{secant}(\\theta) = \\frac{1}{\\text{cosine}(\\theta)}"
)
eq2 = TexMobject(
"\\text{cosecant}(\\theta) = \\frac{1}{\\text{sine}(\\theta)}"
)
eq1.to_corner(UP+LEFT)
eq1.to_edge(LEFT)
eq2.next_to(eq1, DOWN, buff = LARGE_BUFF)
eqs = VGroup(eq1, eq2)
self.play(
self.get_teacher().change_mode, "speaking",
Write(eqs),
*[
ApplyMethod(pi.look_at, eqs)
for pi in self.get_students()
]
)
self.random_blink()
self.play(
VGroup(*eq1[-9:-7]).highlight, YELLOW,
VGroup(*eq2[:2]).highlight, YELLOW,
*[
ApplyMethod(pi.change_mode, "confused")
for pi in self.get_students()
]
)
self.random_blink(2)
def construct(self):
v_color = MAROON_C
w_color = BLUE
words = TextMobject([
"``Linear combination'' of", "$\\vec{\\textbf{v}}$", "and",
"$\\vec{\\textbf{w}}$"
])
words.split()[1].highlight(v_color)
words.split()[3].highlight(w_color)
words.scale_to_fit_width(2 * SPACE_WIDTH - 1)
words.to_edge(UP)
equation = TexMobject(
["a", "\\vec{\\textbf{v}}", "+", "b", "\\vec{\\textbf{w}}"])
equation.arrange_submobjects(buff=0.1, aligned_edge=DOWN)
equation.split()[1].highlight(v_color)
equation.split()[4].highlight(w_color)
a, b = np.array(equation.split())[[0, 3]]
equation.scale(2)
equation.next_to(words, DOWN, buff=1)
scalars_word = TextMobject("Scalars")
scalars_word.scale(1.5)
scalars_word.next_to(equation, DOWN, buff=2)
arrows = [Arrow(scalars_word, letter) for letter in a, b]
self.add(equation)
self.play(Write(words))
self.play(ShowCreation(VMobject(*arrows)), Write(scalars_word))
self.wait(2)
def add_conditional_divisions(self):
sample_space = self.sample_space
top_part, bottom_part = sample_space.horizontal_parts
top_brace = Brace(top_part, UP)
top_label = TexMobject("P(", "+", "|", "\\text{Disease}", ")", "=",
"1")
top_label.scale(0.7)
top_label.next_to(top_brace, UP)
top_label.highlight_by_tex("+", GREEN)
self.play(GrowFromCenter(top_brace))
self.play(FadeIn(top_label))
self.dither()
bottom_part.divide_vertically(0.95, colors=[BLUE_E, YELLOW_E])
bottom_label = TexMobject("P(", "+", "|", "\\text{Not disease}", ")",
"=", "1")
bottom_label.scale(0.7)
bottom_label.highlight_by_tex("+", GREEN)
braces, labels = bottom_part.get_bottom_braces_and_labels(
[bottom_label])
bottom_brace = braces[0]
self.play(
FadeIn(bottom_part.vertical_parts),
GrowFromCenter(bottom_brace),
)
self.play(FadeIn(bottom_label))
self.dither()
def add_scaling(self, arrows, syms, arrays):
s_arrows = VMobject(
TexMobject("2"), Vector([1, 1]).highlight(YELLOW),
TexMobject("="), Vector([2, 2]).highlight(WHITE)
)
s_arrows.arrange_submobjects(RIGHT)
s_arrows.scale(0.75)
s_arrows.next_to(arrows, DOWN)
s_arrays = VMobject(
TexMobject("2"),
matrix_to_mobject([3, -5]).highlight(YELLOW),
TextMobject("="),
matrix_to_mobject(["2(3)", "2(-5)"])
)
s_arrays.arrange_submobjects(RIGHT)
s_arrays.scale(0.75)
s_arrays.next_to(arrays, DOWN)
s_syms = TexMobject(["2", "\\vec{\\textbf{v}}"])
s_syms.split()[-1].highlight(YELLOW)
s_syms.next_to(syms, DOWN)
self.play(
Write(s_arrows), Write(s_arrays), Write(s_syms),
run_time = 2
)
self.wait()
def construct(self):
point_a, point_b = 3*LEFT, 3*RIGHT
dots = []
for point, char in [(point_a, "A"), (point_b, "B")]:
dot = Dot(point)
letter = TexMobject(char)
letter.next_to(dot, UP+LEFT)
dot.add(letter)
dots.append(dot)
path = ParametricFunction(
lambda t : (t/2 + np.cos(t))*RIGHT + np.sin(t)*UP,
start = -2*np.pi,
end = 2*np.pi
)
path.scale(6/(2*np.pi))
path.shift(point_a - path.points[0])
path.highlight(RED)
line = Line(point_a, point_b)
words = TextMobject("Shortest path from $A$ to $B$")
words.to_edge(UP)
self.play(
ShimmerIn(words),
*map(GrowFromCenter, dots)
)
self.play(ShowCreation(path))
self.play(Transform(
path, line,
path_func = path_along_arc(np.pi)
))
self.dither()
def various_arc_sizes_for_p1_p2_placements(self):
arc = self.arc
self.triangle.save_state()
self.play(*map(FadeOut, [
self.push_pins, self.triangle, self.arc_lines
]))
self.update_animations.remove(self.triangle_update)
self.update_animations += [
self.get_center_lines_update(self.point_mobs, self.center_lines),
self.get_arcs_update(self.all_arcs)
]
#90 degree angle
self.change_point_mobs_to_angles([np.pi/2, np.pi], run_time = 1)
elbow = VGroup(
Line(DOWN, DOWN+RIGHT),
Line(DOWN+RIGHT, RIGHT),
)
elbow.scale(0.25)
elbow.shift(self.center)
ninety_degrees = TexMobject("90^\\circ")
ninety_degrees.next_to(elbow, DOWN+RIGHT, buff = 0)
proportion = DecimalNumber(0.25)
proportion.highlight(self.center_color)
# proportion.next_to(arc.point_from_proportion(0.5), DOWN, MED_LARGE_BUFF)
proportion.next_to(self.arc_size_arrow, DOWN)
def proportion_update_func(alpha):
angles = self.get_point_mob_angles()
diff = abs(angles[1]-angles[0])/(2*np.pi)
return min(diff, 1-diff)
proportion_update = ChangingDecimal(proportion, proportion_update_func)
self.play(ShowCreation(elbow), FadeIn(ninety_degrees))
self.dither()
self.play(
ApplyMethod(
arc.rotate_in_place, np.pi/12,
rate_func = wiggle,
)
)
self.play(LaggedStart(FadeIn, proportion, run_time = 1))
self.dither()
#Non right angles
angle_pairs = [
(0.26*np.pi, 1.24*np.pi),
(0.73*np.pi, 0.78*np.pi),
(0.5*np.pi, np.pi),
]
self.update_animations.append(proportion_update)
for angle_pair in angle_pairs:
self.change_point_mobs_to_angles(
angle_pair,
VGroup(elbow, ninety_degrees).fade, 1,
)
self.remove(elbow, ninety_degrees)
self.dither()
self.set_variables_as_attrs(proportion, proportion_update)
def construct(self):
p_tex = "$%s$"%get_vect_tex("p")
p_mob = TextMobject(p_tex)
p_mob.scale(1.5)
p_mob.highlight(P_COLOR)
input_array = Matrix(list("xyz"))
dot_product = Group(p_mob, Dot(radius = 0.07), input_array)
dot_product.arrange_submobjects(buff = MED_BUFF/2)
equals = TexMobject("=")
dot_product.next_to(equals, LEFT)
words = Group(*it.starmap(TextMobject, [
("(Length of projection)",),
("(Length of ", p_tex, ")",)
]))
times = TexMobject("\\times")
words[1].highlight_by_tex(p_tex, P_COLOR)
words[0].next_to(equals, RIGHT)
words[1].next_to(words[0], DOWN, aligned_edge = LEFT)
times.next_to(words[0], RIGHT)
everyone = Group(dot_product, equals, times, words)
everyone.center().scale_to_fit_width(SPACE_WIDTH - 1)
self.add(dot_product)
self.play(Write(equals))
self.play(Write(words[0]))
self.dither()
self.play(
Write(times),
Write(words[1])
)
self.dither()
def show_d_x_squared(self):
ss_group = self.get_secant_slope_group(self.example_input,
self.parabola,
dx=self.dx,
dx_label="dx",
df_label="2(0.5)dx",
include_secant_line=False)
for mob, vect in (ss_group.dx_label, UP), (ss_group.df_label, LEFT):
mob.scale(3, about_point=mob.get_edge_center(vect))
d_x_squraed = self.deriv[4]
brace = Brace(d_x_squraed)
two_x_dx = TexMobject("2x", "\\,dx")
two_x_dx.scale(self.tex_scale_factor)
two_x_dx.next_to(brace, DOWN)
two_x_dx.highlight(d_x_squraed.get_color())
self.play(FocusOn(two_x_dx))
self.play(GrowFromCenter(brace), Write(two_x_dx))
self.dither()
self.play(
self.little_rectangle.move_to,
ss_group,
)
self.dither()
self.play(Write(ss_group))
self.dither()
self.two_x = two_x_dx[0]
self.x_squared_ss_group = ss_group
def specifics_concepts(self):
matrix_vector_product = TexMobject(" ".join([
matrix_to_tex_string(EXAMPLE_TRANFORM),
matrix_to_tex_string(TRANFORMED_VECTOR),
"&=",
matrix_to_tex_string([
["1 \\cdot 1 + 0 \\cdot 2"],
["1 \\cdot 1 + (-1)\\cdot 2"]
]),
"\\\\ &=",
matrix_to_tex_string([[1], [-1]]),
]))
matrix_vector_product.scale_to_fit_width(SPACE_WIDTH-0.5)
matrix_vector_product.next_to(self.vline, LEFT)
self.play(
Write(self.numeric),
FadeIn(matrix_vector_product),
run_time = 2
)
self.dither()
self.play(Write(self.geometric, run_time = 2))
### Paste in linear transformation
self.dither()
digest_locals(self)
def get_graph_label(
self,
graph,
label = "f(x)",
x_val = None,
direction = RIGHT,
buff = MED_SMALL_BUFF,
color = None,
):
label = TexMobject(label)
color = color or graph.get_color()
label.highlight(color)
if x_val is None:
#Search from right to left
for x in np.linspace(self.x_max, self.x_min, 100):
point = self.input_to_graph_point(x, graph)
if point[1] < SPACE_HEIGHT:
break
x_val = x
label.next_to(
self.input_to_graph_point(x_val, graph),
direction,
buff = buff
)
label.shift_onto_screen()
return label
def construct(self):
title = TextMobject("Function composition")
title.to_edge(UP)
sine = TexMobject("g(", "x", ")", "=", "\\sin(", "x", ")")
sine.highlight(SINE_COLOR)
x_squared = TexMobject("h(x)", "=", "x^2")
x_squared.highlight(X_SQUARED_COLOR)
group = VGroup(sine, x_squared)
group.arrange_submobjects(buff=LARGE_BUFF)
group.shift(UP)
composition = TexMobject("g(", "h(x)", ")", "=", "\\sin(", "x^2", ")")
for i in 0, 2, 4, 6:
composition[i].highlight(SINE_COLOR)
for i in 1, 5:
composition[i].highlight(X_SQUARED_COLOR)
composition.next_to(group, DOWN, buff=LARGE_BUFF)
brace = Brace(VGroup(*composition[-3:]), DOWN)
deriv_q = brace.get_text("Derivative?")
self.add(group)
self.play(Write(title))
self.dither()
triplets = [[sine, (0, 2), (0, 2)], [x_squared, (0, ), (1, )],
[sine, (3, 4, 6), (3, 4, 6)], [x_squared, (2, ), (5, )]]
for premob, pre_indices, comp_indicies in triplets:
self.play(*[
ReplacementTransform(premob[i].copy(), composition[j])
for i, j in zip(pre_indices, comp_indicies)
])
self.dither()
self.dither()
self.play(GrowFromCenter(brace), Write(deriv_q))
self.dither()
def construct(self):
two_dot = TexMobject("2\\cdot")
equals = TexMobject("=")
self.add_axes()
v = self.add_vector([3, 1])
v_coords, vx_line, vy_line = self.vector_to_coords(v, clean_up=False)
self.play(ApplyMethod(v_coords.to_edge, UP))
two_dot.next_to(v_coords, LEFT)
equals.next_to(v_coords, RIGHT)
two_v = self.add_vector([6, 2], animate=False)
self.remove(two_v)
self.play(Transform(v.copy(), two_v), Write(two_dot, run_time=1))
two_v_coords, two_v_x_line, two_v_y_line = self.vector_to_coords(
two_v, clean_up=False)
self.play(ApplyMethod(two_v_coords.next_to, equals, RIGHT),
Write(equals, run_time=1))
self.dither(2)
x, y = v_coords.get_mob_matrix().flatten()
two_v_elems = two_v_coords.get_mob_matrix().flatten()
x_sym, y_sym = map(TexMobject, ["x", "y"])
two_x_sym, two_y_sym = map(TexMobject, ["2x", "2y"])
VMobject(x_sym, two_x_sym).highlight(X_COLOR)
VMobject(y_sym, two_y_sym).highlight(Y_COLOR)
syms = [x_sym, y_sym, two_x_sym, two_y_sym]
VMobject(*syms).scale(VECTOR_LABEL_SCALE_FACTOR)
for sym, num in zip(syms, [x, y] + list(two_v_elems)):
sym.move_to(num)
self.play(Transform(x, x_sym), Transform(y, y_sym),
FadeOut(VMobject(*two_v_elems)))
self.dither()
self.play(Transform(VMobject(two_dot.copy(), x.copy()), two_x_sym),
Transform(VMobject(two_dot.copy(), y.copy()), two_y_sym))
self.dither(2)
def add_scaling(self, arrows, syms, arrays):
s_arrows = VMobject(
TexMobject("2"), Vector([1, 1]).highlight(YELLOW),
TexMobject("="), Vector([2, 2]).highlight(WHITE)
)
s_arrows.arrange_submobjects(RIGHT)
s_arrows.scale(0.75)
s_arrows.next_to(arrows, DOWN)
s_arrays = VMobject(
TexMobject("2"),
matrix_to_mobject([3, -5]).highlight(YELLOW),
TextMobject("="),
matrix_to_mobject(["2(3)", "2(-5)"])
)
s_arrays.arrange_submobjects(RIGHT)
s_arrays.scale(0.5)
s_arrays.next_to(arrays, DOWN)
s_syms = TexMobject(["2", "\\vec{\\textbf{v}}"])
s_syms.split()[-1].highlight(YELLOW)
s_syms.next_to(syms, DOWN)
self.play(
Write(s_arrows), Write(s_arrays), Write(s_syms),
run_time = 2
)
self.dither()
def construct(self):
p_tex = "$%s$" % get_vect_tex("p")
p_mob = TextMobject(p_tex)
p_mob.scale(1.5)
p_mob.highlight(P_COLOR)
input_array = Matrix(list("xyz"))
dot_product = VGroup(p_mob, Dot(radius=0.07), input_array)
dot_product.arrange_submobjects(buff=MED_SMALL_BUFF / 2)
equals = TexMobject("=")
dot_product.next_to(equals, LEFT)
words = VGroup(*it.starmap(TextMobject, [(
"(Length of projection)", ), (
"(Length of ",
p_tex,
")",
)]))
times = TexMobject("\\times")
words[1].highlight_by_tex(p_tex, P_COLOR)
words[0].next_to(equals, RIGHT)
words[1].next_to(words[0], DOWN, aligned_edge=LEFT)
times.next_to(words[0], RIGHT)
everyone = VGroup(dot_product, equals, times, words)
everyone.center().scale_to_fit_width(SPACE_WIDTH - 1)
self.add(dot_product)
self.play(Write(equals))
self.play(Write(words[0]))
self.dither()
self.play(Write(times), Write(words[1]))
self.dither()
def construct(self):
signature = get_cursive_name("Alice")
signature.scale(1.5)
signature.highlight(BLUE_C)
signature.to_corner(UP + LEFT)
signature_copy = signature.copy()
signature_copy.shift(3 * RIGHT)
bits = TexMobject("01100001")
bits.next_to(signature, DOWN)
bits.shift_onto_screen()
bits_copy = bits.copy()
bits_copy.next_to(signature_copy, DOWN)
self.add(signature)
self.student_says("Couldn't you just \\\\ copy the signature?",
target_mode="confused",
run_time=1)
self.change_student_modes("pondering", "confused", "erm")
self.play(LaggedStart(FadeIn, bits, run_time=1))
self.dither()
self.play(
ReplacementTransform(bits.copy(), bits_copy, path_arc=np.pi / 2))
self.play(Write(signature_copy))
self.dither(3)
def construct(self):
point_a, point_b = 3 * LEFT, 3 * RIGHT
dots = []
for point, char in [(point_a, "A"), (point_b, "B")]:
dot = Dot(point)
letter = TexMobject(char)
letter.next_to(dot, UP + LEFT)
dot.add(letter)
dots.append(dot)
path = ParametricFunction(lambda t:
(t / 2 + np.cos(t)) * RIGHT + np.sin(t) * UP,
start=-2 * np.pi,
end=2 * np.pi)
path.scale(6 / (2 * np.pi))
path.shift(point_a - path.points[0])
path.highlight(RED)
line = Line(point_a, point_b)
words = TextMobject("Shortest path from $A$ to $B$")
words.to_edge(UP)
self.play(ShimmerIn(words), *map(GrowFromCenter, dots))
self.play(ShowCreation(path))
self.play(Transform(path, line, path_func=path_along_arc(np.pi)))
self.wait()
def construct(self):
lhs = TexMobject(["\\text{det}(", "M_1", "M_2", ")"])
det, m1, m2, rp = lhs.split()
m1.highlight(TEAL)
m2.highlight(PINK)
rhs = TexMobject(["=\\text{det}(", "M_1", ")\\text{det}(", "M_2", ")"])
rhs.split()[1].highlight(TEAL)
rhs.split()[3].highlight(PINK)
rhs.next_to(lhs, RIGHT)
formula = VMobject(lhs, rhs)
formula.center()
title = TextMobject("Explain in one sentence")
title.highlight(YELLOW)
title.next_to(formula, UP, buff=0.5)
self.play(Write(m1))
self.play(Write(m2))
self.wait()
self.play(Write(det), Write(rp))
self.play(Write(rhs))
self.wait(2)
self.play(Write(title))
self.wait(2)
def construct(self):
underlying = TextMobject("Underlying \\\\ system")
underlying.shift(DOWN).to_edge(LEFT)
user_facing = TextMobject("User-facing")
user_facing.next_to(underlying, UP, LARGE_BUFF, LEFT)
protocol = TextMobject("Bitcoin protocol")
protocol.next_to(underlying, RIGHT, MED_LARGE_BUFF)
protocol.highlight(BITCOIN_COLOR)
banking = TextMobject("Banking system")
banking.next_to(protocol, RIGHT, MED_LARGE_BUFF)
banking.highlight(GREEN)
phone = SVGMobject(
file_name="phone",
fill_color=WHITE,
fill_opacity=1,
height=1,
stroke_width=0,
)
phone.next_to(protocol, UP, LARGE_BUFF)
card = SVGMobject(file_name="credit_card",
fill_color=LIGHT_GREY,
fill_opacity=1,
stroke_width=0,
height=1)
card.next_to(banking, UP, LARGE_BUFF)
btc = BitcoinLogo()
btc.next_to(phone, UP, MED_LARGE_BUFF)
dollar = TexMobject("\\$")
dollar.scale_to_fit_height(1)
dollar.highlight(GREEN)
dollar.next_to(card, UP, MED_LARGE_BUFF)
card.save_state()
card.shift(2 * RIGHT)
card.set_fill(opacity=0)
h_line = Line(underlying.get_left(), banking.get_right())
h_line.next_to(underlying, DOWN, MED_SMALL_BUFF, LEFT)
h_line2 = h_line.copy()
h_line2.next_to(user_facing, DOWN, MED_LARGE_BUFF, LEFT)
h_line3 = h_line.copy()
h_line3.next_to(user_facing, UP, MED_LARGE_BUFF, LEFT)
v_line = Line(5 * UP, ORIGIN)
v_line.next_to(underlying, RIGHT, MED_SMALL_BUFF)
v_line.shift(1.7 * UP)
v_line2 = v_line.copy()
v_line2.next_to(protocol, RIGHT, MED_SMALL_BUFF)
v_line2.shift(1.7 * UP)
self.add(h_line, h_line2, h_line3, v_line, v_line2)
self.add(underlying, user_facing, btc)
self.play(Write(protocol))
self.dither(2)
self.play(card.restore, Write(dollar))
self.play(Write(banking))
self.dither(2)
self.play(DrawBorderThenFill(phone))
self.dither(2)
def show_diameter(self):
exceptions = [
self.circle, self.tangent_line, self.pc_line,
self.right_angle_symbol
]
everything = set(self.mobjects).difference(exceptions)
everything_copy = Mobject(*everything).copy()
light_everything = everything_copy.copy()
dark_everything = everything_copy.copy()
dark_everything.fade(0.8)
bottom_point = np.array(self.c_point)
bottom_point += 2 * self.radius * DOWN
diameter = Line(bottom_point, self.c_point)
brace = Brace(diameter, RIGHT)
diameter_word = TextMobject("Diameter")
d_mob = TexMobject("D")
diameter_word.next_to(brace)
d_mob.next_to(diameter)
self.remove(*everything)
self.play(Transform(everything_copy, dark_everything))
self.dither()
self.play(ShowCreation(diameter))
self.play(GrowFromCenter(brace))
self.play(ShimmerIn(diameter_word))
self.dither()
self.play(*[Transform(mob, d_mob) for mob in brace, diameter_word])
self.remove(brace, diameter_word)
self.add(d_mob)
self.play(Transform(everything_copy, light_everything))
self.remove(everything_copy)
self.add(*everything)
self.d_mob = d_mob
self.bottom_point = bottom_point
def show_derivative(self):
deriv = TexMobject("\\frac{df}{dx}")
deriv.next_to(self.graph_label, DOWN, MED_LARGE_BUFF)
deriv.highlight(self.deriv_color)
ss_group = self.get_secant_slope_group(
1, self.graph,
dx = 0.01,
secant_line_color = self.deriv_color
)
self.play(
Write(deriv),
*map(ShowCreation, ss_group)
)
self.animate_secant_slope_group_change(
ss_group, target_x = self.x3,
run_time = 5
)
self.wait()
self.animate_secant_slope_group_change(
ss_group, target_x = self.x2,
run_time = 3
)
self.wait()
self.ss_group = ss_group
self.deriv = deriv
def show_proportionality_to_dx_squared(self):
ddf = self.ddf.copy()
ddf.generate_target()
ddf.target.next_to(self.ddf, UP, LARGE_BUFF)
rhs = TexMobject(
"\\approx", "(\\text{Some constant})", "(dx)^2"
)
rhs.scale(0.8)
rhs.next_to(ddf.target, RIGHT)
example_dx = TexMobject(
"dx = 0.01 \\Rightarrow (dx)^2 = 0.0001"
)
example_dx.scale(0.8)
example_dx.to_corner(UP+RIGHT)
self.play(MoveToTarget(ddf))
self.play(Write(rhs))
self.wait()
self.play(Write(example_dx))
self.wait(2)
self.play(FadeOut(example_dx))
self.ddf = ddf
self.dx_squared = rhs.get_part_by_tex("dx")
def refocus_on_euler_sum(self):
self.euler_sum.add(self.pi_answer)
self.play(
FadeOut(self.leibniz_sum), FadeOut(self.wallis_product),
ApplyMethod(self.euler_sum.shift,
ORIGIN + 2 * UP - self.euler_sum.get_center()))
# focus on pi squared
pi_squared = self.euler_sum.get_part_by_tex("\\pi")[-3]
self.play(ScaleInPlace(pi_squared, 2, rate_func=wiggle))
# Morty thinks of a circle
q_circle = Circle(stroke_color=YELLOW,
fill_color=YELLOW,
fill_opacity=0.5,
radius=0.4,
stroke_width=10.0)
q_mark = TexMobject("?")
q_mark.next_to(q_circle)
thought = Group(q_circle, q_mark)
q_mark.scale_to_fit_height(0.8 * q_circle.get_height())
self.pi_creature_thinks(thought,
target_mode="confused",
bubble_kwargs={
"height": 2,
"width": 3
})
self.wait()
def show_y(self):
y_equals = TexMobject(["y", "="])
y_equals.shift(2*UP)
y_expression = TexMobject([
"D ", "\\sin", "^2", "(\\theta)"
])
y_expression.next_to(y_equals)
y_expression.shift(0.05*UP+0.1*RIGHT)
temp_expr = self.d_sin_squared_theta.copy()
temp_expr.rotate(-np.pi/2)
temp_expr.replace(y_expression)
y_mob = TexMobject("y")
y_mob.next_to(self.y_line, RIGHT)
y_mob.shift(0.2*UP)
self.play(
Transform(self.d_sin_squared_theta, temp_expr),
ShimmerIn(y_mob),
ShowCreation(y_equals)
)
self.remove(self.d_sin_squared_theta)
self.add(y_expression)
self.y_equals = y_equals
self.y_expression = y_expression
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 write_second_derivative(self):
second_deriv = TexMobject("\\frac{d^2 f}{dx^2}")
second_deriv.next_to(self.deriv, DOWN, MED_LARGE_BUFF)
second_deriv.highlight(self.second_deriv_color)
points = [
self.input_to_graph_point(x, self.graph) for x in self.x2, self.x3
]
words = TextMobject("Change to \\\\ slope")
words.next_to(center_of_mass(points), UP, 1.5 * LARGE_BUFF)
arrows = [Arrow(words.get_bottom(), p, color=WHITE) for p in points]
self.play(Write(second_deriv))
self.wait()
self.play(Write(words),
ShowCreation(arrows[0],
rate_func=squish_rate_func(smooth, 0.5, 1)),
run_time=2)
self.animate_secant_slope_group_change(self.ss_group,
target_x=self.x3,
run_time=3,
added_anims=[
Transform(*arrows,
run_time=3,
path_arc=0.75 *
np.pi),
])
self.play(FadeOut(arrows[0]))
self.animate_secant_slope_group_change(
self.ss_group,
target_x=self.x2,
run_time=3,
)
self.second_deriv_words = words
self.second_deriv = second_deriv
def construct(self):
series = VideoSeries()
series.to_edge(UP)
this_video = series[3]
next_video = series[4]
brace = Brace(this_video, DOWN)
this_video.save_state()
this_video.highlight(YELLOW)
this_tex = TexMobject(
"{d(", "a^t", ") \\over dt} = ", "a^t", "\\ln(a)"
)
this_tex[1][1].highlight(YELLOW)
this_tex[3][1].highlight(YELLOW)
this_tex.next_to(brace, DOWN)
next_tex = VGroup(*map(TextMobject, [
"Chain rule", "Product rule", "$\\vdots$"
]))
next_tex.arrange_submobjects(DOWN)
next_tex.next_to(brace, DOWN)
next_tex.shift(
next_video.get_center()[0]*RIGHT\
-next_tex.get_center()[0]*RIGHT
)
self.add(series, brace, *this_tex[:3])
self.change_student_modes(
"confused", "pondering", "erm",
look_at_arg = this_tex
)
self.play(ReplacementTransform(
this_tex[1].copy(), this_tex[3]
))
self.dither()
self.play(
Write(this_tex[4]),
ReplacementTransform(
this_tex[3][0].copy(),
this_tex[4][3],
path_arc = np.pi,
remover = True
)
)
self.dither(2)
self.play(this_tex.replace, this_video)
self.play(
brace.next_to, next_video, DOWN,
this_video.restore,
Animation(this_tex),
next_video.highlight, YELLOW,
Write(next_tex),
self.get_teacher().change_mode, "raise_right_hand"
)
self.change_student_modes(
*["pondering"]*3,
look_at_arg = next_tex
)
self.dither(3)
def construct(self):
but = TextMobject("but")
dots = TexMobject("\\dots")
dots.next_to(but, aligned_edge = DOWN)
but.shift(20*RIGHT)
self.play(ApplyMethod(but.shift, 20*LEFT))
self.play(Write(dots, run_time = 5))
self.dither()
def get_axis_labels(self, x_label = "x", y_label = "y"):
x_axis, y_axis = self.get_axes().split()
x_label_mob = TexMobject(x_label)
y_label_mob = TexMobject(y_label)
x_label_mob.next_to(x_axis, DOWN)
x_label_mob.to_edge(RIGHT)
y_label_mob.next_to(y_axis, RIGHT)
y_label_mob.to_edge(UP)
return VMobject(x_label_mob, y_label_mob)
def get_kilogoogle(self):
G = self.get_google_logo()[-1]
kilo = TextMobject("K")
kilo.scale(1.5)
kilo.next_to(G[-1], LEFT, SMALL_BUFF, DOWN)
plus_plus = TexMobject("++")
plus_plus.set_stroke(width = 1)
plus_plus.next_to(G, RIGHT, SMALL_BUFF)
return VGroup(kilo, G, plus_plus)
def reset(self):
time = self.t_expression[-1]
faders = [time] + list(self.get_on_screen_pi_creatures())
new_time = TexMobject("0")
new_time.next_to(self.t_expression[-2], RIGHT)
first_creature = self.get_pi_creatures()[0]
self.play(*map(FadeOut, faders))
self.play(*map(FadeIn, [first_creature, new_time]))
self.t_expression.submobjects[-1] = new_time
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.dither()
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.dither()
brace = Brace(d_sqrt, DOWN)
constant = TextMobject("Constant")
constant.next_to(brace, DOWN)
self.play(
GrowFromCenter(brace),
ShimmerIn(constant)
)
def shift_to_good_and_back(self):
sum2 = self.sum1.copy()
sigma = sum2.submobjects[1]
plus = TexMobject("+").replace(sigma)
sum2.submobjects[1] = plus
prod2 = self.prod1.copy()
pi = prod2.submobjects[0]
times = TexMobject("\\times").replace(pi)
prod2.submobjects[0] = times
new_sin, new_cos, new_tan = [
VMobject().set_anchor_points(
corners, mode = "corners"
).replace(trig_part.split()[0])
for corners, trig_part in zip(
[
[RIGHT, RIGHT+UP, LEFT],
[RIGHT+UP, LEFT, RIGHT],
[RIGHT+UP, RIGHT, LEFT],
],
self.trigs1.split()
)
]
x1, x2, x3 = [
trig_part.split()[1]
for trig_part in self.trigs1.split()
]
trigs2 = VMobject(
VMobject(new_sin, x1),
VMobject(new_cos, x2),
VMobject(new_tan, x3),
)
x, arrow, y = TexMobject("x \\rightarrow y").split()
f = TexMobject("f")
f.next_to(arrow, UP)
func2 = VMobject(f, VMobject(), x, VMobject(), arrow, y)
func2.scale(0.5)
func2.shift(self.func1.get_center())
good_symbols = VMobject(sum2, prod2, trigs2, func2)
bad_symbols = self.symbols.copy()
self.play(Transform(
self.symbols, good_symbols,
path_arc = np.pi
))
self.dither(3)
self.play(Transform(
self.symbols, bad_symbols,
path_arc = np.pi
))
self.dither()
def generate_points(self):
index = int(self.cycloid_fraction*self.cycloid.get_num_points())
p_point = self.cycloid.points[index]
p_dot = Dot(p_point)
p_label = TexMobject("P")
p_label.next_to(p_dot, DOWN+LEFT)
c_point = self.point_a + self.cycloid_fraction*self.radius*2*np.pi*RIGHT
c_dot = Dot(c_point)
c_label = TexMobject("C")
c_label.next_to(c_dot, UP)
digest_locals(self)
def isolate_bend_points(self):
arc_radius = 0.1
self.activate_zooming()
little_square = self.get_zoomed_camera_mobject()
for index in range(3):
bend_point = self.bend_points[index]
line = Line(
bend_point+DOWN,
bend_point+UP,
color = WHITE,
density = self.zoom_factor*DEFAULT_POINT_DENSITY_1D
)
angle_arcs = []
for i, rotation in [(index, np.pi/2), (index+1, -np.pi/2)]:
arc = Arc(angle = self.path_angles[i])
arc.scale(arc_radius)
arc.rotate(rotation)
arc.shift(bend_point)
angle_arcs.append(arc)
thetas = []
for i in [index+1, index+2]:
theta = TexMobject("\\theta_%d"%i)
theta.scale(0.5/self.zoom_factor)
vert = UP if i == index+1 else DOWN
horiz = rotate_vector(vert, np.pi/2)
theta.next_to(
Point(bend_point),
horiz,
buff = 0.01
)
theta.shift(1.5*arc_radius*vert)
thetas.append(theta)
figure_marks = [line] + angle_arcs + thetas
self.play(ApplyMethod(
little_square.shift,
bend_point - little_square.get_center(),
run_time = 2
))
self.play(*map(ShowCreation, figure_marks))
self.dither()
equation_frame = little_square.copy()
equation_frame.scale(0.5)
equation_frame.shift(
little_square.get_corner(UP+RIGHT) - \
equation_frame.get_corner(UP+RIGHT)
)
equation_frame.scale_in_place(0.9)
self.show_snells(index+1, equation_frame)
self.remove(*figure_marks)
self.disactivate_zooming()
def solve_energy(self):
loss_in_potential = TextMobject("Loss in potential: ")
loss_in_potential.shift(2*UP)
potential = TexMobject("m g y".split())
potential.next_to(loss_in_potential)
kinetic = TexMobject([
"\\dfrac{1}{2}","m","v","^2","="
])
kinetic.next_to(potential, LEFT)
nudge = 0.1*UP
kinetic.shift(nudge)
loss_in_potential.shift(nudge)
ms = Mobject(kinetic.split()[1], potential.split()[0])
two = TexMobject("2")
two.shift(ms.split()[1].get_center())
half = kinetic.split()[0]
sqrt = TexMobject("\\sqrt{\\phantom{2mg}}")
sqrt.shift(potential.get_center())
nudge = 0.2*LEFT
sqrt.shift(nudge)
squared = kinetic.split()[3]
equals = kinetic.split()[-1]
new_eq = equals.copy().next_to(kinetic.split()[2])
self.play(
Transform(
Point(loss_in_potential.get_left()),
loss_in_potential
),
*map(GrowFromCenter, potential.split())
)
self.dither(2)
self.play(
FadeOut(loss_in_potential),
GrowFromCenter(kinetic)
)
self.dither(2)
self.play(ApplyMethod(ms.shift, 5*UP))
self.dither()
self.play(Transform(
half, two,
path_func = counterclockwise_path()
))
self.dither()
self.play(
Transform(
squared, sqrt,
path_func = clockwise_path()
),
Transform(equals, new_eq)
)
self.dither(2)
def standard_basis_comparison(self, label_anims, scalar_anims):
everything = self.get_mobjects()
everything.remove(self.sum_vector)
everything = VMobject(*everything)
alt_coords = [a.mobject for a in scalar_anims]
array = Matrix([
mob.copy().highlight(color)
for mob, color in zip(
alt_coords,
[self.vector1_color, self.vector2_color]
)
])
array.scale(0.8)
array.to_edge(UP)
array.shift(RIGHT)
brackets = array.get_brackets()
anims = [
Transform(*pair)
for pair in zip(alt_coords, array.get_mob_matrix().flatten())
]
# anims += [
# FadeOut(a.mobject)
# for a in label_anims
# ]
self.play(*anims + [Write(brackets)])
self.dither()
self.remove(brackets, *alt_coords)
self.add(array)
self.play(
FadeOut(everything),
Animation(array),
)
self.add_axes(animate = True)
ij_array, x_line, y_line = self.vector_to_coords(
self.sum_vector, integer_labels = False
)
self.add(ij_array, x_line, y_line)
x, y = ij_array.get_mob_matrix().flatten()
self.play(
ApplyMethod(x.highlight, X_COLOR),
ApplyMethod(y.highlight, Y_COLOR),
)
neq = TexMobject("\\neq")
neq.next_to(array)
self.play(
ApplyMethod(ij_array.next_to, neq),
Write(neq)
)
self.dither()
def construct(self):
two_dot = TexMobject("2\\cdot")
equals = TexMobject("=")
self.add_axes()
v = self.add_vector([3, 1])
v_coords, vx_line, vy_line = self.vector_to_coords(v, cleanup = False)
self.play(ApplyMethod(v_coords.to_edge, UP))
two_dot.next_to(v_coords, LEFT)
equals.next_to(v_coords, RIGHT)
two_v = self.add_vector([6, 2], animate = False)
self.remove(two_v)
self.play(
Transform(v.copy(), two_v),
Write(two_dot, run_time = 1)
)
two_v_coords, two_v_x_line, two_v_y_line = self.vector_to_coords(
two_v, cleanup = False
)
self.play(
ApplyMethod(two_v_coords.next_to, equals, RIGHT),
Write(equals, run_time = 1)
)
self.dither(2)
x, y = v_coords.get_mob_matrix().flatten()
two_v_elems = two_v_coords.get_mob_matrix().flatten()
x_sym, y_sym = map(TexMobject, ["x", "y"])
two_x_sym, two_y_sym = map(TexMobject, ["2x", "2y"])
VMobject(x_sym, two_x_sym).highlight(X_COLOR)
VMobject(y_sym, two_y_sym).highlight(Y_COLOR)
syms = [x_sym, y_sym, two_x_sym, two_y_sym]
VMobject(*syms).scale(VECTOR_LABEL_SCALE_VAL)
for sym, num in zip(syms, [x, y] + list(two_v_elems)):
sym.move_to(num)
self.play(
Transform(x, x_sym),
Transform(y, y_sym),
FadeOut(VMobject(*two_v_elems))
)
self.dither()
self.play(
Transform(
VMobject(two_dot.copy(), x.copy()),
two_x_sym
),
Transform(
VMobject(two_dot.copy(), y.copy() ),
two_y_sym
)
)
self.dither(2)
def show_dfs(self):
dx_lines = VGroup()
df_lines = VGroup()
df_dx_groups = VGroup()
df_labels = VGroup()
for i, v_line1, v_line2 in zip(it.count(1), self.v_lines, self.v_lines[1:]):
dx_line = Line(
v_line1.get_bottom(),
v_line2.get_bottom(),
color = GREEN
)
dx_line.move_to(v_line1.get_top(), LEFT)
dx_lines.add(dx_line)
df_line = Line(
dx_line.get_right(),
v_line2.get_top(),
color = YELLOW
)
df_lines.add(df_line)
df_label = TexMobject("df_%d"%i)
df_label.highlight(YELLOW)
df_label.scale(0.8)
df_label.next_to(df_line.get_center(), UP+LEFT, MED_LARGE_BUFF)
df_arrow = Arrow(
df_label.get_bottom(),
df_line.get_center(),
buff = SMALL_BUFF,
)
df_line.label = df_label
df_line.arrow = df_arrow
df_labels.add(df_label)
df_dx_groups.add(VGroup(df_line, dx_line))
for brace, dx_line, df_line in zip(self.braces, dx_lines, df_lines):
self.play(
VGroup(brace, brace.dx).next_to,
dx_line, DOWN, SMALL_BUFF,
FadeIn(dx_line),
)
self.play(ShowCreation(df_line))
self.play(
ShowCreation(df_line.arrow),
Write(df_line.label)
)
self.dither(2)
self.df_dx_groups = df_dx_groups
self.df_labels = df_labels
def get_number_mob(self, num):
result = VGroup()
place = 0
max_place = self.max_place
while place < max_place:
digit = TexMobject(str(self.get_place_num(num, place)))
if place >= len(self.digit_place_colors):
self.digit_place_colors += self.digit_place_colors
digit.highlight(self.digit_place_colors[place])
digit.scale(self.num_scale_factor)
digit.next_to(result, LEFT, buff = SMALL_BUFF, aligned_edge = DOWN)
result.add(digit)
place += 1
return result
def construct(self):
sine = TexMobject("\\sin(x)")
triangle = Polygon(ORIGIN, 2*RIGHT, 2*RIGHT+UP)
arrow = DoubleArrow(LEFT, RIGHT)
sine.next_to(arrow, LEFT)
triangle.next_to(arrow, RIGHT)
q_mark = TextMobject("?").scale(1.5)
q_mark.next_to(arrow, UP)
self.add(sine)
self.play(ShowCreation(arrow))
self.play(ShowCreation(triangle))
self.play(Write(q_mark))
self.dither()
def get_axis_labels(self, x_label = "x", y_label = "y"):
x_axis, y_axis = self.get_axes().split()
quads = [
(x_axis, x_label, UP, RIGHT),
(y_axis, y_label, RIGHT, UP),
]
labels = VGroup()
for axis, tex, vect, edge in quads:
label = TexMobject(tex)
label.add_background_rectangle()
label.next_to(axis, vect)
label.to_edge(edge)
labels.add(label)
self.axis_labels = labels
return labels
