public-mirrors/3b1b-manim
1
0
Fork 0
mirror of https://github.com/3b1b/manim.git synced 2025-08-05 16:49:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
3b1b-manim/epii/epii_animations.py

1142 lines
37 KiB
Python
Raw Normal View History

post epii project state, without tex files
2015-03-22 13:33:02 -06:00
#!/usr/bin/env python
from PIL import Image
from animate import *
from mobject import *
from constants import *
from helpers import *
from tex_image_utils import load_pdf_images
from displayer import *
import itertools as it
import os
import numpy as np
from copy import deepcopy
PI_COLOR = "red"
E_COLOR = "skyblue"
I_COLOR = "green"
ADDER_COLOR = "limegreen"
MULTIPLIER_COLOR = "yellow"
ONE_COLOR = "skyblue"
EPII_MOVIE_DIR = "epii"
symbol_images = load_pdf_images("epii_symbols.pdf", regen_if_exists = False)
phrase_images = load_pdf_images("epii_phrases.pdf", regen_if_exists = False)
name_to_image = dict(
zip([
"e",
"pi",
"i",
"equals_neg1",
"pile_of_equations",
"two",
"plus",
"three",
"four",
"times",
"five",
"fours_underbrace",
"e_to_x",
"e_by_e_x_times",
"e_by_e_pi_i_times",
"e_to_x_property",
"e_to_x_series",
"e_to_5",
"e_to_sum_ones",
"e_to_1_product",
"e_to_x_plus_y",
"e_by_e_x_plus_y_times",
"x_es_then_y_es",
"e_to_x_e_to_y",
"i_squared_equals_neg_1",
"epii_series",
"e_to_complex",
"e_to_matrix",
"e_to_derivative",
"adder_to_multiplier_property",
"defining_property",
"e_by_e",
"e_by_e_by_e",
"e_def",
"e_approx",
"one",
"sqrt_neg1",
"e_digits",
"twenty",
"three_point_five",
"sqrt_two",
"six",
"e_to_2_value",
"e_to_3_value",
"e_to_5_value",
"zero",
"minus",
"neg_1",
"to_the_x",
], symbol_images) + zip([
"e_question",
"pi_question",
"i_question",
"what",
"just_trust_it",
"ish",
"question_marks",
"not_what_is_happening",
"what_it_means",
"why_it_works",
"why_it_is_intuitive",
"colon_explanation",
"adder",
"multiplier",
"other_way_around",
"how_do_we_define_this",
"unlearn_what_you_have_learned",
"e_in_nature",
], phrase_images)
)
def logo_to_epii():
e, pi, i, equals_neg1 = [
ImageMobject(name_to_image[name])
for name in [
"e", "pi", "i", "equals_neg1"
]
]
epii_neg1 = CompoundMobject(e, pi, i, equals_neg1)
epii_neg1.center().shift((0, 2, 0))
# stars = Stars()
return Transform(
ImageMobject(LOGO_PATH, invert = False),
epii_neg1,
dither_time = 0, run_time = 2.0,
).then(
Animation(epii_neg1)
)
# .then(
# Transform(
# stars,
# epii_neg1,
# dither_time = 0, run_time = 3.0,
# )
def write_epii():
e, pi, i, equals_neg1 = [
ImageMobject(name_to_image[name])
for name in ["e", "pi", "i", "equals_neg1"]
]
center = CompoundMobject(e, pi, i, equals_neg1).get_center()
for mob in e, pi, i, equals_neg1:
mob.shift(-center)
anims=[
ShowCreation(e),
ShowCreation(pi).with_background(e),
ShowCreation(i).with_background(e, pi),
ShowCreation(equals_neg1).with_background(e, pi, i),
]
for anim in anims:
anim.set_run_time(1.0)
for anim in anims[1:]:
anim.set_dither(1)
anims[0].then(anim)
return anims[0]
def the_terms():
e, pi, i, one, e_digits, sqrt_neg1, equals_neg1 = [
ImageMobject(name_to_image[name])
for name in [
"e", "pi", "i", "one", "e_digits",
"sqrt_neg1", "equals_neg1"
]
]
center = CompoundMobject(e, pi, i, equals_neg1).get_center()
for mob in [e, pi, i, equals_neg1]:
mob.shift(-center + (0, 2, 0))
colored_e = deepcopy(e).highlight(E_COLOR)
colored_pi = deepcopy(pi).highlight(PI_COLOR)
colored_i = deepcopy(i).highlight(I_COLOR)
e_digits.highlight(E_COLOR)
sqrt_neg1.highlight(I_COLOR)
e_digits.shift([2, -2, 0])
sqrt_neg1.shift([2, 2, 0])
pi_copy = deepcopy(colored_pi)
pi_copy.scale(1.5)
pi_copy.center()
pi_copy.shift([-0.8, 0, 0])
one.center()
one.shift([0.2, 0, 0])
long_line = ParametricFunction(lambda t : (-1, np.pi * t, 0))
diameter = ParametricFunction(lambda t : (0, t, 0))
circle = Circle()
for mobject in [circle, diameter, one, long_line, pi_copy]:
mobject.shift([-1, 0, 0])
mobject.highlight(PI_COLOR)
return Transform(
CompoundMobject(e, pi, i, equals_neg1),
CompoundMobject(colored_e, colored_pi, colored_i, equals_neg1)
).then(
Transform(
colored_e, e_digits
).while_also(
Transform(
colored_i, sqrt_neg1
)
).while_also(
Transform(
colored_pi, pi_copy
)
).while_also(
Transform(
circle, long_line,
)
).with_background(
diameter, one, colored_e, colored_pi, colored_i, equals_neg1
)
)
def literal_epii():
e, pi, i, e_by_e_pi_i_times, what = [
ImageMobject(name_to_image[name])
for name in [
"e", "pi", "i", "e_by_e_pi_i_times", "what"
]
]
what.shift([0, -1, 0])
return Transform(
CompoundMobject(e, pi, i).center().shift((0, 2, 0)),
e_by_e_pi_i_times
).then(
Animation(what, run_time = 2.1).with_background(
e_by_e_pi_i_times
)
)
def pile_of_equations():
return ShowCreation(
CompoundMobject(
ImageMobject(name_to_image["pile_of_equations"]).center(),
ImageMobject(
name_to_image["just_trust_it"]
).center().shift([2, -3, 0]).highlight("red")
),
alpha_func = None,
run_time = 5.0
)
def confusion_of_terms():
e, pi, i, e_question, pi_question, i_question, what_it_means = [
ImageMobject(name_to_image[name])
for name in [
"e", "pi", "i", "e_question", "pi_question", "i_question", "what_it_means"
]
]
colored_e = deepcopy(e).highlight(E_COLOR)
colored_pi = deepcopy(pi).highlight(PI_COLOR)
colored_i = deepcopy(i).highlight(I_COLOR)
e_question.highlight(E_COLOR).shift([2, 1, 0])
pi_question.highlight(PI_COLOR).shift([0, -1, 0])
i_question.highlight(I_COLOR).shift([-1, 0, 0])
what_it_means.center().shift((-3, 0, 0))
stars = Stars()
e_anim = Transform(colored_e, e_question)
e_anim.with_background(colored_pi, colored_i)
i_anim = Transform(colored_i, i_question)
i_anim.with_background(e_question, colored_pi)
pi_anim = Transform(colored_pi, pi_question)
pi_anim.with_background(e_question, i_question)
all_questions = CompoundMobject(e_question, pi_question, i_question)
to_stars = Transform(
all_questions,
stars, run_time = 5.0, dither_time = 0
)
stall_1 = Animation(all_questions)
to_goal = Transform(stars, what_it_means, dither_time = 0, run_time = 2.0)
for anim in [e_anim, i_anim, pi_anim]:
anim.set_run_time(1.0)
anim.set_dither(0)
for anim in [i_anim, pi_anim, stall_1, to_stars, to_goal]:
e_anim.then(anim)
return e_anim
def list_of_goals():
goals = [
ImageMobject(name_to_image[name]).center()
for name in [
"what_it_means", "why_it_works", "why_it_is_intuitive"
]
]
for x in range(3):
goals[x].shift((3*(x - 1), 0, 0))
stars = Stars()
rotating_stars = Rotating(stars, radians = np.pi / 3)
return Transform(stars, goals[0]).while_also(
rotating_stars, display = False
).then(
Reveal(goals[1], dither_time = 0).with_background(goals[0])
).then(
Reveal(goals[2]).with_background(*goals[:2])
)
def not_repeated_multiplication():
e_to_x, e_by_e_x_times, not_what_is_happening = [
ImageMobject(name_to_image[name]).center()
for name in ["e_to_x", "e_by_e_x_times", "not_what_is_happening"]
]
not_what_is_happening.rotate(np.pi/7).highlight("red")
return Transform(e_to_x, e_by_e_x_times).then(
Reveal(not_what_is_happening).with_background(e_by_e_x_times)
).then(
Animation(
CompoundMobject(e_by_e_x_times, not_what_is_happening),
run_time = 1.0
)
)
def problems_with_repeated_multiplication():
e, e_by_e, e_by_e_by_e, e_def, how_do_we_define_this = [
ImageMobject(name_to_image[name]).center()
for name in ["e", "e_by_e", "e_by_e_by_e",
"e_def", "how_do_we_define_this"]
]
how_do_we_define_this.highlight(E_COLOR).shift((0, -1, 0))
kwargs = {"run_time" : 0.2, "dither_time" : 0.5}
return Transform(e, e_by_e, **kwargs).then(
Transform(e_by_e, e_by_e_by_e, **kwargs)
).then(
Transform(e_by_e_by_e, e_def).while_also(
Reveal(how_do_we_define_this)
)
)
def numbers_as_actions():
three = ImageMobject(name_to_image["three"]).center()
sphere = Sphere().scale(2).highlight(MULTIPLIER_COLOR)
def custom_alpha(t):
return high_inflection_0_to_1(1.7 * t * (1 - t))
return Transform(
three, sphere, run_time = 3.0,
alpha_func = custom_alpha
).while_also(
Rotating(sphere, radians = 10 * np.pi),
display = False
)
def numbers_as_counting():
three = ImageMobject(name_to_image["three"])
three.center()
spheres = CompoundMobject(*[
Sphere().scale(0.5).shift([x - 1, 0, 0])
for x in range(3)
])
return Transform(
three, spheres,
).while_also(
Rotating(spheres, axis = [1, 0, 0]),
display = False
)
def addition_by_counting():
two, plus, three, five = [
ImageMobject(name_to_image[name])
for name in [
"two", "plus", "three", "five"
]
]
tps_center = CompoundMobject(two, plus, three).get_center()
for mob in two, plus, three:
mob.shift(tps_center)
five.center()
spheres = []
for x in range(5):
spheres.append(Sphere().scale(0.5).shift([x-2, 0, 0]))
first_two = CompoundMobject(*spheres[:2])
last_three = CompoundMobject(*spheres[2:])
all_five = CompoundMobject(*spheres)
plus_three = CompoundMobject(plus, three)
return Animation(
CompoundMobject(two, plus_three),
run_time = 2.0, dither_time = 0.0,
).then(
Transform(
two, first_two,
).set_dither(0).with_background(
plus_three
)
).then(
Transform(
plus_three, last_three,
).with_background(first_two).set_dither(0)
).then(
Transform(
all_five, five,
).set_dither(0)
).then(
Animation(five, run_time = 1.0, dither_time = 0.0)
)
def multiplication_by_counting():
four, times, five, fours_underbrace, twenty = [
ImageMobject(name_to_image[name])
for name in [
"four", "times", "five", "fours_underbrace", "twenty"
]
]
spheres = CompoundMobject(*[
Sphere().scale(0.5).shift([1.5*x-3, 1.5-y, 0])
for y in range(4)
for x in range(5)
])
fours_underbrace.center()
twenty.center()
rot_spheres = Rotating(spheres, axis = [1, 0, 0], radians = np.pi)
four_times_five = CompoundMobject(four, times, five).center()
first = Transform(four_times_five, fours_underbrace).set_dither(0.5)
second = Transform(copy.deepcopy(fours_underbrace), spheres).set_dither(0)
second.while_also(rot_spheres, display = False).generate_frames()
third = Transform(spheres, twenty).set_dither(0.5)
third.while_also(rot_spheres, display = False)
return first.then(second).then(third)
def fraction_counting():
three_point_five = ImageMobject(name_to_image["three_point_five"]).center()
spheres = [
Sphere().scale(0.5).shift([x-1.5, 0, 0])
for x in range(4)
]
num_points = spheres[-1].get_num_points()
for attr in ['points', 'rgbs']:
setattr(
spheres[-1], attr,
getattr(spheres[-1], attr)[:num_points/2, :]
)
spheres = CompoundMobject(*spheres)
spheres.rotate(np.pi/4, [1, 0, 0])
return Transform(
three_point_five, spheres,
).while_also(
Rotating(spheres, axis = [1, 0, 0], radians = np.pi),
display = False
)
def irrational_counting():
sqrt_two = ImageMobject(name_to_image["sqrt_two"]).center()
ish = ImageMobject(name_to_image["ish"]).center()
spheres = [
Sphere().scale(0.5).rotate(np.pi/4, [1, 0, 0]).shift([x-0.5, 0, 0])
for x in range(2)
]
num_points = spheres[-1].get_num_points()
for attr in ['points', 'rgbs']:
setattr(
spheres[-1], attr,
getattr(spheres[-1], attr)[:int(num_points*(np.sqrt(2)-2)), :]
)
ish.shift([1.3, 0, 0])
spheres = CompoundMobject(ish, *spheres)
return Transform(
sqrt_two, spheres
).while_also(
Rotating(spheres, axis = [1, 0, 0], radians = np.pi),
display = False
)
def imaginary_counting():
sqrt_neg1, question_marks = [
ImageMobject(name_to_image[name]).center()
for name in ["sqrt_neg1", "question_marks"]
]
return Transform(sqrt_neg1, question_marks)
def real_number_as_three_things():
three, adder, multiplier = [
ImageMobject(name_to_image[name]).center()
for name in ["three", "adder", "multiplier"]
]
adder_three = copy.deepcopy(three).highlight(ADDER_COLOR)
mult_three = copy.deepcopy(three).highlight(MULTIPLIER_COLOR)
three.shift([0, 2, 0])
adder_three.shift([-1, 2, 0])
mult_three.shift([1, 2, 0])
adder.highlight(ADDER_COLOR).shift((2, 2, 0))
multiplier.highlight(MULTIPLIER_COLOR).shift((2, 2, 0))
radius = 2 * SPACE_WIDTH
marked_number_line = NumberLine(
radius = radius,
with_numbers = True
)
number_line = NumberLine(radius = radius)
three_dist = 3 * number_line.interval_size
split_three = Transform(
copy.deepcopy(three),
CompoundMobject(three, adder_three, mult_three)
)
adder_three.center().shift(three.get_center())
mult_three.center().shift(three.get_center())
draw_number_line = ShowCreation(marked_number_line)
three_to_point = Transform(
copy.deepcopy(three),
Point((three_dist, 0, 0))
)
add_by_three = ApplyFunction(
lambda (x, y, z) : (three_dist+x, y, z),
number_line, dither_time = 2.0
).while_also(Reveal(adder, dither_time = 2.0))
multiply_by_three = ApplyFunction(
lambda (x, y, z) : (3*x, y, z),
number_line, dither_time = 2.0
).while_also(Reveal(multiplier, dither_time = 2.0))
draw_number_line.set_dither(0)
return split_three.then(
draw_number_line.with_background(three)
).then(
add_by_three.with_background(adder_three)
).then(
multiply_by_three.with_background(mult_three)
)
def wrong_adder_conception():
vert_disp = -0.3
number_line = NumberLine(radius = SPACE_WIDTH + 3)
nlis = number_line.interval_size
three = ImageMobject(name_to_image["three"])
three.center().shift((0, 2, 0)).highlight(ADDER_COLOR)
initial_numbers = [
ImageMobject(
NAME_TO_IMAGE_FILE[str(x)]
).center().scale(0.5).shift((x*nlis, vert_disp, 0))
for x in range(-3, 4)
]
final_numbers = [
ImageMobject(
NAME_TO_IMAGE_FILE[str(x)]
).center().scale(0.5).shift((x*nlis, vert_disp, 0))
for x in range(0, 7)
]
dots1 = ImageMobject(NAME_TO_IMAGE_FILE["cdots"]).center()
dots2 = copy.deepcopy(dots1).shift((-4 * nlis, vert_disp, 0))
dots1.shift((4*nlis, vert_disp, 0))
number_line.add(dots1, dots2)
kwargs = {"run_time" : 2.0, "dither_time" : 1.0}
anim = ComplexFunction(lambda z : z + 3*nlis, number_line, **kwargs)
for init, final in zip(initial_numbers, final_numbers):
anim.while_also(Transform(init, final, **kwargs))
anim.while_also(
Transform(three, CompoundMobject(*final_numbers), **kwargs)
)
return anim
def real_addition_rule():
three = ImageMobject(name_to_image["three"]).center()
three.shift([0, 2, 0]).highlight(ADDER_COLOR)
marked_number_line = NumberLine(radius = 2 * SPACE_WIDTH, with_numbers = True)
number_line = NumberLine(radius = 2 * SPACE_WIDTH)
three_dist = 3 * number_line.interval_size
shifted_line = copy.deepcopy(number_line).shift((three_dist, 0, 0))
zero_arrow = Arrow().nudge().shift((0, -0.3, 0))
three_arrow = Arrow((three_dist, -0.3, 0)).nudge().highlight(ADDER_COLOR)
return Reveal(
CompoundMobject(zero_arrow, three_arrow)
).with_background(marked_number_line, three).then(
Transform(
CompoundMobject(number_line, zero_arrow),
CompoundMobject(shifted_line, three_arrow),
dither_time = 0, run_time = 3.0
).with_background(three, three_arrow)
).then(
Flash(three_arrow).with_background(shifted_line, three)
).then(
Animation(CompoundMobject(three_arrow, shifted_line, three))
)
def real_multiplication_rule():
three = ImageMobject(name_to_image["three"]).center()
three.shift([0, 2, 0]).highlight(MULTIPLIER_COLOR)
marked_number_line = NumberLine(with_numbers = True)
number_line = NumberLine()
three_dist = 3 * number_line.interval_size
stretched_line = copy.deepcopy(number_line)
stretched_line.points = np.array(
map(lambda (x, y, z) : (3*x, y, z), stretched_line.points)
)
zero_arrow = Arrow(direction = (0, 1, 0)).nudge().shift((0, -0.3, 0))
zero_arrow.highlight("white")
one_arrow = Arrow().nudge().shift((number_line.interval_size, -0.3, 0))
one_arrow.highlight(ONE_COLOR)
three_arrow = Arrow((three_dist, -0.3, 0)).nudge().highlight(MULTIPLIER_COLOR)
return Reveal(
CompoundMobject(zero_arrow, one_arrow, three_arrow)
).with_background(marked_number_line, three).then(
Transform(
CompoundMobject(number_line, one_arrow),
CompoundMobject(stretched_line, three_arrow),
dither_time = 0, run_time = 3.0
).with_background(three, three_arrow, zero_arrow)
).then(
Flash(three_arrow).with_background(stretched_line, three, zero_arrow)
).then(
Animation(CompoundMobject(zero_arrow, three_arrow, stretched_line, three))
)
def real_addition_by_sliding():
two, plus, three, five = [
ImageMobject(
name_to_image[name]
)
for name in [
"two", "plus", "three", "five"
]
]
center = CompoundMobject(two, plus, three).get_center()
for mob in two, plus, three:
mob.shift(-center + (0, 2, 0)).highlight(ADDER_COLOR)
five.center().shift((0, 2, 0)).highlight(ADDER_COLOR)
number_line = NumberLine(radius = 2 * SPACE_WIDTH) #Numbers?
int_size = number_line.interval_size
shifted_line = dict()
for x in [2, 5]:
shifted_line[x] = copy.deepcopy(number_line).shift((x*int_size, 0, 0))
return Transform(
copy.deepcopy(number_line), shifted_line[2], dither_time = 0.5
).with_background(two).then(
Transform(
shifted_line[2], shifted_line[5], dither_time = 0.5
).with_background(two, plus, three)
).then(
Transform(
number_line, shifted_line[5], dither_time = 0.5
).with_background(five)
)
def real_multiplication_by_stretching():
two, times, three, six = [
ImageMobject(
name_to_image[name]
).highlight(MULTIPLIER_COLOR)
for name in [
"two", "times", "three", "six"
]
]
center = CompoundMobject(two, times, three).get_center()
for mob in two, times, three:
mob.shift(-center + (0, 2, 0))
six.center().shift((0, 2, 0))
number_line = NumberLine() #Numbers?
int_size = number_line.interval_size
stretched_line = dict()
for num in [2, 6]:
stretched_line[num] = copy.deepcopy(number_line)
stretched_line[num].points = np.array(
map(lambda (x, y, z) : (num*x, y, z), stretched_line[num].points)
)
return Transform(
copy.deepcopy(number_line), stretched_line[2], dither_time = 0.5
).with_background(two).then(
Transform(
stretched_line[2], stretched_line[6], dither_time = 0.5
).with_background(two, times, three)
).then(
Transform(
number_line, stretched_line[6], dither_time = 0.5
).with_background(six)
)
def exp_turns_adder_to_muliplier():
two, e_to_x, e_to_2_value = [
ImageMobject(name_to_image[name]).center()
for name in ["two", "e_to_x", "e_to_2_value"]
]
two.center().shift((-2, 2, 0)).highlight(ADDER_COLOR)
e_to_x.center().shift((0, 2, 0))
e_to_2_value.center().shift((2, 2, 0)).highlight(MULTIPLIER_COLOR)
number_line = NumberLine(radius = SPACE_WIDTH*2)
point = Point(e_to_x.get_center())
shift_line = ApplyFunction(
lambda (x,y,z) : (x+2*number_line.interval_size,y,z),
copy.deepcopy(number_line),
run_time = 1.0, dither_time = 0
)
stretch_line = ApplyFunction(
lambda (x,y,z) : (x*np.exp(2),y,z),
number_line,
run_time = 1.0
)
return Reveal(two).set_dither(0).with_background(e_to_x).then(
shift_line.with_background(two, e_to_x)
).then(
Transform(two, point, dither_time = 0).with_background(e_to_x)
).then(
Transform(point, e_to_2_value, dither_time = 0).with_background(e_to_x)
).then(
stretch_line.with_background(e_to_x, e_to_2_value)
)
def exp_is_homomorphism():
two, three, five, e_to_x, e_to_2_value, e_to_3_value, e_to_5_value, plus, times = [
ImageMobject(name_to_image[name]).center()
for name in ["two", "three", "five", "e_to_x", "e_to_2_value",
"e_to_3_value", "e_to_5_value", "plus", "times"]
]
two.shift((-2.2, 2.2, 0))
three.shift((-1.8, 1.8, 0))
two_three = CompoundMobject(two, three).highlight(ADDER_COLOR)
five.shift((-2, -2, 0)).highlight(ADDER_COLOR)
e_to_2_value.shift((1.8, 2.2, 0))
e_to_3_value.shift((2.2, 1.8, 0))
e_to_2_value_e_to_3_value = CompoundMobject(e_to_2_value, e_to_3_value).highlight(MULTIPLIER_COLOR)
e_to_5_value.shift((2, -2, 0)).highlight(MULTIPLIER_COLOR)
e_to_x_copy = copy.deepcopy(e_to_x)
e_to_x.shift((0, 2, 0))
e_to_x_copy.shift((0, -2, 0))
plus.shift((-2, 0, 0))
times.shift((2, 0, 0))
operations = CompoundMobject(e_to_x, e_to_x_copy, plus, times)
high_exp_point = Point(e_to_x.get_center())
low_exp_point = Point(e_to_x_copy.get_center())
plus_point = Point(plus.get_center())
times_point = Point(times.get_center())
anim = Transform(
two_three, plus_point, dither_time = 0
).with_background(operations)
for start, end in [
(plus_point, five),
(five, low_exp_point),
(low_exp_point, e_to_5_value),
(copy.deepcopy(two_three), high_exp_point),
(high_exp_point, e_to_2_value_e_to_3_value),
(e_to_2_value_e_to_3_value, times_point),
(times_point, e_to_5_value)
]:
anim.then(Transform(start, end, dither_time = 0),
carry_over_background = True
)
if end in [e_to_5_value, five, e_to_2_value_e_to_3_value]:
anim.then(
Animation(end, run_time = 1.0, dither_time = 0),
carry_over_background = True,
)
return anim
def repeated_product_gives_property():
expressions = [
ImageMobject(name_to_image[name]).center()
for name in ["e_to_x_plus_y", "e_by_e_x_plus_y_times",
"x_es_then_y_es", "e_to_x_e_to_y",]
]
anim = Transform(expressions[0], expressions[1], run_time = 0.5)
for x in range(1, 3):
anim.then(
Transform(expressions[x], expressions[x + 1]),
run_time = 0.5
)
return anim
def repeated_product_as_consequence():
defining_property, other_way_around, e_to_5, \
e_to_sum_ones, e_to_1_product = [
ImageMobject(name_to_image[name]).center()
for name in ["defining_property", "other_way_around", "e_to_5",
"e_to_sum_ones", "e_to_1_product"]
]
return Animation(other_way_around, run_time = 1.0, dither_time = 0).then(
Animation(defining_property, run_time = 2.0, dither_time = 0)
).then(
Transform(e_to_5, e_to_sum_ones, run_time = 0.5)
).then(
Transform(e_to_sum_ones, e_to_1_product, run_time = 0.5)
)
def e_to_x_definition():
adder_to_multiplier_property, e_to_x_series, \
colon_explanation, e_def, e_approx, e_in_nature = [
ImageMobject(name_to_image[name])
for name in [
"adder_to_multiplier_property",
"e_to_x_series",
"colon_explanation",
"e_def",
"e_approx",
"e_in_nature"
]
]
for mob in e_to_x_series, colon_explanation:
mob.center()
colon_explanation.shift((-1, 1.5, 0))
colon_explanation.add(Arrow(point = (-3.5, 0.4, 0), direction = (-1,-1,0)))
e_in_nature.shift((0, -2, 0))
for mob in e_def, e_approx:
mob.shift((0, 1, 0))
return Transform(
adder_to_multiplier_property,
e_to_x_series
).then(
Reveal(colon_explanation).with_background(e_to_x_series)
).then(
Transform(e_to_x_series, e_def).while_also(
Reveal(CompoundMobject(e_approx, e_in_nature))
)
)
def less_natural_exponentials():
two, five, i, to_the_x, adder_to_multiplier_property = [
ImageMobject(name_to_image[name])
for name in ["two", "five", "i", "to_the_x",
"adder_to_multiplier_property"]
]
two.center()
five.center()
i.scale(1.5).center()
to_the_x.shift((0, -0.25, 0))
kwargs = {"dither_time" : 0.5}
return Transform(
adder_to_multiplier_property,
CompoundMobject(two, to_the_x), **kwargs
).then(
Transform(two, five, **kwargs).with_background(
to_the_x
)
).then(
Transform(five, i, **kwargs).with_background(
to_the_x
)
)
def complex_addition(num):
complex_plane = Grid(radius = 2 * SPACE_WIDTH).add(Cross())
point = Cross().shift((num.real, num.imag, 0)).highlight(ADDER_COLOR)
return ShowCreation(point).with_background(complex_plane).then(
ComplexFunction(
(lambda z : z + num), complex_plane
).with_background(
point
)
)
def complex_multiplication(num):
complex_plane = Grid(radius = 2 * SPACE_WIDTH)
zero = Cross()
one = Cross().shift((1, 0, 0)).highlight(ONE_COLOR)
num_dot = Cross().shift((num.real, num.imag, 0)).highlight(MULTIPLIER_COLOR)
return ComplexFunction(
(lambda z : z*num), complex_plane
).while_also(
ComplexFunction((lambda z : z + num - 1), one)
).with_background(
zero, num_dot
)
def multiply_i_twice():
zero, one, i, new_one = [
Cross(),
Cross().shift((1, 0, 0)).highlight(ONE_COLOR),
Cross().shift((0, 1, 0)).highlight(MULTIPLIER_COLOR),
Cross().shift((0, 1, 0)).highlight(ONE_COLOR),
]
complex_plane = Grid(radius = 2 * SPACE_WIDTH)
return RotationAsTransform(complex_plane, np.pi/2).while_also(
RotationAsTransform(one, np.pi/2)
).with_background(zero, i).then(
RotationAsTransform(complex_plane, np.pi/2).while_also(
RotationAsTransform(CompoundMobject(new_one), np.pi/2)
).with_background(zero)
)
def multiply_neg_1():
zero, one, neg_1 = [
Cross(),
Cross().shift((1, 0, 0)).highlight(ONE_COLOR),
Cross().shift((-1, 0, 0)).highlight(MULTIPLIER_COLOR),
]
complex_plane = Grid(radius = 2 * SPACE_WIDTH).add(zero, one)
return RotationAsTransform(
complex_plane.add(zero, one), np.pi
).with_background(neg_1)
def i_squared_equals_neg_1():
equation = ImageMobject(name_to_image["i_squared_equals_neg_1"]).center()
plane = Grid().add(Cross(), Cross().shift((-1, 0, 0)).highlight(MULTIPLIER_COLOR))
return Transform(plane, equation, dither_time = 2.0)
def reals_in_complex():
radius = 2 * SPACE_WIDTH
plain_complex_plane = Grid(radius = radius)
complex_plane = copy.deepcopy(plain_complex_plane)
complex_plane.highlight(NumberLine.DEFAULT_COLOR, lambda (x, y, z) : y == 0)
shifted = copy.deepcopy(complex_plane).shift((3, 0, 0))
stretched = copy.deepcopy(complex_plane).scale(2)
anim = Transform(plain_complex_plane, complex_plane)
for start, end in [
(copy.deepcopy(complex_plane), shifted),
(shifted, complex_plane),
(copy.deepcopy(complex_plane), stretched),
(stretched, complex_plane)
]:
anim.then(Transform(start, end, run_time = 2.0, dither_time = 0.0))
return anim
def broken_up_complex_addition(num):
complex_plane = Grid(radius = 2 * SPACE_WIDTH).add(Cross())
point = Cross().shift((num.real, num.imag, 0)).highlight(ADDER_COLOR)
plane_plus_real = copy.deepcopy(complex_plane).shift((num.real, 0, 0))
plane_plus_num = copy.deepcopy(complex_plane).shift((num.real, num.imag, 0))
return Transform(complex_plane, plane_plus_real).with_background(point).then(
Transform(plane_plus_real, plane_plus_num),
carry_over_background = True
)
def broken_up_complex_multiplication(num):
complex_plane = Grid(radius = 2 * SPACE_WIDTH)
zero = Cross()
one = Cross().shift((1, 0, 0)).highlight(ONE_COLOR)
num_dot = Cross().shift((num.real, num.imag, 0)).highlight(MULTIPLIER_COLOR)
plane_stretched = copy.deepcopy(complex_plane).scale(np.linalg.norm(num))
plane_times_num = copy.deepcopy(plane_stretched).rotate(np.log(num).imag)
one_stretched = copy.deepcopy(one).shift((np.linalg.norm(num) - 1, 0, 0))
one_times_num = copy.deepcopy(one).center().shift(num_dot.get_center())
return Transform(
complex_plane, plane_stretched
).with_background(zero, num_dot).while_also(
Transform(one, one_stretched)
).then(
Transform(
plane_stretched, plane_times_num
).while_also(Transform(one_stretched, one_times_num)),
carry_over_background = True
)
def new_dimensions():
adder = ComplexFunction(lambda z : z + complex(0, 1))
multiplier = RotationAsTransform(Grid(radius = SPACE_HEIGHT + SPACE_WIDTH), np.pi / 3)
for anim in adder, multiplier:
anim.set_run_time(5.0).set_dither(0.5).set_alpha_func(there_and_back)
return adder.then(multiplier)
def wrap_imaginaries_to_circle():
imaginaries = ParametricFunction(
lambda t : (0, t * SPACE_HEIGHT, 0),
color = ADDER_COLOR
)
imaginaries.shift((0.01, 0, 0))
circle = Circle(color = MULTIPLIER_COLOR)
Mobject.align_data(imaginaries, circle)
complex_plane = Grid()
hidden_plane = Grid(color = "black")
return FadeOut(
complex_plane, alpha_func = there_and_back
).with_background(imaginaries).then(
ShowCreation(circle).with_background(imaginaries, complex_plane),
).then(
ComplexFunction(np.exp, imaginaries).with_background(
circle, complex_plane),
)
def wrap_imaginaries_to_circle_with_measurments():
pi, i, minus, neg_1 = [
ImageMobject(name_to_image[name])
for name in ["pi", "i", "minus", "neg_1"]
]
pi_i = CompoundMobject(pi, i).center()
minus_pi_i = copy.deepcopy(pi_i).center().add(
minus.center().scale(0.5).shift((-0.2, 0, 0))
)
for mob, sgn in (pi_i, 1), (minus_pi_i, -1):
mob.shift((-0.3, sgn*np.pi, 0))
mob.add(
Cross().scale(0.5).shift((0, sgn*np.pi, 0)).highlight(ADDER_COLOR)
)
neg_1.center().shift((-1.2, 0, 0))
imaginaries = ParametricFunction(
lambda t : (0, np.pi * t, 0),
color = ADDER_COLOR
)
complex_plane = Grid()
circle = Circle(color = MULTIPLIER_COLOR)
return ComplexFunction(np.exp, imaginaries).with_background(
circle, complex_plane
).while_also(
Transform(CompoundMobject(pi_i, minus_pi_i), neg_1,
run_time = DEFAULT_ANIMATION_RUN_TIME,
)
)
def definition_of_pi():
pi, one, two = [
ImageMobject(name_to_image[name]).center()
for name in [
"pi", "one", "two"
]
]
two.scale(0.7).shift((-0.1, 0, 0))
two_pi = CompoundMobject(two, pi.shift((0.1, 0, 0)))
one.shift((0.5, 0.3, 0))
two_pi.shift((0, -1.3, 0))
circle = Circle().rotate(np.pi/4)
line = Line((-np.pi, -1, 0), (np.pi, -1, 0)).highlight(Circle.DEFAULT_COLOR)
radius = Line((0, 0, 0), (1, 0, 0))
kwargs = {"run_time" : 2, "dither_time" : 1}
return Transform(circle, line, **kwargs).with_background(
one, radius
).while_also(
Reveal(two_pi, **kwargs)
)
def epii_adder_to_multiplier():
e, pi, i, equals_neg1, neg_1 = [
ImageMobject(name_to_image[name])
for name in [
"e", "pi", "i", "equals_neg1", "neg_1"
]
]
pi.highlight(ADDER_COLOR)
i.highlight(ADDER_COLOR)
equals_neg1.highlight(MULTIPLIER_COLOR, lambda (x, y, z) : x > 0.25)
neg_1.highlight(MULTIPLIER_COLOR)
epii_neg1 = CompoundMobject(e, pi, i, equals_neg1)
dividing_line = Line((0, -SPACE_HEIGHT, 0), (0, SPACE_HEIGHT, 0))
half_width = SPACE_WIDTH / 2
left_grid = Grid(radius = SPACE_HEIGHT + np.pi).filter_out(
lambda (x, y, z) : abs(x) > half_width
).add(Cross())
right_grid = Grid().add(Cross(), Cross().highlight(ONE_COLOR).shift((1, 0, 0)))
# pi_i = CompoundMobject(pi, i).center().shift((-0.25, np.pi, 0))
pi_i = Cross().highlight(ADDER_COLOR).shift((0, np.pi, 0))
# neg_1.center().shift((-1.5, 0, 0))
neg_1 = Cross().highlight(MULTIPLIER_COLOR).shift((-1, 0, 0))
return Animation(epii_neg1, run_time = 2, dither_time = 0).then(
ComplexFunction(lambda z : z + complex(0, np.pi), left_grid).with_background(
pi_i, dividing_line.shift((half_width, 0, 0))
).shift((-half_width, 0, 0)).while_also(
RotationAsTransform(right_grid, np.pi).with_background(
neg_1
).restrict_width(half_width).shift((half_width, 0, 0))
).while_also(
Animation(epii_neg1)
)
)
# return Animation(epii_neg1, run_time = 1.0, dither_time = 0).then(
# ComplexFunction(lambda z : z + complex(0, np.pi), Grid(radius = 2*SPACE_HEIGHT))
# ).with_background(epii_neg1).then(
# RotationAsTransform(Grid(radius = 2*SPACE_HEIGHT), np.pi)
# ).with_background(epii_neg1)
def e_to_all_kinds_of_things():
expressions = [
ImageMobject(name_to_image[name])
for name in [
"e_to_complex", "e_to_matrix", "e_to_derivative", "e_def"
]
]
return reduce(
Animation.then,
[
Transform(expressions[x], expressions[x + 1])
for x in range(3)
]
)
if __name__ == '__main__':
example_complex = complex(2, 1)
functions = [
# (logo_to_epii, []),
# (write_epii, []),
# (the_terms, []),
# (literal_epii, []),
# (pile_of_equations, []),
# (confusion_of_terms, []),
# (list_of_goals, []),
# (not_repeated_multiplication, []),
# (problems_with_repeated_multiplication, []),
# (numbers_as_actions, []),
# (numbers_as_counting, []),
# (addition_by_counting, []),
# (multiplication_by_counting, []),
# (fraction_counting, []),
# (irrational_counting, []),
# (imaginary_counting, []),
# (real_number_as_three_things, []),
# (wrong_adder_conception, []),
# (real_addition_rule, []),
# (real_multiplication_rule, []),
# (real_addition_by_sliding, []),
# (real_multiplication_by_stretching, []),
# (exp_turns_adder_to_muliplier, []),
# (exp_is_homomorphism, []),
# (repeated_product_gives_property, []),
# (repeated_product_as_consequence, []),
(e_to_x_definition, []),
# (less_natural_exponentials, []),
# (complex_addition, [example_complex]),
# (complex_multiplication, [example_complex]),
# (multiply_i_twice, []),
# (multiply_neg_1, []),
# (i_squared_equals_neg_1, []),
# (complex_addition, [complex(0, 1)]),
# (reals_in_complex, []),
# (broken_up_complex_addition, [example_complex]),
# (broken_up_complex_multiplication, [example_complex]),
# (new_dimensions, []),
# (wrap_imaginaries_to_circle, []),
# (wrap_imaginaries_to_circle_with_measurments, []),
# (definition_of_pi, []),
# (epii_adder_to_multiplier, []),
# (e_to_all_kinds_of_things, []),
]
full_path = os.path.join(MOVIE_DIR, EPII_MOVIE_DIR)
if not os.path.exists(full_path):
os.mkdir(full_path)
for func, args in functions:
name = os.path.join(
EPII_MOVIE_DIR,
to_cammel_case(func.__name__) + hash_args(args)
)
func(*args).write_to_movie(name)
for anim in [
# ShowCreation(Grid(), run_time = 3.0),
# Rotating(Stars(), radians = np.pi / 3),
# ComplexFunction(np.exp, Grid(radius = SPACE_HEIGHT))
]:
anim.write_to_movie(os.path.join(EPII_MOVIE_DIR, str(anim)))
Reference in a new issue Copy permalink