def generate_points(self):
hollow_tri = HollowTriangle(**self.triangle_config)
bang = TexMobject("!")
bang.set_height(hollow_tri.inner_height * 0.7)
bang.move_to(hollow_tri.get_center_of_mass())
self.add(hollow_tri, bang)
self.set_color(self.color)
def get_coordinate_labels(self, *numbers):
# TODO: Should merge this with the code from NumberPlane.get_coordinate_labels
result = VGroup()
if len(numbers) == 0:
numbers = list(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) if y != 0
]
for number in numbers:
# if number == complex(0, 0):
# continue
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.set_height(self.written_coordinate_height)
num_mob.next_to(point, DOWN + LEFT, SMALL_BUFF)
result.add(num_mob)
self.coordinate_labels = result
return result
def construct(self):
exp_tower = ExpTower(element = "x", order = 10)
exp_tower.set_height(6)
exp_tower.gradient_highlight(YELLOW, BLUE)
two, equal_sign, four = equation = TexMobject("2", "=", "4")
two.set_color(GREEN)
four.set_color(RED)
equation.scale(10)
question_mark = TexMobject("?")
question_mark.set_height(2)
question_mark.next_to(equal_sign, UP, buff = 0.5)
notations = VGroup(*[
TexMobject("{}^{\\infty} x"),
TexMobject("x \\uparrow \\uparrow \\infty"),
])
for notation, num, direction, angle, color in \
zip(notations, [two, four], [UP+RIGHT, DOWN+LEFT], [-TAU/15, TAU/24], [YELLOW, BLUE]):
notation.scale(3)
notation.rotate(angle)
notation.next_to(num, direction)
notation.set_color(color)
self.add(exp_tower, notations)
self.add(FullScreenFadeRectangle())
self.add(equation, question_mark)
def generate_points(self):
start_angle = np.pi / 2 + self.arc_angle / 2
end_angle = np.pi / 2 - self.arc_angle / 2
self.add(Arc(start_angle=start_angle, angle=-self.arc_angle))
tick_angle_range = np.linspace(start_angle, end_angle, self.num_ticks)
for index, angle in enumerate(tick_angle_range):
vect = rotate_vector(RIGHT, angle)
tick = Line((1 - self.tick_length) * vect, vect)
label = TexMobject(str(10 * index))
label.set_height(self.tick_length)
label.shift((1 + self.tick_length) * vect)
self.add(tick, label)
needle = Polygon(LEFT,
UP,
RIGHT,
stroke_width=0,
fill_opacity=1,
fill_color=self.needle_color)
needle.stretch_to_fit_width(self.needle_width)
needle.stretch_to_fit_height(self.needle_height)
needle.rotate(start_angle - np.pi / 2, about_point=ORIGIN)
self.add(needle)
self.needle = needle
self.center_offset = self.get_center()
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 generate_symbol(self):
symbol = TexMobject("\\checkmark")
symbol.set_color(self.color)
symbol.set_height(self.inner_radius)
return symbol
def show_the_solution(self):
# Prepare for the solution
pre_solve = VGroup(*self.question[::2])
self.play(
ReplacementTransform(pre_solve, self.solve),
FadeOut(self.question[1]),
run_time = 1,
)
self.wait()
# Manipulate LHS
old_l_part, r_part = self.equation
new_l_part = ExpTower(order = self.highest_order+1, is_infinite = True)
new_l_part.match_height(old_l_part)
new_l_part.next_to(r_part, LEFT, aligned_edge = DOWN)
old_rect, new_rect = rects = [
CoverRectangle(part, text = "2")
for part in (old_l_part, new_l_part.get_exponent())
]
old_two, new_two = twos = [
rect.get_text_mob()
for rect in rects
]
self.play(DrawBorderThenFill(old_rect, run_time = 1))
self.wait()
self.play(
ReplacementTransform(old_l_part, new_l_part),
ReplacementTransform(old_rect, new_rect),
)
self.wait()
new_equation = VGroup(new_l_part, r_part, new_rect)
new_equation.generate_target()
new_equation.target.scale(0.8)
new_equation.target.shift(UP)
self.play(MoveToTarget(new_equation))
self.wait()
# A little bit clean-up
source_eq = VGroup(*[
mob.copy()
for mob in (new_l_part.get_base(), new_two, r_part[0], r_part[1])
])
source_eq.generate_target()
target_eq = TexMobject("x", "^2", "=", "2")
target_eq.scale(3).next_to(source_eq, DOWN, buff = 1)
for k, (old_part, new_part) in enumerate(zip(source_eq.target, target_eq)):
old_part.move_to(new_part)
if k == 1:
old_part.scale(0.5)
old_part.shift(RIGHT/4)
self.play(
FadeOut(new_rect),
MoveToTarget(source_eq),
)
self.wait()
# Reveal the final answer
result = TexMobject("x", "=", "\\sqrt", "2")
result.set_height(source_eq.get_height() * 0.7)
result.move_to(source_eq)
self.play(*[
ReplacementTransform(source_eq[m], result[n], path_arc = angle)
for m, n, angle in [(0, 0, 0), (1, 2, -TAU/3), (2, 1, 0), (3, 3, 0)]
])
self.wait()
qed = QEDSymbol()
qed.next_to(result, RIGHT, aligned_edge = DOWN, buff = 1.5)
self.play(FadeIn(qed))
self.wait()
