Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Animations up to the preview for the breakdown into sine curves for diffyq chapter 3

Grant Sandersonddd7ce2f1264
diff --git a/active_projects/ode/all_part3_scenes.py b/active_projects/ode/all_part3_scenes.py
index 32be5c04b..dd6d024bd 100644
--- a/active_projects/ode/all_part3_scenes.py
+++ b/active_projects/ode/all_part3_scenes.py
@@ -1,5 +1,6 @@
from active_projects.ode.part3.staging import *
from active_projects.ode.part3.temperature_graphs import *
+from active_projects.ode.part3.pi_creature_scenes import *
OUTPUT_DIRECTORY = "ode/part3"
@@ -9,5 +10,6 @@ SCENES_IN_ORDER = [
CircleAnimationOfF,
LastChapterWrapper,
ThreeMainObservations,
- SimpleSinExpGraph,
+ SimpleCosExpGraph,
+ AddMultipleSolutions,
]
diff --git a/active_projects/ode/part3/pi_creature_scenes.py b/active_projects/ode/part3/pi_creature_scenes.py
new file mode 100644
index 000000000..e79bacbb4
--- /dev/null
+++ b/active_projects/ode/part3/pi_creature_scenes.py
@@ -0,0 +1,41 @@
+from manimlib.imports import *
+
+
+class IveHeardOfThis(TeacherStudentsScene):
+ def construct(self):
+ point = VectorizedPoint()
+ point.move_to(3 * RIGHT + 2 * UP)
+ self.student_says(
+ "I've heard\\\\", "of this!",
+ student_index=1,
+ target_mode="hooray",
+ bubble_kwargs={
+ "height": 3,
+ "width": 3,
+ "direction": RIGHT,
+ },
+ run_time=1,
+ )
+ self.change_student_modes(
+ "thinking", "hooray", "thinking",
+ look_at_arg=point,
+ added_anims=[self.teacher.change, "happy"]
+ )
+ self.wait(3)
+ self.student_says(
+ "But who\\\\", "cares?",
+ student_index=1,
+ target_mode="maybe",
+ bubble_kwargs={
+ "direction": RIGHT,
+ "width": 3,
+ "height": 3,
+ },
+ run_time=1,
+ )
+ self.change_student_modes(
+ "pondering", "maybe", "pondering",
+ look_at_arg=point,
+ added_anims=[self.teacher.change, "guilty"]
+ )
+ self.wait(5)
diff --git a/active_projects/ode/part3/staging.py b/active_projects/ode/part3/staging.py
index a91de197d..4bd3f8fb6 100644
--- a/active_projects/ode/part3/staging.py
+++ b/active_projects/ode/part3/staging.py
@@ -221,32 +221,21 @@ class FourierSeriesIllustraiton(Scene):
y_min=-1,
y_max=1,
)
- axes2 = axes1.copy()
- step_func = axes2.get_graph(
- lambda x: (1 if x < 0.5 else -1),
- discontinuities=[0.5],
- color=YELLOW,
- stroke_width=3,
+ axes1.x_axis.add_numbers(
+ 0.5, 1,
+ number_config={"num_decimal_places": 1}
)
- dot = Dot(axes2.c2p(0.5, 0), color=step_func.get_color())
- dot.scale(0.5)
- step_func.add(dot)
- axes2.add(step_func)
+ axes2 = axes1.copy()
+ target_func_graph = self.get_target_func_graph(axes2)
+ axes2.add(target_func_graph)
arrow = Arrow(LEFT, RIGHT, color=WHITE)
- VGroup(axes1, arrow, axes2).arrange(RIGHT).shift(UP)
-
- def generate_nth_func(n):
- return lambda x: (4 / n / PI) * np.sin(TAU * n * x)
-
- def generate_kth_partial_sum_func(k):
- return lambda x: np.sum([
- generate_nth_func(n)(x)
- for n in n_range[:k]
- ])
+ group = VGroup(axes1, arrow, axes2)
+ group.arrange(RIGHT, buff=LARGE_BUFF)
+ group.shift(2 * UP)
sine_graphs = VGroup(*[
- axes1.get_graph(generate_nth_func(n))
+ axes1.get_graph(self.generate_nth_func(n))
for n in n_range
])
sine_graphs.set_stroke(width=3)
@@ -256,44 +245,43 @@ class FourierSeriesIllustraiton(Scene):
)
partial_sums = VGroup(*[
- axes1.get_graph(generate_kth_partial_sum_func(k + 1))
+ axes1.get_graph(self.generate_kth_partial_sum_func(k + 1))
for k in range(len(n_range))
])
partial_sums.match_style(sine_graphs)
- sum_tex = TexMobject(
- "\\frac{4}{\\pi}"
- "\\sum_{1, 3, 5, \\dots}"
- "\\frac{1}{n} \\sin(2\\pi \\cdot n \\cdot x)"
- )
- sum_tex.next_to(partial_sums, DOWN, buff=0.7)
+ sum_tex = self.get_sum_tex()
+ sum_tex.next_to(axes1, DOWN, LARGE_BUFF)
+ sum_tex.shift(RIGHT)
eq = TexMobject("=")
- step_tex = TexMobject(
- """
- 1 \\quad \\text{if $x < 0.5$} \\\\
- 0 \\quad \\text{if $x = 0.5$} \\\\
- -1 \\quad \\text{if $x > 0.5$} \\\\
- """
- )
- lb = Brace(step_tex, LEFT, buff=SMALL_BUFF)
- step_tex.add(lb)
- step_tex.next_to(axes2, DOWN, buff=MED_LARGE_BUFF)
+ target_func_tex = self.get_target_func_tex()
+ target_func_tex.next_to(axes2, DOWN)
+ target_func_tex.match_y(sum_tex)
eq.move_to(midpoint(
- step_tex.get_left(),
+ target_func_tex.get_left(),
sum_tex.get_right()
))
+ range_words = TextMobject(
+ "For $0 \\le x \\le 1$"
+ )
+ range_words.next_to(
+ VGroup(sum_tex, target_func_tex),
+ DOWN,
+ )
+
rects = it.chain(
[
- SurroundingRectangle(sum_tex[0][i])
- for i in [4, 6, 8]
+ SurroundingRectangle(piece)
+ for piece in self.get_sum_tex_pieces(sum_tex)
],
it.cycle([None])
)
self.add(axes1, arrow, axes2)
- self.add(step_func)
- self.add(sum_tex, eq, step_tex)
+ self.add(target_func_graph)
+ self.add(sum_tex, eq, target_func_tex)
+ self.add(range_words)
curr_partial_sum = axes1.get_graph(lambda x: 0)
curr_partial_sum.set_stroke(width=1)
@@ -320,6 +308,101 @@ class FourierSeriesIllustraiton(Scene):
self.play(*anims2)
curr_partial_sum = partial_sum
+ def get_sum_tex(self):
+ return TexMobject(
+ "\\frac{4}{\\pi} \\left(",
+ "\\frac{\\cos(\\pi x)}{1}",
+ "-\\frac{\\cos(3\\pi x)}{3}",
+ "+\\frac{\\cos(5\\pi x)}{5}",
+ "- \\cdots \\right)"
+ ).scale(0.75)
+
+ def get_sum_tex_pieces(self, sum_tex):
+ return sum_tex[1:4]
+
+ def get_target_func_tex(self):
+ step_tex = TexMobject(
+ """
+ 1 \\quad \\text{if $x < 0.5$} \\\\
+ 0 \\quad \\text{if $x = 0.5$} \\\\
+ -1 \\quad \\text{if $x > 0.5$} \\\\
+ """
+ )
+ lb = Brace(step_tex, LEFT, buff=SMALL_BUFF)
+ step_tex.add(lb)
+ return step_tex
+
+ def get_target_func_graph(self, axes):
+ step_func = axes.get_graph(
+ lambda x: (1 if x < 0.5 else -1),
+ discontinuities=[0.5],
+ color=YELLOW,
+ stroke_width=3,
+ )
+ dot = Dot(axes.c2p(0.5, 0), color=step_func.get_color())
+ dot.scale(0.5)
+ step_func.add(dot)
+ return step_func
+
+ # def generate_nth_func(self, n):
+ # return lambda x: (4 / n / PI) * np.sin(TAU * n * x)
+
+ def generate_nth_func(self, n):
+ return lambda x: np.prod([
+ (4 / PI),
+ (1 / n) * (-1)**((n - 1) / 2),
+ np.cos(PI * n * x)
+ ])
+
+ def generate_kth_partial_sum_func(self, k):
+ return lambda x: np.sum([
+ self.generate_nth_func(n)(x)
+ for n in self.n_range[:k]
+ ])
+
+
+class FourierSeriesOfLineIllustration(FourierSeriesIllustraiton):
+ CONFIG = {
+ "n_range": range(1, 31, 2)
+ }
+
+ def get_sum_tex(self):
+ return TexMobject(
+ "\\frac{8}{\\pi^2} \\left(",
+ "\\frac{\\cos(\\pi x)}{1^2}",
+ "+\\frac{\\cos(3\\pi x)}{3^2}",
+ "+\\frac{\\cos(5\\pi x)}{5^2}",
+ "+ \\cdots \\right)"
+ ).scale(0.75)
+
+ # def get_sum_tex_pieces(self, sum_tex):
+ # return sum_tex[1:4]
+
+ def get_target_func_tex(self):
+ result = TexMobject("1 - 2x")
+ result.scale(1.5)
+ point = VectorizedPoint()
+ point.next_to(result, RIGHT, 1.5 * LARGE_BUFF)
+ # result.add(point)
+ return result
+
+ def get_target_func_graph(self, axes):
+ return axes.get_graph(
+ lambda x: 1 - 2 * x,
+ color=YELLOW,
+ stroke_width=3,
+ )
+
+ # def generate_nth_func(self, n):
+ # return lambda x: (4 / n / PI) * np.sin(TAU * n * x)
+
+ def generate_nth_func(self, n):
+ return lambda x: np.prod([
+ (8 / PI**2),
+ (1 / n**2),
+ np.cos(PI * n * x)
+ ])
+
class CircleAnimationOfF(FourierOfTrebleClef):
CONFIG = {
diff --git a/active_projects/ode/part3/temperature_graphs.py b/active_projects/ode/part3/temperature_graphs.py
index 35f1b4721..4d0df9583 100644
--- a/active_projects/ode/part3/temperature_graphs.py
+++ b/active_projects/ode/part3/temperature_graphs.py
@@ -1,3 +1,5 @@
+from scipy import integrate
+
from manimlib.imports import *
@@ -30,8 +32,10 @@ class TemperatureGraphScene(SpecialThreeDScene):
},
}
- def get_three_d_axes(self, include_labels=True):
- axes = ThreeDAxes(**self.axes_config)
+ def get_three_d_axes(self, include_labels=True, **kwargs):
+ config = dict(self.axes_config)
+ config.update(kwargs)
+ axes = ThreeDAxes(**config)
axes.set_stroke(width=2)
# Add number labels
@@ -41,17 +45,19 @@ class TemperatureGraphScene(SpecialThreeDScene):
if include_labels:
x_label = TexMobject("x")
x_label.next_to(axes.x_axis.get_right(), DOWN)
- axes.x_axis.add(x_label)
+ axes.x_axis.label = x_label
t_label = TextMobject("Time")
t_label.rotate(90 * DEGREES, OUT)
t_label.next_to(axes.y_axis.get_top(), DL)
- axes.y_axis.add(t_label)
+ axes.y_axis.label = t_label
temp_label = TextMobject("Temperature")
temp_label.rotate(90 * DEGREES, RIGHT)
temp_label.next_to(axes.z_axis.get_zenith(), RIGHT)
- axes.z_axis.add(temp_label)
+ axes.z_axis.label = temp_label
+ for axis in axes:
+ axis.add(axis.label)
# Adjust axis orinetations
axes.x_axis.rotate(
@@ -88,19 +94,24 @@ class TemperatureGraphScene(SpecialThreeDScene):
return axes
- def get_initial_state_graph(self, axes, func, **kwargs):
+ def get_time_slice_graph(self, axes, func, t, **kwargs):
config = dict()
config.update(self.default_graph_style)
config.update(kwargs)
return ParametricFunction(
lambda x: axes.c2p(
- x, 0, func(x)
+ x, t, func(x)
),
t_min=axes.x_min,
t_max=axes.x_max,
**config,
)
+ def get_initial_state_graph(self, axes, func, **kwargs):
+ return self.get_time_slice_graph(
+ axes, func, t=0, **kwargs
+ )
+
def get_surface(self, axes, func, **kwargs):
config = dict()
config.update(axes.surface_config)
@@ -121,11 +132,11 @@ class TemperatureGraphScene(SpecialThreeDScene):
return mobject
-class SimpleSinExpGraph(TemperatureGraphScene):
+class SimpleCosExpGraph(TemperatureGraphScene):
def construct(self):
axes = self.get_three_d_axes()
- sine_graph = self.get_sine_graph(axes)
- sine_exp_surface = self.get_sine_exp_surface(axes)
+ cos_graph = self.get_cos_graph(axes)
+ cos_exp_surface = self.get_cos_exp_surface(axes)
self.set_camera_orientation(
phi=80 * DEGREES,
@@ -135,36 +146,73 @@ class SimpleSinExpGraph(TemperatureGraphScene):
self.begin_ambient_camera_rotation(rate=0.01)
self.add(axes)
- self.play(ShowCreation(sine_graph))
+ self.play(ShowCreation(cos_graph))
self.play(UpdateFromAlphaFunc(
- sine_exp_surface,
+ cos_exp_surface,
lambda m, a: m.become(
- self.get_sine_exp_surface(axes, v_max=a * 10)
+ self.get_cos_exp_surface(axes, v_max=a * 10)
),
run_time=3
))
- self.wait(20)
+
+ self.add(cos_graph.copy())
+
+ t_tracker = ValueTracker(0)
+ get_t = t_tracker.get_value
+ cos_graph.add_updater(
+ lambda m: m.become(self.get_time_slice_graph(
+ axes,
+ lambda x: self.cos_exp(x, get_t()),
+ t=get_t()
+ ))
+ )
+
+ plane = Rectangle(
+ stroke_width=0,
+ fill_color=WHITE,
+ fill_opacity=0.1,
+ )
+ plane.rotate(90 * DEGREES, RIGHT)
+ plane.match_width(axes.x_axis)
+ plane.match_depth(axes.z_axis, stretch=True)
+ plane.move_to(axes.c2p(0, 0, 0), LEFT)
+
+ self.add(plane, cos_graph)
+ self.play(
+ ApplyMethod(
+ t_tracker.set_value, 10,
+ run_time=10,
+ rate_func=linear,
+ ),
+ ApplyMethod(
+ plane.shift, 10 * UP,
+ run_time=10,
+ rate_func=linear,
+ ),
+ VFadeIn(plane),
+ )
+ self.wait(10)
#
- def sin_exp(self, x, t, A=2, omega=1, k=0.25):
- return A * np.sin(omega * x) * np.exp(-k * (omega**2) * t)
+ def cos_exp(self, x, t, A=2, omega=1.5, k=0.1):
+ return A * np.cos(omega * x) * np.exp(-k * (omega**2) * t)
- def get_sine_graph(self, axes, **config):
+ def get_cos_graph(self, axes, **config):
return self.get_initial_state_graph(
axes,
- lambda x: self.sin_exp(x, 0),
+ lambda x: self.cos_exp(x, 0),
**config
)
- def get_sine_exp_surface(self, axes, **config):
+ def get_cos_exp_surface(self, axes, **config):
return self.get_surface(
axes,
- lambda x, t: self.sin_exp(x, t),
+ lambda x, t: self.cos_exp(x, t),
**config
)
-class AddMultipleSolutions(SimpleSinExpGraph):
+class AddMultipleSolutions(SimpleCosExpGraph):
CONFIG = {
"axes_config": {
"x_axis_config": {
@@ -184,8 +232,8 @@ class AddMultipleSolutions(SimpleSinExpGraph):
self.orient_three_d_mobject(all_axes)
As = [1.5, 1.5]
- omegas = [1, 2]
- ks = [0.25, 0.01]
+ omegas = [1.5, 2.5]
+ ks = [0.1, 0.1]
quads = [
(axes1, [As[0]], [omegas[0]], [ks[0]]),
(axes2, [As[1]], [omegas[1]], [ks[1]]),
@@ -196,15 +244,15 @@ class AddMultipleSolutions(SimpleSinExpGraph):
graph = self.get_initial_state_graph(
axes,
lambda x: np.sum([
- self.sin_exp(x, 0, A, omega, k)
+ self.cos_exp(x, 0, A, omega, k)
for A, omega, k in zip(As, omegas, ks)
])
)
surface = self.get_surface(
axes,
lambda x, t: np.sum([
- self.sin_exp(x, t, A, omega)
- for A, omega in zip(As, omegas)
+ self.cos_exp(x, t, A, omega, k)
+ for A, omega, k in zip(As, omegas, ks)
])
)
surface.sort(lambda p: -p[2])
@@ -259,3 +307,274 @@ class AddMultipleSolutions(SimpleSinExpGraph):
FadeInFrom(axes3.checkmark, DOWN),
)
self.wait()
+
+
+class BreakDownAFunction(SimpleCosExpGraph):
+ CONFIG = {
+ "axes_config": {
+ "z_axis_config": {
+ "unit_size": 0.75,
+ "include_tip": False,
+ },
+ "z_min": 0,
+ },
+ "n_low_axes": 4,
+ }
+
+ def construct(self):
+ self.set_camera_orientation(distance=100)
+ self.set_axes()
+ self.setup_graphs()
+ self.show_break_down()
+ self.show_solutions_for_waves()
+
+ def set_axes(self):
+ top_axes = self.get_three_d_axes()
+ top_axes.z_axis.label.next_to(
+ top_axes.z_axis.get_end(), OUT, SMALL_BUFF
+ )
+ top_axes.y_axis.set_opacity(0)
+ self.orient_three_d_mobject(top_axes)
+ top_axes.y_axis.label.rotate(-10 * DEGREES, UP)
+ top_axes.scale(0.75)
+ top_axes.center()
+ top_axes.to_edge(UP)
+
+ low_axes = self.get_three_d_axes(
+ z_min=-3,
+ z_axis_config={"unit_size": 1}
+ )
+ low_axes.y_axis.set_opacity(0)
+ for axis in low_axes:
+ axis.label.fade(1)
+ # low_axes.add(low_axes.input_plane)
+ # low_axes.input_plane.set_opacity(0)
+
+ self.orient_three_d_mobject(low_axes)
+ low_axes_group = VGroup(*[
+ low_axes.deepcopy()
+ for x in range(self.n_low_axes)
+ ])
+ low_axes_group.arrange(
+ RIGHT, buff=low_axes.get_width() / 3
+ )
+ low_axes_group.set_width(FRAME_WIDTH - 2.5)
+ low_axes_group.next_to(top_axes, DOWN, LARGE_BUFF)
+ low_axes_group.to_edge(LEFT)
+
+ self.top_axes = top_axes
+ self.low_axes_group = low_axes_group
+
+ def setup_graphs(self):
+ top_axes = self.top_axes
+ low_axes_group = self.low_axes_group
+
+ top_graph = self.get_initial_state_graph(
+ top_axes,
+ self.initial_func,
+ discontinuities=self.get_initial_func_discontinuities(),
+ color=YELLOW,
+ )
+
+ fourier_terms = self.get_fourier_cosine_terms(
+ self.initial_func
+ )
+
+ low_graphs = VGroup(*[
+ self.get_initial_state_graph(
+ axes,
+ lambda x: A * np.cos(n * x / 2)
+ )
+ for n, axes, A in zip(
+ it.count(0, 2),
+ low_axes_group,
+ fourier_terms[::2],
+ )
+ ])
+ k = 0.1
+ low_surfaces = VGroup(*[
+ self.get_surface(
+ axes,
+ lambda x, t: np.prod([
+ A,
+ np.cos(n * x / 2),
+ np.exp(-k * (n / 2)**2 * t)
+ ])
+ )
+ for n, axes, A in zip(
+ it.count(0, 2),
+ low_axes_group,
+ fourier_terms[::2],
+ )
+ ])
+ top_surface = self.get_surface(
+ top_axes,
+ lambda x, t: np.sum([
+ np.prod([
+ A,
+ np.cos(n * x / 2),
+ np.exp(-k * (n / 2)**2 * t)
+ ])
+ for n, A in zip(
+ it.count(0, 2),
+ fourier_terms[::2]
+ )
+ ])
+ )
+
+ self.top_graph = top_graph
+ self.low_graphs = low_graphs
+ self.low_surfaces = low_surfaces
+ self.top_surface = top_surface
+
+ def show_break_down(self):
+ top_axes = self.top_axes
+ low_axes_group = self.low_axes_group
+ top_graph = self.top_graph
+ low_graphs = self.low_graphs
+
+ plusses = VGroup(*[
+ TexMobject("+").next_to(
+ axes.x_axis.get_end(),
+ RIGHT, MED_LARGE_BUFF
+ )
+ for axes in low_axes_group
+ ])
+ dots = TexMobject("\\cdots")
+ dots.next_to(plusses, RIGHT, MED_SMALL_BUFF)
+ arrow = Arrow(
+ dots.get_right(),
+ top_axes.get_right(),
+ path_arc=110 * DEGREES,
+ )
+
+ top_words = TextMobject("Arbitrary\\\\function")
+ top_words.next_to(top_axes, LEFT, MED_LARGE_BUFF)
+ top_words.set_color(YELLOW)
+ top_arrow = Arrow(
+ top_words.get_right(),
+ top_graph.get_center() + LEFT,
+ )
+
+ low_words = TextMobject("Sine curves")
+ low_words.set_color(BLUE)
+ low_words.next_to(low_axes_group, DOWN, MED_LARGE_BUFF)
+
+ self.add(top_axes)
+ self.play(ShowCreation(top_graph))
+ self.play(
+ FadeInFrom(top_words, RIGHT),
+ ShowCreation(top_arrow)
+ )
+ self.wait()
+ self.play(
+ LaggedStartMap(FadeIn, low_axes_group),
+ *[
+ TransformFromCopy(top_graph, low_graph)
+ for low_graph in low_graphs
+ ]
+ )
+ self.play(FadeInFrom(low_words, UP))
+ self.wait()
+ self.play(
+ LaggedStartMap(FadeInFromDown, plusses),
+ Write(dots)
+ )
+ self.play(ShowCreation(arrow))
+ self.wait()
+
+ def show_solutions_for_waves(self):
+ low_axes_group = self.low_axes_group
+ top_axes = self.top_axes
+ low_graphs = self.low_graphs
+ low_surfaces = self.low_surfaces
+ top_surface = self.top_surface
+ top_graph = self.top_graph
+
+ for surface in [top_surface, *low_surfaces]:
+ surface.sort(lambda p: -p[2])
+
+ anims1 = []
+ anims2 = []
+ for axes, surface, graph in zip(low_axes_group, low_surfaces, low_graphs):
+ axes.y_axis.set_opacity(1)
+ axes.y_axis.label.fade(1)
+ anims1 += [
+ ShowCreation(axes.y_axis),
+ Write(surface, run_time=2),
+ ]
+ anims2.append(AnimationGroup(
+ TransformFromCopy(graph, top_graph.copy()),
+ Transform(
+ surface.copy().fade(1),
+ top_surface,
+ )
+ ))
+
+ self.play(*anims1)
+ self.wait()
+ self.play(LaggedStart(*anims2, run_time=2))
+ self.wait()
+
+ checkmark = TexMobject("\\checkmark")
+ checkmark.set_color(GREEN)
+ low_checkmarks = VGroup(*[
+ checkmark.copy().next_to(
+ surface.get_top(), UP, SMALL_BUFF
+ )
+ for surface in low_surfaces
+ ])
+ top_checkmark = checkmark.copy()
+ top_checkmark.scale(1.5)
+ top_checkmark.move_to(top_axes.get_corner(UR))
+
+ self.play(LaggedStartMap(FadeInFromDown, low_checkmarks))
+ self.wait()
+ self.play(TransformFromCopy(
+ low_checkmarks, VGroup(top_checkmark)
+ ))
+ self.wait()
+
+ #
+ def initial_func(self, x):
+ return 3 * np.exp(-(x - PI)**2)
+
+ x1 = TAU / 4 - 0.1
+ x2 = TAU / 4 + 0.1
+ x3 = 3 * TAU / 4 - 0.1
+ x4 = 3 * TAU / 4 + 0.1
+
+ T0 = -2
+ T1 = 2
+
+ if x < x1:
+ return T0
+ elif x < x2:
+ return interpolate(
+ T0, T1,
+ inverse_interpolate(x1, x2, x)
+ )
+ elif x < x3:
+ return T1
+ elif x < x4:
+ return interpolate(
+ T1, T0,
+ inverse_interpolate(x3, x4, x)
+ )
+ else:
+ return T0
+
+ def get_initial_func_discontinuities(self):
+ # return [TAU / 4, 3 * TAU / 4]
+ return []
+
+ def get_fourier_cosine_terms(self, func, n_terms=20):
+ result = [
+ integrate.quad(
+ lambda x: (1 / PI) * func(x) * np.cos(n * x / 2),
+ 0, TAU
+ )[0]
+ for n in range(n_terms)
+ ]
+ result[0] = result[0] / 2
+ return result