A community-maintained Python framework for creating mathematical animations.
Rename ode folder to diffyq
Grant Sanderson2e0e5cfb5eb2
diff --git a/active_projects/ode/all_part1_scenes.py b/active_projects/ode/all_part1_scenes.pydeleted file mode 100644index 0ca648d4e..000000000--- a/active_projects/ode/all_part1_scenes.py+++ /dev/null@@ -1,107 +0,0 @@-from active_projects.ode.part1.pendulum import *-from active_projects.ode.part1.staging import *-from active_projects.ode.part1.pi_scenes import *-from active_projects.ode.part1.phase_space import *-from active_projects.ode.part1.wordy_scenes import *--OUTPUT_DIRECTORY = "ode/part1"-SCENES_IN_ORDER = [- WhenChangeIsEasier,- VectorFieldTest,- IntroducePendulum,- MultiplePendulumsOverlayed,- PeriodFormula,- FormulasAreLies,- MediumAnglePendulum,- MediumHighAnglePendulum,- HighAnglePendulum,- LowAnglePendulum,- SomeOfYouWatching,- SmallAngleApproximationTex,- VeryLowAnglePendulum,- FormulasAreLies,- TourOfDifferentialEquations,- WherePendulumLeads,- LongDoublePendulum,- # FollowThisThread,- StrogatzQuote,- ShowHorizontalDashedLine,- RabbitFoxPopulations,- RabbitFoxEquation,- # Something...- ShowSimpleTrajectory,- SimpleProjectileEquation,- SimpleProjectileEquationVGraphFreedom,- ShowGravityAcceleration,- UniversalGravityLawSymbols,- ExampleTypicalODE,- AnalyzePendulumForce,- ShowSineValues,- BuildUpEquation,- AirResistanceBrace,- ShowDerivativeVideo,- SubtleAirCurrents,- SimpleDampenedPendulum,- DefineODE,- SecondOrderEquationExample,- ODEvsPDEinFrames,- ProveTeacherWrong,- SetAsideSeekingSolution,- #- WriteInRadians,- XEqLThetaToCorner,- ComingUp,- InputLabel,- SoWhatIsThetaThen,- ReallyHardToSolve,- ReasonForSolution,- PhysicistPhaseSpace,- GleickQuote,- SpectrumOfStartingStates,- WritePhaseFlow,- AskAboutStability,- LoveExample,- PassageOfTime,- LovePhaseSpace,- ComparePhysicsToLove,- FramesComparingPhysicsToLove,- SetupToTakingManyTinySteps,- ShowClutterPrevention,- # VisualizeHeightSlopeCurvature,- VisualizeStates,- ReferencePiCollisionStateSpaces,- IntroduceVectorField,- XComponentArrows,- BreakingSecondOrderIntoTwoFirstOrder,- ShowPendulumPhaseFlow,- ShowHighVelocityCase,- TweakMuInFormula,- TweakMuInVectorField,- FromODEToVectorField,- LorenzVectorField,- ThreeBodiesInSpace,- AltThreeBodiesInSpace,- TwoBodiesInSpace,- TwoBodiesWithZPart,- ThreeBodyTitle,- ThreeBodySymbols,- #- HighAmplitudePendulum,- WritePhaseSpace,- #- AskAboutActuallySolving,- WriteODESolvingCode,- TakeManyTinySteps,- ManyStepsFromDifferentStartingPoints,- InaccurateComputation,- HungerForExactness,- ShowRect,- ShowSquare,- JumpToThisPoint,- ThreeBodyEquation,- ItGetsWorse,- ChaosTitle,- RevisitQuote,- EndScreen,- Thumbnail,-]diff --git a/active_projects/ode/all_part2_scenes.py b/active_projects/ode/all_part2_scenes.pydeleted file mode 100644index c38839737..000000000--- a/active_projects/ode/all_part2_scenes.py+++ /dev/null@@ -1,41 +0,0 @@-from active_projects.ode.part2.staging import *-from active_projects.ode.part2.fourier_series import *-from active_projects.ode.part2.heat_equation import *-from active_projects.ode.part2.pi_scenes import *-from active_projects.ode.part2.wordy_scenes import *--OUTPUT_DIRECTORY = "ode/part2"-SCENES_IN_ORDER = [- PartTwoOfTour,- HeatEquationIntroTitle,- BrownianMotion,- BlackScholes,- ContrastChapters1And2,- FourierSeriesIntro,- FourierSeriesIntroBackground20,- ExplainCircleAnimations,- # FourierSeriesIntroBackground4,- # FourierSeriesIntroBackground8,- # FourierSeriesIntroBackground12,- TwoDBodyWithManyTemperatures,- TwoDBodyWithManyTemperaturesGraph,- TwoDBodyWithManyTemperaturesContour,- BringTwoRodsTogether,- ShowEvolvingTempGraphWithArrows,- # TodaysTargetWrapper,- WriteHeatEquation,- ReactionsToInitialHeatEquation,- TalkThrough1DHeatGraph,- ShowCubeFormation,- CompareInputsOfGeneralCaseTo1D,- ContrastXChangesToTChanges,- ShowPartialDerivativeSymbols,- WriteHeatEquation,- ShowCurvatureToRateOfChangeIntuition,- ContrastPDEToODE,- TransitionToTempVsTime,- Show1DAnd3DEquations,- #- AskAboutWhereEquationComesFrom,- DiscreteSetup,-]diff --git a/active_projects/ode/all_part3_scenes.py b/active_projects/ode/all_part3_scenes.pydeleted file mode 100644index 6fe249532..000000000--- a/active_projects/ode/all_part3_scenes.py+++ /dev/null@@ -1,70 +0,0 @@-from active_projects.ode.part3.staging import *-from active_projects.ode.part3.temperature_graphs import *-from active_projects.ode.part3.pi_creature_scenes import *-from active_projects.ode.part3.wordy_scenes import *-from active_projects.ode.part3.discrete_case import *---OUTPUT_DIRECTORY = "ode/part3"-SCENES_IN_ORDER = [- LastChapterWrapper,- ThreeConstraints,- OceanOfPossibilities,- ThreeMainObservations,- SimpleCosExpGraph,- AddMultipleSolutions,- FourierSeriesIllustraiton,- BreakDownAFunction,- SineCurveIsUnrealistic,- AnalyzeSineCurve,- EquationAboveSineAnalysis,- ExponentialDecay,- InvestmentGrowth,- GrowingPileOfMoney,- CarbonDecayCurve,- CarbonDecayingInMammoth,- SineWaveScaledByExp,- ShowSinExpDerivatives,- IfOnly,- BoundaryConditionInterlude,- BoundaryConditionReference,- GiantCross,- SimulateRealSineCurve,- DerivativesOfLinearFunction,- StraightLine3DGraph,- SimulateLinearGraph,- EmphasizeBoundaryPoints,- ShowNewRuleAtDiscreteBoundary,- DiscreteEvolutionPoint25,- DiscreteEvolutionPoint1,- FlatEdgesForDiscreteEvolution,- FlatEdgesForDiscreteEvolutionTinySteps,- FlatEdgesContinuousEvolution,- FlatAtBoundaryWords,- SlopeToHeatFlow,- CloserLookAtStraightLine,- WriteOutBoundaryCondition,- SoWeGotNowhere,- ManipulateSinExpSurface,- HeatEquationFrame,- ShowFreq1CosExpDecay,- ShowFreq2CosExpDecay,- ShowFreq4CosExpDecay,- CompareFreqDecays1to2,- CompareFreqDecays1to4,- CompareFreqDecays2to4,- ShowHarmonics,- ShowHarmonicSurfaces,-- # SimpleCosExpGraph,- # AddMultipleSolutions,- # IveHeardOfThis,- # FourierSeriesOfLineIllustration,- # InFouriersShoes,-]--PART_4_SCENES = [- FourierSeriesIllustraiton,- FourierNameIntro,- CircleAnimationOfF,-]diff --git a/active_projects/ode/all_part4_scenes.py b/active_projects/ode/all_part4_scenes.pydeleted file mode 100644index 7e95486fb..000000000--- a/active_projects/ode/all_part4_scenes.py+++ /dev/null@@ -1,18 +0,0 @@-from active_projects.ode.part4.staging import *-from active_projects.ode.part4.fourier_series_scenes import *-from active_projects.ode.part4.pi_creature_scenes import *--OUTPUT_DIRECTORY = "ode/part4"-SCENES_IN_ORDER = [- ComplexFourierSeriesExample,- ComplexFourierSeriesExampleEnd,- FourierSeriesExampleWithRectForZoom,- ZoomedInFourierSeriesExample,- RelationToOtherVideos,- WhyWouldYouCare,- # Oldies-- # FourierSeriesIllustraiton,- # FourierNameIntro,- # CircleAnimationOfF,-]diff --git a/active_projects/ode/name_animations.py b/active_projects/ode/name_animations.pydeleted file mode 100644index b96c00e9d..000000000--- a/active_projects/ode/name_animations.py+++ /dev/null@@ -1,40 +0,0 @@-#!/usr/bin/env python-from manimlib.imports import *-from active_projects.ode.part2.fourier_series import FourierOfName--name_color_pairs = [--]--circle_counts = [- # 10,- # 25,- 100,-]--if __name__ == "__main__":- for name, color in name_color_pairs:- for n_circles in circle_counts:- try:- first_name = name.split(" ")[0]- scene = FourierOfName(- name_text=name,- name_color=color,- n_circles=n_circles,- file_writer_config={- "write_to_movie": True,- "output_directory": os.path.join(- "patron_fourier_names",- first_name,- ),- "file_name": "{}_Fouierified_{}_Separate_paths".format(- first_name,- n_circles- ),- },- camera_config={- "frame_rate": 24,- },- )- except:- passdiff --git a/active_projects/ode/part1/pendulum.py b/active_projects/ode/part1/pendulum.pydeleted file mode 100644index de8015795..000000000--- a/active_projects/ode/part1/pendulum.py+++ /dev/null@@ -1,1893 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.shared_constructs import *---class Pendulum(VGroup):- CONFIG = {- "length": 3,- "gravity": 9.8,- "weight_diameter": 0.5,- "initial_theta": 0.3,- "omega": 0,- "damping": 0.1,- "top_point": 2 * UP,- "rod_style": {- "stroke_width": 3,- "stroke_color": LIGHT_GREY,- "sheen_direction": UP,- "sheen_factor": 1,- },- "weight_style": {- "stroke_width": 0,- "fill_opacity": 1,- "fill_color": GREY_BROWN,- "sheen_direction": UL,- "sheen_factor": 0.5,- "background_stroke_color": BLACK,- "background_stroke_width": 3,- "background_stroke_opacity": 0.5,- },- "dashed_line_config": {- "num_dashes": 25,- "stroke_color": WHITE,- "stroke_width": 2,- },- "angle_arc_config": {- "radius": 1,- "stroke_color": WHITE,- "stroke_width": 2,- },- "velocity_vector_config": {- "color": RED,- },- "theta_label_height": 0.25,- "set_theta_label_height_cap": False,- "n_steps_per_frame": 100,- "include_theta_label": True,- "include_velocity_vector": False,- "velocity_vector_multiple": 0.5,- "max_velocity_vector_length_to_length_ratio": 0.5,- }-- def __init__(self, **kwargs):- super().__init__(**kwargs)- self.create_fixed_point()- self.create_rod()- self.create_weight()- self.rotating_group = VGroup(self.rod, self.weight)- self.create_dashed_line()- self.create_angle_arc()- if self.include_theta_label:- self.add_theta_label()- if self.include_velocity_vector:- self.add_velocity_vector()-- self.set_theta(self.initial_theta)- self.update()-- def create_fixed_point(self):- self.fixed_point_tracker = VectorizedPoint(self.top_point)- self.add(self.fixed_point_tracker)- return self-- def create_rod(self):- rod = self.rod = Line(UP, DOWN)- rod.set_height(self.length)- rod.set_style(**self.rod_style)- rod.move_to(self.get_fixed_point(), UP)- self.add(rod)-- def create_weight(self):- weight = self.weight = Circle()- weight.set_width(self.weight_diameter)- weight.set_style(**self.weight_style)- weight.move_to(self.rod.get_end())- self.add(weight)-- def create_dashed_line(self):- line = self.dashed_line = DashedLine(- self.get_fixed_point(),- self.get_fixed_point() + self.length * DOWN,- **self.dashed_line_config- )- line.add_updater(- lambda l: l.move_to(self.get_fixed_point(), UP)- )- self.add_to_back(line)-- def create_angle_arc(self):- self.angle_arc = always_redraw(lambda: Arc(- arc_center=self.get_fixed_point(),- start_angle=-90 * DEGREES,- angle=self.get_arc_angle_theta(),- **self.angle_arc_config,- ))- self.add(self.angle_arc)-- def get_arc_angle_theta(self):- # Might be changed in certain scenes- return self.get_theta()-- def add_velocity_vector(self):- def make_vector():- omega = self.get_omega()- theta = self.get_theta()- mvlr = self.max_velocity_vector_length_to_length_ratio- max_len = mvlr * self.rod.get_length()- vvm = self.velocity_vector_multiple- multiple = np.clip(- vvm * omega, -max_len, max_len- )- vector = Vector(- multiple * RIGHT,- **self.velocity_vector_config,- )- vector.rotate(theta, about_point=ORIGIN)- vector.shift(self.rod.get_end())- return vector-- self.velocity_vector = always_redraw(make_vector)- self.add(self.velocity_vector)- return self-- def add_theta_label(self):- self.theta_label = always_redraw(self.get_label)- self.add(self.theta_label)-- def get_label(self):- label = TexMobject("\\theta")- label.set_height(self.theta_label_height)- if self.set_theta_label_height_cap:- max_height = self.angle_arc.get_width()- if label.get_height() > max_height:- label.set_height(max_height)- top = self.get_fixed_point()- arc_center = self.angle_arc.point_from_proportion(0.5)- vect = arc_center - top- norm = get_norm(vect)- vect = normalize(vect) * (norm + self.theta_label_height)- label.move_to(top + vect)- return label-- #- def get_theta(self):- theta = self.rod.get_angle() - self.dashed_line.get_angle()- theta = (theta + PI) % TAU - PI- return theta-- def set_theta(self, theta):- self.rotating_group.rotate(- theta - self.get_theta()- )- self.rotating_group.shift(- self.get_fixed_point() - self.rod.get_start(),- )- return self-- def get_omega(self):- return self.omega-- def set_omega(self, omega):- self.omega = omega- return self-- def get_fixed_point(self):- return self.fixed_point_tracker.get_location()-- #- def start_swinging(self):- self.add_updater(Pendulum.update_by_gravity)-- def end_swinging(self):- self.remove_updater(Pendulum.update_by_gravity)-- def update_by_gravity(self, dt):- theta = self.get_theta()- omega = self.get_omega()- nspf = self.n_steps_per_frame- for x in range(nspf):- d_theta = omega * dt / nspf- d_omega = op.add(- -self.damping * omega,- -(self.gravity / self.length) * np.sin(theta),- ) * dt / nspf- theta += d_theta- omega += d_omega- self.set_theta(theta)- self.set_omega(omega)- return self---class GravityVector(Vector):- CONFIG = {- "color": YELLOW,- "length_multiple": 1 / 9.8,- # TODO, continually update the length based- # on the pendulum's gravity?- }-- def __init__(self, pendulum, **kwargs):- super().__init__(DOWN, **kwargs)- self.pendulum = pendulum- self.scale(self.length_multiple * pendulum.gravity)- self.attach_to_pendulum(pendulum)-- def attach_to_pendulum(self, pendulum):- self.add_updater(lambda m: m.shift(- pendulum.weight.get_center() - self.get_start(),- ))-- def add_component_lines(self):- self.component_lines = always_redraw(self.create_component_lines)- self.add(self.component_lines)-- def create_component_lines(self):- theta = self.pendulum.get_theta()- x_new = rotate(RIGHT, theta)- base = self.get_start()- tip = self.get_end()- vect = tip - base- corner = base + x_new * np.dot(vect, x_new)- kw = {"dash_length": 0.025}- return VGroup(- DashedLine(base, corner, **kw),- DashedLine(corner, tip, **kw),- )---class ThetaValueDisplay(VGroup):- CONFIG = {-- }-- def __init__(self, **kwargs):- super().__init__(**kwargs)---class ThetaVsTAxes(Axes):- CONFIG = {- "x_min": 0,- "x_max": 8,- "y_min": -PI / 2,- "y_max": PI / 2,- "y_axis_config": {- "tick_frequency": PI / 8,- "unit_size": 1.5,- },- "number_line_config": {- "color": "#EEEEEE",- "stroke_width": 2,- "include_tip": False,- },- "graph_style": {- "stroke_color": GREEN,- "stroke_width": 3,- "fill_opacity": 0,- },- }-- def __init__(self, **kwargs):- super().__init__(**kwargs)- self.add_labels()-- def add_axes(self):- self.axes = Axes(**self.axes_config)- self.add(self.axes)-- def add_labels(self):- x_axis = self.get_x_axis()- y_axis = self.get_y_axis()-- t_label = self.t_label = TexMobject("t")- t_label.next_to(x_axis.get_right(), UP, MED_SMALL_BUFF)- x_axis.label = t_label- x_axis.add(t_label)- theta_label = self.theta_label = TexMobject("\\theta(t)")- theta_label.next_to(y_axis.get_top(), UP, SMALL_BUFF)- y_axis.label = theta_label- y_axis.add(theta_label)-- self.y_axis_label = theta_label- self.x_axis_label = t_label-- x_axis.add_numbers()- y_axis.add(self.get_y_axis_coordinates(y_axis))-- def get_y_axis_coordinates(self, y_axis):- texs = [- # "\\pi \\over 4",- # "\\pi \\over 2",- # "3 \\pi \\over 4",- # "\\pi",- "\\pi / 4",- "\\pi / 2",- "3 \\pi / 4",- "\\pi",- ]- values = np.arange(1, 5) * PI / 4- labels = VGroup()- for pos_tex, pos_value in zip(texs, values):- neg_tex = "-" + pos_tex- neg_value = -1 * pos_value- for tex, value in (pos_tex, pos_value), (neg_tex, neg_value):- if value > self.y_max or value < self.y_min:- continue- symbol = TexMobject(tex)- symbol.scale(0.5)- point = y_axis.number_to_point(value)- symbol.next_to(point, LEFT, MED_SMALL_BUFF)- labels.add(symbol)- return labels-- def get_live_drawn_graph(self, pendulum,- t_max=None,- t_step=1.0 / 60,- **style):- style = merge_dicts_recursively(self.graph_style, style)- if t_max is None:- t_max = self.x_max-- graph = VMobject()- graph.set_style(**style)-- graph.all_coords = [(0, pendulum.get_theta())]- graph.time = 0- graph.time_of_last_addition = 0-- def update_graph(graph, dt):- graph.time += dt- if graph.time > t_max:- graph.remove_updater(update_graph)- return- new_coords = (graph.time, pendulum.get_theta())- if graph.time - graph.time_of_last_addition >= t_step:- graph.all_coords.append(new_coords)- graph.time_of_last_addition = graph.time- points = [- self.coords_to_point(*coords)- for coords in [*graph.all_coords, new_coords]- ]- graph.set_points_smoothly(points)-- graph.add_updater(update_graph)- return graph---# Scenes-class IntroducePendulum(PiCreatureScene, MovingCameraScene):- CONFIG = {- "pendulum_config": {- "length": 3,- "top_point": 4 * RIGHT,- "weight_diameter": 0.35,- "gravity": 20,- },- "theta_vs_t_axes_config": {- "y_max": PI / 4,- "y_min": -PI / 4,- "y_axis_config": {- "tick_frequency": PI / 16,- "unit_size": 2,- "tip_length": 0.3,- },- "x_max": 12,- "number_line_config": {- "stroke_width": 2,- }- },- }-- def setup(self):- MovingCameraScene.setup(self)- PiCreatureScene.setup(self)-- def construct(self):- self.add_pendulum()- # self.label_pi_creatures()- self.label_pendulum()- self.add_graph()- self.label_function()- self.show_graph_period()- self.show_length_and_gravity()- # self.tweak_length_and_gravity()-- def create_pi_creatures(self):- randy = Randolph(color=BLUE_C)- morty = Mortimer(color=MAROON_E)- creatures = VGroup(randy, morty)- creatures.scale(0.5)- creatures.arrange(RIGHT, buff=2.5)- creatures.to_corner(DR)- return creatures-- def add_pendulum(self):- pendulum = self.pendulum = Pendulum(**self.pendulum_config)- pendulum.start_swinging()- frame = self.camera_frame- frame.save_state()- frame.scale(0.5)- frame.move_to(pendulum.dashed_line)-- self.add(pendulum, frame)-- def label_pi_creatures(self):- randy, morty = self.pi_creatures- randy_label = TextMobject("Physics\\\\", "student")- morty_label = TextMobject("Physics\\\\", "teacher")- labels = VGroup(randy_label, morty_label)- labels.scale(0.5)- randy_label.next_to(randy, UP, LARGE_BUFF)- morty_label.next_to(morty, UP, LARGE_BUFF)-- for label, pi in zip(labels, self.pi_creatures):- label.arrow = Arrow(- label.get_bottom(), pi.eyes.get_top()- )- label.arrow.set_color(WHITE)- label.arrow.set_stroke(width=5)-- morty.labels = VGroup(- morty_label,- morty_label.arrow,- )-- self.play(- FadeInFromDown(randy_label),- GrowArrow(randy_label.arrow),- randy.change, "hooray",- )- self.play(- Animation(self.pendulum.fixed_point_tracker),- TransformFromCopy(randy_label[0], morty_label[0]),- FadeIn(morty_label[1]),- GrowArrow(morty_label.arrow),- morty.change, "raise_right_hand",- )- self.wait(2)-- def label_pendulum(self):- pendulum = self.pendulum- randy, morty = self.pi_creatures- label = pendulum.theta_label- rect = SurroundingRectangle(label, buff=0.5 * SMALL_BUFF)- rect.add_updater(lambda r: r.move_to(label))-- for pi in randy, morty:- pi.add_updater(- lambda m: m.look_at(pendulum.weight)- )-- self.play(randy.change, "pondering")- self.play(morty.change, "pondering")- self.wait(3)- randy.clear_updaters()- morty.clear_updaters()- self.play(- ShowCreationThenFadeOut(rect),- )- self.wait()-- def add_graph(self):- axes = self.axes = ThetaVsTAxes(**self.theta_vs_t_axes_config)- axes.y_axis.label.next_to(axes.y_axis, UP, buff=0)- axes.to_corner(UL)-- self.play(- Restore(- self.camera_frame,- rate_func=squish_rate_func(smooth, 0, 0.9),- ),- DrawBorderThenFill(- axes,- rate_func=squish_rate_func(smooth, 0.5, 1),- lag_ratio=0.9,- ),- Transform(- self.pendulum.theta_label.copy().clear_updaters(),- axes.y_axis.label.copy(),- remover=True,- rate_func=squish_rate_func(smooth, 0, 0.8),- ),- run_time=3,- )-- self.wait(1.5)- self.graph = axes.get_live_drawn_graph(self.pendulum)- self.add(self.graph)-- def label_function(self):- hm_word = TextMobject("Simple harmonic motion")- hm_word.scale(1.25)- hm_word.to_edge(UP)-- formula = TexMobject(- "=\\theta_0 \\cos(\\sqrt{g / L} t)"- )- formula.next_to(- self.axes.y_axis_label, RIGHT, SMALL_BUFF- )- formula.set_stroke(width=0, background=True)-- self.play(FadeInFrom(hm_word, DOWN))- self.wait()- self.play(- Write(formula),- hm_word.to_corner, UR- )- self.wait(4)-- def show_graph_period(self):- pendulum = self.pendulum- axes = self.axes-- period = self.period = TAU * np.sqrt(- pendulum.length / pendulum.gravity- )- amplitude = pendulum.initial_theta-- line = Line(- axes.coords_to_point(0, amplitude),- axes.coords_to_point(period, amplitude),- )- line.shift(SMALL_BUFF * RIGHT)- brace = Brace(line, UP, buff=SMALL_BUFF)- brace.add_to_back(brace.copy().set_style(BLACK, 10))- formula = get_period_formula()- formula.next_to(brace, UP, SMALL_BUFF)-- self.period_formula = formula- self.period_brace = brace-- self.play(- GrowFromCenter(brace),- FadeInFromDown(formula),- )- self.wait(2)-- def show_length_and_gravity(self):- formula = self.period_formula- L = formula.get_part_by_tex("L")- g = formula.get_part_by_tex("g")-- rod = self.pendulum.rod- new_rod = rod.copy()- new_rod.set_stroke(BLUE, 7)- new_rod.add_updater(lambda r: r.put_start_and_end_on(- *rod.get_start_and_end()- ))-- g_vect = GravityVector(- self.pendulum,- length_multiple=0.5 / 9.8,- )- down_vectors = self.get_down_vectors()- down_vectors.set_color(YELLOW)- down_vectors.set_opacity(0.5)-- self.play(- ShowCreationThenDestructionAround(L),- ShowCreation(new_rod),- )- self.play(FadeOut(new_rod))-- self.play(- ShowCreationThenDestructionAround(g),- GrowArrow(g_vect),- )- self.play(self.get_down_vectors_animation(down_vectors))- self.wait(6)-- self.gravity_vector = g_vect-- def tweak_length_and_gravity(self):- pendulum = self.pendulum- axes = self.axes- graph = self.graph- brace = self.period_brace- formula = self.period_formula- g_vect = self.gravity_vector- randy, morty = self.pi_creatures-- graph.clear_updaters()- period2 = self.period * np.sqrt(2)- period3 = self.period / np.sqrt(2)- amplitude = pendulum.initial_theta- graph2, graph3 = [- axes.get_graph(- lambda t: amplitude * np.cos(TAU * t / p),- color=RED,- )- for p in (period2, period3)- ]- formula.add_updater(lambda m: m.next_to(- brace, UP, SMALL_BUFF- ))-- new_pendulum_config = dict(self.pendulum_config)- new_pendulum_config["length"] *= 2- new_pendulum_config["top_point"] += 3.5 * UP- # new_pendulum_config["initial_theta"] = pendulum.get_theta()- new_pendulum = Pendulum(**new_pendulum_config)-- down_vectors = self.get_down_vectors()-- self.play(randy.change, "happy")- self.play(- ReplacementTransform(pendulum, new_pendulum),- morty.change, "horrified",- morty.shift, 3 * RIGHT,- morty.labels.shift, 3 * RIGHT,- )- self.remove(morty, morty.labels)- g_vect.attach_to_pendulum(new_pendulum)- new_pendulum.start_swinging()- self.play(- ReplacementTransform(graph, graph2),- brace.stretch, np.sqrt(2), 0, {"about_edge": LEFT},- )- self.add(g_vect)- self.wait(3)-- new_pendulum.gravity *= 4- g_vect.scale(2)- self.play(- FadeOut(graph2),- self.get_down_vectors_animation(down_vectors)- )- self.play(- FadeIn(graph3),- brace.stretch, 0.5, 0, {"about_edge": LEFT},- )- self.wait(6)-- #- def get_down_vectors(self):- down_vectors = VGroup(*[- Vector(0.5 * DOWN)- for x in range(10 * 150)- ])- down_vectors.arrange_in_grid(10, 150, buff=MED_SMALL_BUFF)- down_vectors.set_color_by_gradient(BLUE, RED)- # for vect in down_vectors:- # vect.shift(0.1 * np.random.random(3))- down_vectors.to_edge(RIGHT)- return down_vectors-- def get_down_vectors_animation(self, down_vectors):- return LaggedStart(- *[- GrowArrow(v, rate_func=there_and_back)- for v in down_vectors- ],- lag_ratio=0.0005,- run_time=2,- remover=True- )---class MultiplePendulumsOverlayed(Scene):- CONFIG = {- "initial_thetas": [- 150 * DEGREES,- 90 * DEGREES,- 60 * DEGREES,- 30 * DEGREES,- 10 * DEGREES,- ],- "weight_colors": [- PINK, RED, GREEN, BLUE, GREY,- ],- "pendulum_config": {- "top_point": ORIGIN,- "length": 3,- },- }-- def construct(self):- pendulums = VGroup(*[- Pendulum(- initial_theta=theta,- weight_style={- "fill_color": wc,- "fill_opacity": 0.5,- },- **self.pendulum_config,- )- for theta, wc in zip(- self.initial_thetas,- self.weight_colors,- )- ])- for pendulum in pendulums:- pendulum.start_swinging()- pendulum.remove(pendulum.theta_label)-- randy = Randolph(color=BLUE_C)- randy.to_corner(DL)- randy.add_updater(lambda r: r.look_at(pendulums[0].weight))-- axes = ThetaVsTAxes(- x_max=20,- y_axis_config={- "unit_size": 0.5,- "tip_length": 0.3,- },- )- axes.to_corner(UL)- graphs = VGroup(*[- axes.get_live_drawn_graph(- pendulum,- stroke_color=pendulum.weight.get_color(),- stroke_width=1,- )- for pendulum in pendulums- ])-- self.add(pendulums)- self.add(axes, *graphs)- self.play(randy.change, "sassy")- self.wait(2)- self.play(Blink(randy))- self.wait(5)- self.play(randy.change, "angry")- self.play(Blink(randy))- self.wait(10)---class LowAnglePendulum(Scene):- CONFIG = {- "pendulum_config": {- "initial_theta": 20 * DEGREES,- "length": 2.0,- "damping": 0,- "top_point": ORIGIN,- },- "axes_config": {- "y_axis_config": {"unit_size": 0.75},- "x_axis_config": {- "unit_size": 0.5,- "numbers_to_show": range(2, 25, 2),- "number_scale_val": 0.5,- },- "x_max": 25,- "number_line_config": {- "tip_length": 0.3,- "stroke_width": 2,- }- },- "axes_corner": UL,- }-- def construct(self):- pendulum = Pendulum(**self.pendulum_config)- axes = ThetaVsTAxes(**self.axes_config)- axes.center()- axes.to_corner(self.axes_corner, buff=LARGE_BUFF)- graph = axes.get_live_drawn_graph(pendulum)-- L = pendulum.length- g = pendulum.gravity- theta0 = pendulum.initial_theta- prediction = axes.get_graph(- lambda t: theta0 * np.cos(t * np.sqrt(g / L))- )- dashed_prediction = DashedVMobject(prediction, num_dashes=300)- dashed_prediction.set_stroke(WHITE, 1)- prediction_formula = TexMobject(- "\\theta_0", "\\cos(\\sqrt{g / L} \\cdot t)"- )- prediction_formula.scale(0.75)- prediction_formula.next_to(- dashed_prediction, UP, SMALL_BUFF,- )-- theta0 = prediction_formula.get_part_by_tex("\\theta_0")- theta0_brace = Brace(theta0, UP, buff=SMALL_BUFF)- theta0_brace.stretch(0.5, 1, about_edge=DOWN)- theta0_label = Integer(- pendulum.initial_theta * 180 / PI,- unit="^\\circ"- )- theta0_label.scale(0.75)- theta0_label.next_to(theta0_brace, UP, SMALL_BUFF)-- group = VGroup(theta0_brace, theta0_label, prediction_formula)- group.shift_onto_screen(buff=MED_SMALL_BUFF)-- self.add(axes, dashed_prediction, pendulum)- self.play(- ShowCreation(dashed_prediction, run_time=2),- FadeInFromDown(prediction_formula),- FadeInFromDown(theta0_brace),- FadeInFromDown(theta0_label),- )- self.play(- ShowCreationThenFadeAround(theta0_label),- ShowCreationThenFadeAround(pendulum.theta_label),- )- self.wait()-- pendulum.start_swinging()- self.add(graph)- self.wait(30)---class ApproxWordsLowAnglePendulum(Scene):- def construct(self):- period = TexMobject(- "\\text{Period}", "\\approx",- "2\\pi \\sqrt{\\,{L} / {g}}",- **Lg_formula_config- )- checkmark = TexMobject("\\checkmark")- checkmark.set_color(GREEN)- checkmark.scale(2)- checkmark.next_to(period, RIGHT, MED_LARGE_BUFF)-- self.add(period, checkmark)---class MediumAnglePendulum(LowAnglePendulum):- CONFIG = {- "pendulum_config": {- "initial_theta": 50 * DEGREES,- "n_steps_per_frame": 1000,- },- "axes_config": {- "y_axis_config": {"unit_size": 0.75},- "y_max": PI / 2,- "y_min": -PI / 2,- "number_line_config": {- "tip_length": 0.3,- "stroke_width": 2,- }- },- "pendulum_shift_vect": 1 * RIGHT,- }---class MediumHighAnglePendulum(MediumAnglePendulum):- CONFIG = {- "pendulum_config": {- "initial_theta": 90 * DEGREES,- "n_steps_per_frame": 1000,- },- }---class HighAnglePendulum(LowAnglePendulum):- CONFIG = {- "pendulum_config": {- "initial_theta": 175 * DEGREES,- "n_steps_per_frame": 1000,- "top_point": 1.5 * DOWN,- "length": 2,- },- "axes_config": {- "y_axis_config": {"unit_size": 0.5},- "y_max": PI,- "y_min": -PI,- "number_line_config": {- "tip_length": 0.3,- "stroke_width": 2,- }- },- "pendulum_shift_vect": 1 * RIGHT,- }---class VeryLowAnglePendulum(LowAnglePendulum):- CONFIG = {- "pendulum_config": {- "initial_theta": 10 * DEGREES,- "n_steps_per_frame": 1000,- "top_point": ORIGIN,- "length": 3,- },- "axes_config": {- "y_axis_config": {"unit_size": 2},- "y_max": PI / 4,- "y_min": -PI / 4,- "number_line_config": {- "tip_length": 0.3,- "stroke_width": 2,- }- },- "pendulum_shift_vect": 1 * RIGHT,- }---class WherePendulumLeads(PiCreatureScene):- def construct(self):- pendulum = Pendulum(- top_point=UP,- length=3,- gravity=20,- )- pendulum.start_swinging()-- l_title = TextMobject("Linearization")- l_title.scale(1.5)- l_title.to_corner(UL)- c_title = TextMobject("Chaos")- c_title.scale(1.5)- c_title.move_to(l_title)- c_title.move_to(- c_title.get_center() * np.array([-1, 1, 1])- )-- get_theta = pendulum.get_theta- spring = always_redraw(- lambda: ParametricFunction(- lambda t: np.array([- np.cos(TAU * t) + (1.4 + get_theta()) * t,- np.sin(TAU * t) - 0.5,- 0,- ]),- t_min=-0.5,- t_max=7,- color=GREY,- sheen_factor=1,- sheen_direction=UL,- ).scale(0.2).to_edge(LEFT, buff=0)- )- spring_rect = SurroundingRectangle(- spring, buff=MED_LARGE_BUFF,- stroke_width=0,- fill_color=BLACK,- fill_opacity=0,- )-- weight = Dot(radius=0.25)- weight.add_updater(lambda m: m.move_to(- spring.points[-1]- ))- weight.set_color(BLUE)- weight.set_sheen(1, UL)- spring_system = VGroup(spring, weight)-- linear_formula = TexMobject(- "\\frac{d \\vec{\\textbf{x}}}{dt}="- "A\\vec{\\textbf{x}}"- )- linear_formula.next_to(spring, UP, LARGE_BUFF)- linear_formula.match_x(l_title)-- randy = self.pi_creature- randy.set_height(2)- randy.center()- randy.to_edge(DOWN)- randy.shift(3 * LEFT)- q_marks = TexMobject("???")- q_marks.next_to(randy, UP)-- self.add(pendulum, randy)- self.play(- randy.change, "pondering", pendulum,- FadeInFromDown(q_marks, lag_ratio=0.3)- )- self.play(randy.look_at, pendulum)- self.wait(5)- self.play(- Animation(VectorizedPoint(pendulum.get_top())),- FadeOutAndShift(q_marks, UP, lag_ratio=0.3),- )- self.add(spring_system)- self.play(- FadeOut(spring_rect),- FadeInFrom(linear_formula, UP),- FadeInFromDown(l_title),- )- self.play(FadeInFromDown(c_title))- self.wait(8)---class LongDoublePendulum(ExternallyAnimatedScene):- pass---class AnalyzePendulumForce(MovingCameraScene):- CONFIG = {- "pendulum_config": {- "length": 5,- "top_point": 3.5 * UP,- "initial_theta": 60 * DEGREES,- "set_theta_label_height_cap": True,- },- "g_vect_config": {- "length_multiple": 0.25,- },- "tan_line_color": BLUE,- "perp_line_color": PINK,- }-- def construct(self):- self.add_pendulum()- self.show_arc_length()- self.add_g_vect()- self.show_constraint()- self.break_g_vect_into_components()- self.show_angle_geometry()- self.show_gsin_formula()- self.show_sign()- self.show_acceleration_formula()- # self.ask_about_what_to_do()-- # self.emphasize_theta()- # self.show_angular_velocity()- # self.show_angular_acceleration()- # self.circle_g_sin_formula()-- def add_pendulum(self):- pendulum = Pendulum(**self.pendulum_config)- theta_tracker = ValueTracker(pendulum.get_theta())- pendulum.add_updater(lambda p: p.set_theta(- theta_tracker.get_value()- ))-- self.add(pendulum)- self.pendulum = pendulum- self.theta_tracker = theta_tracker-- def show_arc_length(self):- pendulum = self.pendulum- angle = pendulum.get_theta()- height = pendulum.length- top = pendulum.get_fixed_point()-- line = Line(UP, DOWN)- line.set_height(height)- line.move_to(top, UP)- arc = always_redraw(lambda: Arc(- start_angle=-90 * DEGREES,- angle=pendulum.get_theta(),- arc_center=pendulum.get_fixed_point(),- radius=pendulum.length,- stroke_color=GREEN,- ))-- brace = Brace(Line(ORIGIN, 5 * UP), RIGHT)- brace.point = VectorizedPoint(brace.get_right())- brace.add(brace.point)- brace.set_height(angle)- brace.move_to(ORIGIN, DL)- brace.apply_complex_function(np.exp)- brace.scale(height)- brace.rotate(-90 * DEGREES)- brace.move_to(arc)- brace.shift(MED_SMALL_BUFF * normalize(- arc.point_from_proportion(0.5) - top- ))- x_sym = TexMobject("x")- x_sym.set_color(GREEN)- x_sym.next_to(brace.point, DR, buff=SMALL_BUFF)-- rhs = TexMobject("=", "L", "\\theta")- rhs.set_color_by_tex("\\theta", BLUE)- rhs.next_to(x_sym, RIGHT)- rhs.shift(0.7 * SMALL_BUFF * UP)- line_L = TexMobject("L")- line_L.next_to(- pendulum.rod.get_center(), UR, SMALL_BUFF,- )-- self.play(- ShowCreation(arc),- Rotate(line, angle, about_point=top),- UpdateFromAlphaFunc(- line, lambda m, a: m.set_stroke(- width=2 * there_and_back(a)- )- ),- GrowFromPoint(- brace, line.get_bottom(),- path_arc=angle- ),- )- self.play(FadeInFrom(x_sym, UP))- self.wait()-- # Show equation- line.set_stroke(BLUE, 5)- self.play(- ShowCreationThenFadeOut(line),- FadeInFromDown(line_L)- )- self.play(- TransformFromCopy(- line_L, rhs.get_part_by_tex("L")- ),- Write(rhs.get_part_by_tex("="))- )- self.play(- TransformFromCopy(- pendulum.theta_label,- rhs.get_parts_by_tex("\\theta"),- )- )- self.add(rhs)-- x_eq = VGroup(x_sym, rhs)-- self.play(- FadeOut(brace),- x_eq.rotate, angle / 2,- x_eq.next_to, arc.point_from_proportion(0.5),- UL, {"buff": -MED_SMALL_BUFF}- )-- self.x_eq = x_eq- self.arc = arc- self.line_L = line_L-- def add_g_vect(self):- pendulum = self.pendulum-- g_vect = self.g_vect = GravityVector(- pendulum, **self.g_vect_config,- )- g_word = self.g_word = TextMobject("Gravity")- g_word.rotate(-90 * DEGREES)- g_word.scale(0.75)- g_word.add_updater(lambda m: m.next_to(- g_vect, RIGHT, buff=-SMALL_BUFF,- ))-- self.play(- GrowArrow(g_vect),- FadeInFrom(g_word, UP, lag_ratio=0.1),- )- self.wait()-- def show_constraint(self):- pendulum = self.pendulum-- arcs = VGroup()- for u in [-1, 2, -1]:- d_theta = 40 * DEGREES * u- arc = Arc(- start_angle=pendulum.get_theta() - 90 * DEGREES,- angle=d_theta,- radius=pendulum.length,- arc_center=pendulum.get_fixed_point(),- stroke_width=2,- stroke_color=YELLOW,- stroke_opacity=0.5,- )- self.play(- self.theta_tracker.increment_value, d_theta,- ShowCreation(arc)- )- arcs.add(arc)- self.play(FadeOut(arcs))-- def break_g_vect_into_components(self):- g_vect = self.g_vect- g_vect.component_lines = always_redraw(- g_vect.create_component_lines- )- tan_line, perp_line = g_vect.component_lines- g_vect.tangent = always_redraw(lambda: Arrow(- tan_line.get_start(),- tan_line.get_end(),- buff=0,- color=self.tan_line_color,- ))- g_vect.perp = always_redraw(lambda: Arrow(- perp_line.get_start(),- perp_line.get_end(),- buff=0,- color=self.perp_line_color,- ))-- self.play(ShowCreation(g_vect.component_lines))- self.play(GrowArrow(g_vect.tangent))- self.wait()- self.play(GrowArrow(g_vect.perp))- self.wait()-- def show_angle_geometry(self):- g_vect = self.g_vect-- arc = Arc(- start_angle=90 * DEGREES,- angle=self.pendulum.get_theta(),- radius=0.5,- arc_center=g_vect.get_end(),- )- q_mark = TexMobject("?")- q_mark.next_to(arc.get_center(), UL, SMALL_BUFF)- theta_label = TexMobject("\\theta")- theta_label.move_to(q_mark)-- self.add(g_vect)- self.play(- ShowCreation(arc),- Write(q_mark)- )- self.play(ShowCreationThenFadeAround(q_mark))- self.wait()- self.play(ShowCreationThenFadeAround(- self.pendulum.theta_label- ))- self.play(- TransformFromCopy(- self.pendulum.theta_label,- theta_label,- ),- FadeOut(q_mark)- )- self.wait()- self.play(WiggleOutThenIn(g_vect.tangent))- self.play(WiggleOutThenIn(- Line(- *g_vect.get_start_and_end(),- buff=0,- ).add_tip().match_style(g_vect),- remover=True- ))- self.wait()- self.play(- FadeOut(arc),- FadeOut(theta_label),- )-- def show_gsin_formula(self):- g_vect = self.g_vect- g_word = self.g_word- g_word.clear_updaters()-- g_term = self.g_term = TexMobject("-g")- g_term.add_updater(lambda m: m.next_to(- g_vect,- RIGHT if self.pendulum.get_theta() >= 0 else LEFT,- SMALL_BUFF- ))-- def create_vect_label(vect, tex, direction):- label = TexMobject(tex)- label.set_stroke(width=0, background=True)- label.add_background_rectangle()- label.scale(0.7)- max_width = 0.9 * vect.get_length()- if label.get_width() > max_width:- label.set_width(max_width)- angle = vect.get_angle()- angle = (angle + PI / 2) % PI - PI / 2- label.next_to(ORIGIN, direction, SMALL_BUFF)- label.rotate(angle, about_point=ORIGIN)- label.shift(vect.get_center())- return label-- g_sin_label = always_redraw(lambda: create_vect_label(- g_vect.tangent, "-g\\sin(\\theta)", UP,- ))- g_cos_label = always_redraw(lambda: create_vect_label(- g_vect.perp, "-g\\cos(\\theta)", DOWN,- ))-- self.play(- ReplacementTransform(g_word[0][0], g_term[0][1]),- FadeOut(g_word[0][1:]),- Write(g_term[0][0]),- )- self.add(g_term)- self.wait()- for label in g_sin_label, g_cos_label:- self.play(- GrowFromPoint(label[0], g_term.get_center()),- TransformFromCopy(g_term, label[1][:2]),- GrowFromPoint(label[1][2:], g_term.get_center()),- remover=True- )- self.add(label)- self.wait()-- self.g_sin_label = g_sin_label- self.g_cos_label = g_cos_label-- def show_sign(self):- get_theta = self.pendulum.get_theta- theta_decimal = DecimalNumber(include_sign=True)- theta_decimal.add_updater(lambda d: d.set_value(- get_theta()- ))- theta_decimal.add_updater(lambda m: m.next_to(- self.pendulum.theta_label, DOWN- ))- theta_decimal.add_updater(lambda m: m.set_color(- GREEN if get_theta() > 0 else RED- ))-- self.play(- FadeInFrom(theta_decimal, UP),- FadeOut(self.x_eq),- FadeOut(self.line_L),- )- self.set_theta(-60 * DEGREES, run_time=4)- self.set_theta(60 * DEGREES, run_time=4)- self.play(- FadeOut(theta_decimal),- FadeIn(self.x_eq),- )-- def show_acceleration_formula(self):- x_eq = self.x_eq- g_sin_theta = self.g_sin_label-- equation = TexMobject(- "a", "=",- "\\ddot", "x",- "=",- "-", "g", "\\sin\\big(", "\\theta", "\\big)",- )- equation.to_edge(LEFT)-- second_deriv = equation[2:4]- x_part = equation.get_part_by_tex("x")- x_part.set_color(GREEN)- a_eq = equation[:2]- eq2 = equation.get_parts_by_tex("=")[1]- rhs = equation[5:]-- second_deriv_L_form = TexMobject(- "L", "\\ddot", "\\theta"- )- second_deriv_L_form.move_to(second_deriv, DOWN)- eq3 = TexMobject("=")- eq3.rotate(90 * DEGREES)- eq3.next_to(second_deriv_L_form, UP)-- g_L_frac = TexMobject(- "-", "{g", "\\over", "L}"- )- g_L_frac.move_to(rhs[:2], LEFT)- g_L_frac.shift(SMALL_BUFF * UP / 2)-- mu_term = TexMobject(- "-\\mu", "\\dot", "\\theta",- )- mu_term.next_to(g_L_frac, LEFT)- mu_term.shift(SMALL_BUFF * UP / 2)-- mu_brace = Brace(mu_term, UP)- mu_word = mu_brace.get_text("Air resistance")-- for mob in equation, second_deriv_L_form, mu_term:- mob.set_color_by_tex("\\theta", BLUE)-- self.play(- TransformFromCopy(x_eq[0], x_part),- Write(equation[:3]),- )- self.wait()- self.play(- Write(eq2),- TransformFromCopy(g_sin_theta, rhs)- )- self.wait()- #- self.show_acceleration_at_different_angles()- #- self.play(- FadeInFromDown(second_deriv_L_form),- Write(eq3),- second_deriv.next_to, eq3, UP,- a_eq.shift, SMALL_BUFF * LEFT,- eq2.shift, SMALL_BUFF * RIGHT,- rhs.shift, SMALL_BUFF * RIGHT,- )- self.wait()- self.wait()- self.play(- FadeOut(a_eq),- FadeOut(second_deriv),- FadeOut(eq3),- ReplacementTransform(- second_deriv_L_form.get_part_by_tex("L"),- g_L_frac.get_part_by_tex("L"),- ),- ReplacementTransform(- equation.get_part_by_tex("-"),- g_L_frac.get_part_by_tex("-"),- ),- ReplacementTransform(- equation.get_part_by_tex("g"),- g_L_frac.get_part_by_tex("g"),- ),- Write(g_L_frac.get_part_by_tex("\\over")),- rhs[2:].next_to, g_L_frac, RIGHT, {"buff": SMALL_BUFF},- )- self.wait()- self.play(- GrowFromCenter(mu_term),- VGroup(eq2, second_deriv_L_form[1:]).next_to,- mu_term, LEFT,- )- self.play(- GrowFromCenter(mu_brace),- FadeInFromDown(mu_word),- )-- def show_acceleration_at_different_angles(self):- to_fade = VGroup(- self.g_cos_label,- self.g_vect.perp,- )- new_comp_line_sytle = {- "stroke_width": 0.5,- "stroke_opacity": 0.25,- }-- self.play(- FadeOut(self.x_eq),- to_fade.set_opacity, 0.25,- self.g_vect.component_lines.set_style,- new_comp_line_sytle- )- self.g_vect.component_lines.add_updater(- lambda m: m.set_style(**new_comp_line_sytle)- )- for mob in to_fade:- mob.add_updater(lambda m: m.set_opacity(0.25))-- self.set_theta(0)- self.wait(2)- self.set_theta(89.9 * DEGREES, run_time=3)- self.wait(2)- self.set_theta(- 60 * DEGREES,- FadeIn(self.x_eq),- run_time=2,- )- self.wait()-- def ask_about_what_to_do(self):- g_vect = self.g_vect- g_sin_label = self.g_sin_label- angle = g_vect.tangent.get_angle()- angle = (angle - PI) % TAU-- randy = You()- randy.to_corner(DL)- bubble = randy.get_bubble(- height=2,- width=3.5,- )- g_sin_copy = g_sin_label.copy()- g_sin_copy.remove(g_sin_copy[0])- g_sin_copy.generate_target()- g_sin_copy.target.scale(1 / 0.75)- g_sin_copy.target.rotate(-angle)- a_eq = TexMobject("a=")- thought_term = VGroup(a_eq, g_sin_copy.target)- thought_term.arrange(RIGHT, buff=SMALL_BUFF)- thought_term.move_to(bubble.get_bubble_center())-- rect = SurroundingRectangle(g_sin_copy.target)- rect.rotate(angle)- rect.move_to(g_sin_label)-- randy.save_state()- randy.fade(1)- self.play(randy.restore, randy.change, "pondering")- self.play(ShowCreationThenFadeOut(rect))- self.play(- ShowCreation(bubble),- Write(a_eq),- MoveToTarget(g_sin_copy),- randy.look_at, bubble,- )- thought_term.remove(g_sin_copy.target)- thought_term.add(g_sin_copy)- self.play(Blink(randy))- self.wait()- self.play(- ShowCreationThenDestruction(- thought_term.copy().set_style(- stroke_color=YELLOW,- stroke_width=2,- fill_opacity=0,- ),- run_time=2,- lag_ratio=0.2,- ),- randy.change, "confused", thought_term,- )- self.play(Blink(randy))- self.play(- FadeOut(randy),- FadeOut(bubble),- thought_term.next_to, self.pendulum, DOWN, LARGE_BUFF- )-- self.accleration_equation = thought_term-- def emphasize_theta(self):- pendulum = self.pendulum-- self.play(FocusOn(pendulum.theta_label))- self.play(Indicate(pendulum.theta_label))-- pendulum_copy = pendulum.deepcopy()- pendulum_copy.clear_updaters()- pendulum_copy.fade(1)- pendulum_copy.start_swinging()-- def new_updater(p):- p.set_theta(pendulum_copy.get_theta())- pendulum.add_updater(new_updater)-- self.add(pendulum_copy)- self.wait(5)- pendulum_copy.end_swinging()- self.remove(pendulum_copy)- pendulum.remove_updater(new_updater)- self.update_mobjects(0)-- def show_angular_velocity(self):- pass-- def show_angular_acceleration(self):- pass-- def circle_g_sin_formula(self):- self.play(- ShowCreationThenFadeAround(- self.accleration_equation- )- )-- #- def set_theta(self, value, *added_anims, **kwargs):- kwargs["run_time"] = kwargs.get("run_time", 2)- self.play(- self.theta_tracker.set_value, value,- *added_anims,- **kwargs,- )---class BuildUpEquation(Scene):- CONFIG = {- "tex_config": {- "tex_to_color_map": {- "{a}": YELLOW,- "{v}": RED,- "{x}": GREEN,- "\\theta": BLUE,- "{L}": WHITE,- }- }- }-- def construct(self):- # self.add_center_line()- self.show_derivatives()- self.show_theta_double_dot_equation()- self.talk_about_sine_component()- self.add_air_resistance()-- def add_center_line(self):- line = Line(UP, DOWN)- line.set_height(FRAME_HEIGHT)- line.set_stroke(WHITE, 1)- self.add(line)-- def show_derivatives(self):- a_eq = TexMobject(- "{a}", "=", "{d{v} \\over dt}",- **self.tex_config,- )- v_eq = TexMobject(- "{v}", "=", "{d{x} \\over dt}",- **self.tex_config,- )- x_eq = TexMobject(- "{x} = {L} \\theta",- **self.tex_config,- )- eqs = VGroup(a_eq, v_eq, x_eq)- eqs.arrange(DOWN, buff=LARGE_BUFF)- eqs.to_corner(UL)-- v_rhs = TexMobject(- "={L}{d\\theta \\over dt}",- "=", "{L}\\dot{\\theta}",- **self.tex_config,- )-- v_rhs.next_to(v_eq, RIGHT, SMALL_BUFF)- v_rhs.shift(- UP * (v_eq[1].get_bottom()[1] - v_rhs[0].get_bottom()[1])- )- a_rhs = TexMobject(- "={L}{d", "\\dot{\\theta}", "\\over dt}",- "=", "{L}\\ddot{\\theta}",- **self.tex_config,- )- a_rhs.next_to(a_eq, RIGHT, SMALL_BUFF)- a_rhs.shift(- UP * (a_eq[1].get_bottom()[1] - a_rhs[0].get_bottom()[1])- )-- # a_eq- self.play(Write(a_eq))- self.wait()-- # v_eq- self.play(- TransformFromCopy(- a_eq.get_part_by_tex("{v}"),- v_eq.get_part_by_tex("{v}"),- )- )- self.play(TransformFromCopy(v_eq[:1], v_eq[1:]))- self.wait()-- # x_eq- self.play(- TransformFromCopy(- v_eq.get_part_by_tex("{x}"),- x_eq.get_part_by_tex("{x}"),- )- )- self.play(Write(x_eq[1:]))- self.wait()- for tex in "L", "\\theta":- self.play(ShowCreationThenFadeAround(- x_eq.get_part_by_tex(tex)- ))- self.wait()-- # v_rhs- self.play(*[- TransformFromCopy(- x_eq.get_part_by_tex(tex),- v_rhs.get_part_by_tex(tex),- )- for tex in ("=", "{L}", "\\theta")- ])- self.play(- TransformFromCopy(v_eq[-3], v_rhs[2]),- TransformFromCopy(v_eq[-1], v_rhs[4]),- )- self.wait()- self.play(- Write(v_rhs[-5]),- TransformFromCopy(*v_rhs.get_parts_by_tex("{L}")),- TransformFromCopy(v_rhs[3:4], v_rhs[-3:])- )- self.wait()- self.play(ShowCreationThenFadeAround(v_rhs[2:4]))- self.play(ShowCreationThenFadeAround(v_rhs[4]))- self.wait()-- # a_rhs- self.play(*[- TransformFromCopy(- v_rhs.get_parts_by_tex(tex)[-1],- a_rhs.get_part_by_tex(tex),- )- for tex in ("=", "{L}", "\\theta", "\\dot")- ])- self.play(- TransformFromCopy(a_eq[-3], a_rhs[2]),- TransformFromCopy(a_eq[-1], a_rhs[6]),- )- self.wait()- self.play(- Write(a_rhs[-5]),- TransformFromCopy(*a_rhs.get_parts_by_tex("{L}")),- TransformFromCopy(a_rhs[3:4], a_rhs[-3:]),- )- self.wait()-- self.equations = VGroup(- a_eq, v_eq, x_eq,- v_rhs, a_rhs,- )-- def show_theta_double_dot_equation(self):- equations = self.equations- a_deriv = equations[0]- a_rhs = equations[-1][-5:].copy()-- shift_vect = 1.5 * DOWN-- equals = TexMobject("=")- equals.rotate(90 * DEGREES)- equals.next_to(a_deriv[0], UP, MED_LARGE_BUFF)- g_sin_eq = TexMobject(- "-", "g", "\\sin", "(", "\\theta", ")",- **self.tex_config,- )- g_sin_eq.next_to(- equals, UP,- buff=MED_LARGE_BUFF,- aligned_edge=LEFT,- )- g_sin_eq.to_edge(LEFT)- g_sin_eq.shift(shift_vect)-- shift_vect += (- g_sin_eq[1].get_center() -- a_deriv[0].get_center()- )[0] * RIGHT-- equals.shift(shift_vect)- a_rhs.shift(shift_vect)-- self.play(- equations.shift, shift_vect,- Write(equals),- GrowFromPoint(- g_sin_eq, 2 * RIGHT + 3 * DOWN- )- )- self.wait()- self.play(- a_rhs.next_to, g_sin_eq, RIGHT,- a_rhs.shift, SMALL_BUFF * UP,- )- self.wait()-- # Fade equations- self.play(- FadeOut(equals),- equations.shift, DOWN,- equations.fade, 0.5,- )-- # Rotate sides- equals, L, ddot, theta, junk = a_rhs- L_dd_theta = VGroup(L, ddot, theta)- minus, g, sin, lp, theta2, rp = g_sin_eq- m2, g2, over, L2 = frac = TexMobject("-", "{g", "\\over", "L}")- frac.next_to(equals, RIGHT)-- self.play(- L_dd_theta.next_to, equals, LEFT,- L_dd_theta.shift, SMALL_BUFF * UP,- g_sin_eq.next_to, equals, RIGHT,- path_arc=PI / 2,- )- self.play(- ReplacementTransform(g, g2),- ReplacementTransform(minus, m2),- ReplacementTransform(L, L2),- Write(over),- g_sin_eq[2:].next_to, over, RIGHT, SMALL_BUFF,- )- self.wait()-- # Surround- rect = SurroundingRectangle(VGroup(g_sin_eq, frac, ddot))- rect.stretch(1.1, 0)- dashed_rect = DashedVMobject(- rect, num_dashes=50, positive_space_ratio=1,- )- dashed_rect.shuffle()- dashed_rect.save_state()- dashed_rect.space_out_submobjects(1.1)- for piece in dashed_rect:- piece.rotate(90 * DEGREES)- dashed_rect.fade(1)- self.play(Restore(dashed_rect, lag_ratio=0.05))- dashed_rect.generate_target()- dashed_rect.target.space_out_submobjects(0.9)- dashed_rect.target.fade(1)- for piece in dashed_rect.target:- piece.rotate(90 * DEGREES)- self.play(MoveToTarget(- dashed_rect,- lag_ratio=0.05,- remover=True- ))- self.wait()-- self.main_equation = VGroup(- ddot, theta, equals,- m2, L2, over, g2,- sin, lp, theta2, rp,- )-- def talk_about_sine_component(self):- main_equation = self.main_equation- gL_part = main_equation[4:7]- sin_part = main_equation[7:]- sin = sin_part[0]-- morty = Mortimer(height=1.5)- morty.next_to(sin, DR, buff=LARGE_BUFF)- morty.add_updater(lambda m: m.look_at(sin))-- self.play(ShowCreationThenFadeAround(gL_part))- self.wait()- self.play(ShowCreationThenFadeAround(sin_part))- self.wait()-- self.play(FadeIn(morty))- sin.save_state()- self.play(- morty.change, "angry",- sin.next_to, morty, LEFT, {"aligned_edge": UP},- )- self.play(Blink(morty))- morty.clear_updaters()- self.play(- morty.change, "concerned_musician",- morty.look, DR,- )- self.play(Restore(sin))- self.play(FadeOut(morty))- self.wait()-- # Emphasize theta as input- theta = sin_part[2]- arrow = Vector(0.5 * UP, color=WHITE)- arrow.next_to(theta, DOWN, SMALL_BUFF)- word = TextMobject("Input")- word.next_to(arrow, DOWN)-- self.play(- FadeInFrom(word, UP),- GrowArrow(arrow)- )- self.play(- ShowCreationThenDestruction(- theta.copy().set_style(- fill_opacity=0,- stroke_width=2,- stroke_color=YELLOW,- ),- lag_ratio=0.1,- )- )- self.play(FadeOut(arrow), FadeOut(word))-- def add_air_resistance(self):- main_equation = self.main_equation- tdd_eq = main_equation[:3]- rhs = main_equation[3:]-- new_term = TexMobject(- "-", "\\mu", "\\dot{", "\\theta}",- )- new_term.set_color_by_tex("\\theta", BLUE)- new_term.move_to(main_equation)- new_term.shift(0.5 * SMALL_BUFF * UP)- new_term[0].align_to(rhs[0], UP)-- brace = Brace(new_term, DOWN)- words = brace.get_text("Air resistance")-- self.play(- FadeInFromDown(new_term),- tdd_eq.next_to, new_term, LEFT,- tdd_eq.align_to, tdd_eq, UP,- rhs.next_to, new_term, RIGHT,- rhs.align_to, rhs, UP,- )- self.play(- GrowFromCenter(brace),- Write(words)- )- self.wait()---class SimpleDampenedPendulum(Scene):- def construct(self):- pendulum = Pendulum(- top_point=ORIGIN,- initial_theta=150 * DEGREES,- mu=0.5,- )- self.add(pendulum)- pendulum.start_swinging()- self.wait(20)---class NewSceneName(Scene):- def construct(self):- passdiff --git a/active_projects/ode/part1/phase_space.py b/active_projects/ode/part1/phase_space.pydeleted file mode 100644index 549ac28b5..000000000--- a/active_projects/ode/part1/phase_space.py+++ /dev/null@@ -1,2079 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.shared_constructs import *-from active_projects.ode.part1.pendulum import Pendulum---# TODO: Arguably separate the part showing many-# configurations with the part showing just one.-class VisualizeStates(Scene):- CONFIG = {- "coordinate_plane_config": {- "y_line_frequency": PI / 2,- # "x_line_frequency": PI / 2,- "x_line_frequency": 1,- "y_axis_config": {- # "unit_size": 1.75,- "unit_size": 1,- },- "y_max": 4,- "faded_line_ratio": 4,- "background_line_style": {- "stroke_width": 1,- },- },- "little_pendulum_config": {- "length": 1,- "gravity": 4.9,- "weight_diameter": 0.3,- "include_theta_label": False,- "include_velocity_vector": True,- "angle_arc_config": {- "radius": 0.2,- },- "velocity_vector_config": {- "max_tip_length_to_length_ratio": 0.35,- "max_stroke_width_to_length_ratio": 6,- },- "velocity_vector_multiple": 0.25,- "max_velocity_vector_length_to_length_ratio": 0.8,- },- "big_pendulum_config": {- "length": 1.6,- "gravity": 4.9,- "damping": 0.2,- "weight_diameter": 0.3,- "include_velocity_vector": True,- "angle_arc_config": {- "radius": 0.5,- },- "initial_theta": 80 * DEGREES,- "omega": -1,- "set_theta_label_height_cap": True,- },- "n_thetas": 11,- "n_omegas": 7,- # "n_thetas": 5,- # "n_omegas": 3,- "initial_grid_wait_time": 15,- }-- def construct(self):- self.initialize_plane()-- simple = False- if simple:- self.add(self.plane)- else:- self.initialize_grid_of_states()- self.show_all_states_evolving()- self.show_grid_of_states_creation()- self.collapse_grid_into_points()- self.show_state_with_pair_of_numbers()- self.show_acceleration_dependence()- self.show_evolution_from_a_start_state()-- def initialize_grid_of_states(self):- pendulums = VGroup()- rects = VGroup()- state_grid = VGroup()- thetas = self.get_initial_thetas()- omegas = self.get_initial_omegas()- for omega in omegas:- row = VGroup()- for theta in thetas:- rect = Rectangle(- height=3,- width=3,- stroke_color=WHITE,- stroke_width=2,- fill_color=DARKER_GREY,- fill_opacity=1,- )- pendulum = Pendulum(- initial_theta=theta,- omega=omega,- top_point=rect.get_center(),- **self.little_pendulum_config,- )- pendulum.add_velocity_vector()- pendulums.add(pendulum)- rects.add(rect)- state = VGroup(rect, pendulum)- state.rect = rect- state.pendulum = pendulum- row.add(state)- row.arrange(RIGHT, buff=0)- state_grid.add(row)- state_grid.arrange(UP, buff=0)-- state_grid.set_height(FRAME_HEIGHT)- state_grid.center()- state_grid.save_state(use_deepcopy=True)-- self.state_grid = state_grid- self.pendulums = pendulums-- def initialize_plane(self):- plane = self.plane = NumberPlane(- **self.coordinate_plane_config- )- plane.axis_labels = VGroup(- plane.get_x_axis_label(- "\\theta", RIGHT, UL, buff=SMALL_BUFF- ),- plane.get_y_axis_label(- "\\dot \\theta", UP, DR, buff=SMALL_BUFF- ).set_color(YELLOW),- )- for label in plane.axis_labels:- label.add_background_rectangle()- plane.add(plane.axis_labels)-- plane.y_axis.add_numbers(direction=DL)-- x_axis = plane.x_axis- label_texs = ["\\pi \\over 2", "\\pi", "3\\pi \\over 2", "\\tau"]- values = [PI / 2, PI, 3 * PI / 2, TAU]- x_axis.coordinate_labels = VGroup()- x_axis.add(x_axis.coordinate_labels)- for value, label_tex in zip(values, label_texs):- for u in [-1, 1]:- tex = label_tex- if u < 0:- tex = "-" + tex- label = TexMobject(tex)- label.scale(0.5)- if label.get_height() > 0.4:- label.set_height(0.4)- point = x_axis.number_to_point(u * value)- label.next_to(point, DR, SMALL_BUFF)- x_axis.coordinate_labels.add(label)- return plane-- def show_all_states_evolving(self):- state_grid = self.state_grid- pendulums = self.pendulums-- for pendulum in pendulums:- pendulum.start_swinging()-- self.add(state_grid)- self.wait(self.initial_grid_wait_time)-- def show_grid_of_states_creation(self):- self.remove(self.state_grid)- self.initialize_grid_of_states() # Again- state_grid = self.state_grid-- title = TextMobject("All states")- title.to_edge(UP, buff=MED_SMALL_BUFF)- self.all_states_title = title-- state_grid.set_height(- FRAME_HEIGHT - title.get_height() - 2 * MED_SMALL_BUFF- )- state_grid.to_edge(DOWN, buff=0)-- def place_at_top(state):- state.set_height(3)- state.center()- state.next_to(title, DOWN)-- middle_row = state_grid[len(state_grid) // 2]- middle_row_copy = middle_row.deepcopy()- right_column_copy = VGroup(*[- row[-1] for row in state_grid- ]).deepcopy()-- for state in it.chain(middle_row_copy, right_column_copy):- place_at_top(state)-- self.add(title)- self.play(- ShowIncreasingSubsets(middle_row),- ShowIncreasingSubsets(middle_row_copy),- run_time=2,- rate_func=linear,- )- self.wait()- self.play(- ShowIncreasingSubsets(state_grid),- ShowIncreasingSubsets(right_column_copy),- run_time=2,- rate_func=linear,- )- self.remove(middle_row_copy)- self.remove(middle_row)- self.add(state_grid)- self.remove(right_column_copy)- self.play(- ReplacementTransform(- right_column_copy[-1],- state_grid[-1][-1],- remover=True- )- )- self.wait()-- def collapse_grid_into_points(self):- state_grid = self.state_grid- plane = self.plane-- dots = VGroup()- for row in state_grid:- for state in row:- dot = Dot(- self.get_state_point(state.pendulum),- radius=0.05,- color=YELLOW,- background_stroke_width=3,- background_stroke_color=BLACK,- )- dot.state = state- dots.add(dot)-- self.add(plane)- self.remove(state_grid)- flat_state_group = VGroup(*it.chain(*state_grid))- flat_dot_group = VGroup(*it.chain(*dots))- self.clear() # The nuclear option- self.play(- ShowCreation(plane),- FadeOut(self.all_states_title),- LaggedStart(*[- TransformFromCopy(m1, m2)- for m1, m2 in zip(flat_state_group, flat_dot_group)- ], lag_ratio=0.1, run_time=4)- )- self.clear() # Again, not sure why I need this- self.add(plane, dots)- self.wait()-- self.state_dots = dots-- def show_state_with_pair_of_numbers(self):- axis_labels = self.plane.axis_labels-- state = self.get_flexible_state_picture()- dot = self.get_state_controlling_dot(state)- h_line = always_redraw(- lambda: self.get_tracking_h_line(dot.get_center())- )- v_line = always_redraw(- lambda: self.get_tracking_v_line(dot.get_center())- )-- self.add(dot)- anims = [GrowFromPoint(state, dot.get_center())]- if hasattr(self, "state_dots"):- anims.append(FadeOut(self.state_dots))- self.play(*anims)-- for line, label in zip([h_line, v_line], axis_labels):- # self.add(line, dot)- self.play(- ShowCreation(line),- ShowCreationThenFadeAround(label),- run_time=1- )- for vect in LEFT, 3 * UP:- self.play(- ApplyMethod(- dot.shift, vect,- rate_func=there_and_back,- run_time=2,- )- )- self.wait()- for vect in 2 * LEFT, 3 * UP, 2 * RIGHT, 2 * DOWN:- self.play(dot.shift, vect, run_time=1.5)- self.wait()-- self.state = state- self.state_dot = dot- self.h_line = h_line- self.v_line = v_line-- def show_acceleration_dependence(self):- ode = get_ode()- thetas = ode.get_parts_by_tex("\\theta")- thetas[0].set_color(RED)- thetas[1].set_color(YELLOW)- ode.move_to(- FRAME_WIDTH * RIGHT / 4 +- FRAME_HEIGHT * UP / 4,- )- ode.add_background_rectangle_to_submobjects()-- self.play(Write(ode))- self.wait()- self.play(FadeOut(ode))-- def show_evolution_from_a_start_state(self):- state = self.state- dot = self.state_dot-- self.play(- Rotating(- dot,- about_point=dot.get_center() + UR,- rate_func=smooth,- )- )- self.wait()-- # Show initial trajectory- state.pendulum.clear_updaters(recursive=False)- self.tie_dot_position_to_state(dot, state)- state.pendulum.start_swinging()- trajectory = self.get_evolving_trajectory(dot)- self.add(trajectory)- for x in range(20):- self.wait()-- # Talk through start- trajectory.suspend_updating()- state.pendulum.end_swinging()- dot.clear_updaters()- self.tie_state_to_dot_position(state, dot)-- alphas = np.linspace(0, 0.1, 1000)- index = np.argmin([- trajectory.point_from_proportion(a)[1]- for a in alphas- ])- alpha = alphas[index]- sub_traj = trajectory.copy()- sub_traj.suspend_updating()- sub_traj.pointwise_become_partial(trajectory, 0, alpha)- sub_traj.match_style(trajectory)- sub_traj.set_stroke(width=3)-- self.wait()- self.play(dot.move_to, sub_traj.get_start())- self.wait()- self.play(- ShowCreation(sub_traj),- UpdateFromFunc(- dot, lambda d: d.move_to(sub_traj.get_end())- ),- run_time=6,- )- self.wait()-- # Comment on physical velocity vs. space position- v_vect = state.pendulum.velocity_vector- v_line_copy = self.v_line.copy()- v_line_copy.clear_updaters()- v_line_copy.set_stroke(PINK, 5)- td_label = self.plane.axis_labels[1]- y_axis_copy = self.plane.y_axis.copy()- y_axis_copy.submobjects = []- y_axis_copy.match_style(v_line_copy)-- self.play(ShowCreationThenFadeAround(v_vect))- self.play(- ShowCreationThenFadeAround(td_label),- ShowCreationThenFadeOut(y_axis_copy)- )- self.play(ShowCreationThenFadeOut(v_line_copy))- self.wait()-- # Abstract vs. physical- abstract = TextMobject("Abstract")- abstract.add_background_rectangle()- abstract.scale(2)- abstract.to_corner(UR)- physical = TextMobject("Physical")- physical.next_to(state.get_top(), DOWN)-- self.play(- ApplyMethod(- self.plane.set_stroke, YELLOW, 0.5,- rate_func=there_and_back,- lag_ratio=0.2,- ),- FadeInFromDown(abstract),- Animation(state),- )- self.wait()- self.play(FadeInFromDown(physical))- self.wait()-- # Continue on spiral- sub_traj.resume_updating()- state.pendulum.clear_updaters(recursive=False)- state.pendulum.start_swinging()- dot.clear_updaters()- self.tie_dot_position_to_state(dot, state)- self.wait(20)-- #- def get_initial_thetas(self):- angle = 3 * PI / 4- return np.linspace(-angle, angle, self.n_thetas)-- def get_initial_omegas(self):- return np.linspace(-1.5, 1.5, self.n_omegas)-- def get_state(self, pendulum):- return (pendulum.get_theta(), pendulum.get_omega())-- def get_state_point(self, pendulum):- return self.plane.coords_to_point(- *self.get_state(pendulum)- )-- def get_flexible_state_picture(self):- buff = MED_SMALL_BUFF- height = FRAME_HEIGHT / 2 - buff- rect = Square(- side_length=height,- stroke_color=WHITE,- stroke_width=2,- fill_color="#111111",- fill_opacity=1,- )- rect.to_corner(UL, buff=buff / 2)- pendulum = Pendulum(- top_point=rect.get_center(),- **self.big_pendulum_config- )- pendulum.fixed_point_tracker.add_updater(- lambda m: m.move_to(rect.get_center())- )-- state = VGroup(rect, pendulum)- state.rect = rect- state.pendulum = pendulum- return state-- def get_state_dot(self, state):- dot = Dot(color=PINK)- dot.move_to(self.get_state_point(state.pendulum))- return dot-- def get_state_controlling_dot(self, state):- dot = self.get_state_dot(state)- self.tie_state_to_dot_position(state, dot)- return dot-- def tie_state_to_dot_position(self, state, dot):- def update_pendulum(pend):- theta, omega = self.plane.point_to_coords(- dot.get_center()- )- pend.set_theta(theta)- pend.set_omega(omega)- return pend- state.pendulum.add_updater(update_pendulum)- state.pendulum.get_arc_angle_theta = \- lambda: self.plane.x_axis.point_to_number(dot.get_center())- return self-- def tie_dot_position_to_state(self, dot, state):- dot.add_updater(lambda d: d.move_to(- self.get_state_point(state.pendulum)- ))- return dot-- def get_tracking_line(self, point, axis, color=WHITE):- number = axis.point_to_number(point)- axis_point = axis.number_to_point(number)- return DashedLine(- axis_point, point,- dash_length=0.025,- color=color,- )-- def get_tracking_h_line(self, point):- return self.get_tracking_line(- point, self.plane.y_axis, WHITE,- )-- def get_tracking_v_line(self, point):- return self.get_tracking_line(- point, self.plane.x_axis, YELLOW,- )-- def get_evolving_trajectory(self, mobject):- trajectory = VMobject()- trajectory.start_new_path(mobject.get_center())- trajectory.set_stroke(RED, 1)-- def update_trajectory(traj):- point = mobject.get_center()- if get_norm(trajectory.points[-1] == point) > 0.05:- traj.add_smooth_curve_to(point)- trajectory.add_updater(update_trajectory)- return trajectory---class IntroduceVectorField(VisualizeStates):- CONFIG = {- "vector_field_config": {- "max_magnitude": 3,- # "delta_x": 2,- # "delta_y": 2,- },- "big_pendulum_config": {- "initial_theta": -80 * DEGREES,- "omega": 1,- }- }-- def construct(self):- self.initialize_plane()- self.add_flexible_state()- self.initialize_vector_field()- self.add_equation()- self.preview_vector_field()- self.write_vector_derivative()- self.interpret_first_coordinate()- self.interpret_second_coordinate()- self.show_full_vector_field()- self.show_trajectory()-- def initialize_plane(self):- super().initialize_plane()- self.add(self.plane)-- def initialize_vector_field(self):- self.vector_field = VectorField(- self.vector_field_func,- **self.vector_field_config,- )- self.vector_field.sort(get_norm)-- def add_flexible_state(self):- self.state = self.get_flexible_state_picture()- self.add(self.state)-- def add_equation(self):- ode = get_ode()- ode.set_width(self.state.get_width() - MED_LARGE_BUFF)- ode.next_to(self.state.get_top(), DOWN, SMALL_BUFF)- thetas = ode.get_parts_by_tex("\\theta")- thetas[0].set_color(RED)- thetas[1].set_color(YELLOW)- ode_word = TextMobject("Differential equation")- ode_word.match_width(ode)- ode_word.next_to(ode, DOWN)-- self.play(- FadeInFrom(ode, 0.5 * DOWN),- FadeInFrom(ode_word, 0.5 * UP),- )-- self.ode = ode- self.ode_word = ode_word-- def preview_vector_field(self):- vector_field = self.vector_field-- growth = LaggedStartMap(- GrowArrow, vector_field,- run_time=3,- lag_ratio=0.01,- )- self.add(- growth.mobject,- vector_field,- self.state, self.ode, self.ode_word- )-- self.play(growth)- self.wait()- self.play(FadeOut(vector_field))- self.remove(growth.mobject)-- def write_vector_derivative(self):- state = self.state- plane = self.plane-- dot = self.get_state_dot(state)-- # Vector- vect = Arrow(- plane.coords_to_point(0, 0),- dot.get_center(),- buff=0,- color=dot.get_color()- )- vect_sym, d_vect_sym = [- self.get_vector_symbol(- "{" + a + "\\theta}(t)",- "{" + b + "\\theta}(t)",- )- for a, b in [("", "\\dot"), ("\\dot", "\\ddot")]- ]- # vect_sym.get_entries()[1][0][1].set_color(YELLOW)- # d_vect_sym.get_entries()[0][0][1].set_color(YELLOW)- # d_vect_sym.get_entries()[1][0][1].set_color(RED)- vect_sym.next_to(vect.get_end(), UP, MED_LARGE_BUFF)- time_inputs = VGroup(*[- e[-1][-2] for e in vect_sym.get_entries()- ])-- # Derivative- ddt = TexMobject("d \\over dt")- ddt.set_height(0.9 * vect_sym.get_height())- ddt.next_to(vect_sym, LEFT)- ddt.set_stroke(BLACK, 5, background=True)- equals = TexMobject("=")- equals.add_background_rectangle()- equals.next_to(vect_sym, RIGHT, SMALL_BUFF)- d_vect_sym.next_to(equals, RIGHT, SMALL_BUFF)-- # Little vector- angle_tracker = ValueTracker(0)- mag_tracker = ValueTracker(0.75)- d_vect = always_redraw(- lambda: Vector(- rotate_vector(- mag_tracker.get_value() * RIGHT,- angle_tracker.get_value(),- ),- color=WHITE- ).shift(dot.get_center()),- )- d_vect_magnitude_factor_tracker = ValueTracker(2)- real_d_vect = always_redraw(- lambda: self.vector_field.get_vector(- dot.get_center()- ).scale(- d_vect_magnitude_factor_tracker.get_value(),- about_point=dot.get_center()- )- )-- # Show vector- self.play(TransformFromCopy(state[1], vect))- self.play(FadeInFromDown(vect_sym))- self.wait()- self.play(ReplacementTransform(vect, dot))- self.wait()- self.play(LaggedStartMap(- ShowCreationThenFadeAround, time_inputs,- lag_ratio=0.1,- ))- self.wait()-- # Write Derivative- self.play(Write(ddt))- self.play(- plane.y_axis.numbers.fade, 1,- FadeInFrom(equals, LEFT),- TransformFromCopy(vect_sym, d_vect_sym)- )- self.wait()-- # Show as little vector- equation_group = VGroup(- ddt, vect_sym, equals, d_vect_sym- )- self.play(- # equation_group.shift, 4 * DOWN,- equation_group.to_edge, RIGHT, LARGE_BUFF,- GrowArrow(d_vect),- )- self.wait()- self.play(angle_tracker.set_value, 120 * DEGREES)- self.play(mag_tracker.set_value, 1.5)- self.wait()-- # Highlight new vector- self.play(- ShowCreationThenFadeAround(d_vect_sym),- FadeOut(d_vect)- )- self.wait()- self.play(- TransformFromCopy(d_vect_sym, real_d_vect),- dot.set_color, WHITE,- )- self.wait()-- # Take a walk- trajectory = VMobject()- trajectory.start_new_path(dot.get_center())- dt = 0.01- for x in range(130):- p = trajectory.points[-1]- dp_dt = self.vector_field_func(p)- trajectory.add_smooth_curve_to(p + dp_dt * dt)- self.tie_state_to_dot_position(state, dot)- self.play(- MoveAlongPath(dot, trajectory),- run_time=5,- rate_func=bezier([0, 0, 1, 1]),- )-- self.state_dot = dot- self.d_vect = real_d_vect- self.equation_group = equation_group- self.d_vect_magnitude_factor_tracker = d_vect_magnitude_factor_tracker-- def interpret_first_coordinate(self):- equation = self.equation_group- ddt, vect_sym, equals, d_vect_sym = equation- dot = self.state_dot-- first_components_copy = VGroup(- vect_sym.get_entries()[0],- d_vect_sym.get_entries()[0],- ).copy()- rect = SurroundingRectangle(first_components_copy)- rect.set_stroke(YELLOW, 2)-- equation.save_state()-- self.play(- ShowCreation(rect),- equation.fade, 0.5,- Animation(first_components_copy),- )- self.wait()- dot.save_state()- self.play(dot.shift, 2 * UP)- self.wait()- self.play(dot.shift, 6 * DOWN)- self.wait()- self.play(dot.restore)- self.wait()-- self.play(- equation.restore,- FadeOut(rect),- )- self.remove(first_components_copy)-- def interpret_second_coordinate(self):- equation = self.equation_group- ddt, vect_sym, equals, d_vect_sym = equation-- second_components = VGroup(- vect_sym.get_entries()[1],- d_vect_sym.get_entries()[1],- )- rect = SurroundingRectangle(second_components)- rect.set_stroke(YELLOW, 2)-- expanded_derivative = self.get_vector_symbol(- "{\\dot\\theta}(t)",- "-\\mu {\\dot\\theta}(t)" +- "-(g / L) \\sin\\big({\\theta}(t)\\big)",- )- expanded_derivative.move_to(d_vect_sym)- expanded_derivative.to_edge(RIGHT, MED_SMALL_BUFF)- equals2 = TexMobject("=")- equals2.next_to(expanded_derivative, LEFT, SMALL_BUFF)-- equation.save_state()- self.play(- ShowCreation(rect),- )- self.wait()- self.play(- FadeInFrom(expanded_derivative, LEFT),- FadeIn(equals2),- equation.next_to, equals2, LEFT, SMALL_BUFF,- MaintainPositionRelativeTo(rect, equation),- VFadeOut(rect),- )- self.wait()-- self.full_equation = VGroup(- *equation, equals2, expanded_derivative,- )-- def show_full_vector_field(self):- vector_field = self.vector_field- state = self.state- ode = self.ode- ode_word = self.ode_word- equation = self.full_equation- d_vect = self.d_vect- dot = self.state_dot-- equation.generate_target()- equation.target.scale(0.7)- equation.target.to_edge(DOWN, LARGE_BUFF)- equation.target.to_edge(LEFT, MED_SMALL_BUFF)- equation_rect = BackgroundRectangle(equation.target)-- growth = LaggedStartMap(- GrowArrow, vector_field,- run_time=3,- lag_ratio=0.01,- )- self.add(- growth.mobject,- state, ode, ode_word,- equation_rect, equation, dot,- d_vect,- )- self.play(- growth,- FadeIn(equation_rect),- MoveToTarget(equation),- self.d_vect_magnitude_factor_tracker.set_value, 1,- )-- def show_trajectory(self):- state = self.state- dot = self.state_dot-- state.pendulum.clear_updaters(recursive=False)- self.tie_dot_position_to_state(dot, state)- state.pendulum.start_swinging()-- trajectory = self.get_evolving_trajectory(dot)- trajectory.set_stroke(WHITE, 3)-- self.add(trajectory, dot)- self.wait(25)-- #- def get_vector_symbol(self, tex1, tex2):- t2c = {- "{\\theta}": BLUE,- "{\\dot\\theta}": YELLOW,- "{\\omega}": YELLOW,- "{\\ddot\\theta}": RED,- }- return get_vector_symbol(- tex1, tex2,- element_to_mobject_config={- "tex_to_color_map": t2c,- }- ).scale(0.9)-- def vector_field_func(self, point):- x, y = self.plane.point_to_coords(point)- mu, g, L = [- self.big_pendulum_config.get(key)- for key in ["damping", "gravity", "length"]- ]- return pendulum_vector_field_func(- x * RIGHT + y * UP,- mu=mu, g=g, L=L- )-- def ask_about_change(self):- state = self.state-- dot = self.get_state_dot(state)- d_vect = Vector(0.75 * RIGHT, color=WHITE)- d_vect.shift(dot.get_center())- q_mark = always_redraw(- lambda: TexMobject("?").move_to(- d_vect.get_end() + 0.4 * rotate_vector(- d_vect.get_vector(), 90 * DEGREES,- ),- )- )-- self.play(TransformFromCopy(state[1], dot))- self.tie_state_to_dot_position(state, dot)- self.play(- GrowArrow(d_vect),- FadeInFromDown(q_mark)- )- for x in range(4):- angle = 90 * DEGREES- self.play(- Rotate(- d_vect, angle,- about_point=d_vect.get_start(),- )- )- self.play(- dot.shift,- 0.3 * d_vect.get_vector(),- rate_func=there_and_back,- )---class ShowPendulumPhaseFlow(IntroduceVectorField):- CONFIG = {- "coordinate_plane_config": {- "x_axis_config": {- "unit_size": 0.8,- },- "x_max": 9,- "x_min": -9,- },- "flow_time": 20,- }-- def construct(self):- self.initialize_plane()- self.initialize_vector_field()- plane = self.plane- field = self.vector_field- self.add(plane, field)-- stream_lines = StreamLines(- field.func,- delta_x=0.3,- delta_y=0.3,- )- animated_stream_lines = AnimatedStreamLines(- stream_lines,- line_anim_class=ShowPassingFlashWithThinningStrokeWidth,- )-- self.add(animated_stream_lines)- self.wait(self.flow_time)---class ShowHighVelocityCase(ShowPendulumPhaseFlow, MovingCameraScene):- CONFIG = {- "coordinate_plane_config": {- "x_max": 15,- "x_min": -15,- },- "vector_field_config": {- "x_max": 15,- },- "big_pendulum_config": {- "max_velocity_vector_length_to_length_ratio": 1,- },- "run_time": 25,- "initial_theta": 0,- "initial_theta_dot": 4,- "frame_shift_vect": TAU * RIGHT,- }-- def setup(self):- MovingCameraScene.setup(self)-- def construct(self):- self.initialize_plane_and_field()- self.add_flexible_state()- self.show_high_vector()- self.show_trajectory()-- def initialize_plane_and_field(self):- self.initialize_plane()- self.add(self.plane)- self.initialize_vector_field()- self.add(self.vector_field)-- def add_flexible_state(self):- super().add_flexible_state()- state = self.state- plane = self.plane-- state.to_edge(DOWN, buff=SMALL_BUFF),- start_point = plane.coords_to_point(- self.initial_theta,- self.initial_theta_dot,- )- dot = self.get_state_controlling_dot(state)- dot.move_to(start_point)- state.update()-- self.dot = dot- self.start_point = start_point-- def show_high_vector(self):- field = self.vector_field- top_vectors = VGroup(*filter(- lambda a: np.all(a.get_center() > [-10, 1.5, -10]),- field- )).copy()- top_vectors.set_stroke(PINK, 3)- top_vectors.sort(lambda p: p[0])-- self.play(- ShowCreationThenFadeOut(- top_vectors,- run_time=2,- lag_ratio=0.01,- )- )-- def show_trajectory(self):- state = self.state- frame = self.camera_frame- dot = self.dot- start_point = self.start_point-- traj = self.get_trajectory(start_point, self.run_time)-- self.add(traj, dot)- anims = [- ShowCreation(- traj,- rate_func=linear,- ),- UpdateFromFunc(- dot, lambda d: d.move_to(traj.points[-1])- ),- ]- if get_norm(self.frame_shift_vect) > 0:- anims += [- ApplyMethod(- frame.shift, self.frame_shift_vect,- rate_func=squish_rate_func(- smooth, 0, 0.3,- )- ),- MaintainPositionRelativeTo(state.rect, frame),- ]- self.play(*anims, run_time=total_time)-- def get_trajectory(self, start_point, time, dt=0.1, added_steps=100):- field = self.vector_field- traj = VMobject()- traj.start_new_path(start_point)- for x in range(int(time / dt)):- last_point = traj.points[-1]- for y in range(added_steps):- dp_dt = field.func(last_point)- last_point += dp_dt * dt / added_steps- traj.add_smooth_curve_to(last_point)- traj.make_smooth()- traj.set_stroke(WHITE, 2)- return traj---class TweakMuInFormula(Scene):- def construct(self):- self.add(FullScreenFadeRectangle(- opacity=0.75,- ))-- ode = get_ode()- ode.to_edge(DOWN, buff=LARGE_BUFF)- mu = ode.get_part_by_tex("\\mu")- lil_rect = SurroundingRectangle(mu, buff=0.5 * SMALL_BUFF)- lil_rect.stretch(1.2, 1, about_edge=DOWN)- lil_rect.set_stroke(PINK, 2)-- interval = UnitInterval()- interval.add_numbers(- *np.arange(0, 1.2, 0.2)- )- interval.next_to(ode, UP, LARGE_BUFF)- big_rect_seed = SurroundingRectangle(interval, buff=MED_SMALL_BUFF)- big_rect_seed.stretch(1.5, 1, about_edge=DOWN)- big_rect_seed.stretch(1.2, 0)- big_rect = VGroup(*[- DashedLine(v1, v2)- for v1, v2 in adjacent_pairs(big_rect_seed.get_vertices())- ])- big_rect.set_stroke(PINK, 2)-- arrow = Arrow(- lil_rect.get_top(),- big_rect_seed.point_from_proportion(0.65),- buff=SMALL_BUFF,- )- arrow.match_color(lil_rect)-- mu_tracker = ValueTracker(0.1)- get_mu = mu_tracker.get_value-- triangle = Triangle(- start_angle=-90 * DEGREES,- stroke_width=0,- fill_opacity=1,- fill_color=WHITE,- )- triangle.set_height(0.2)- triangle.add_updater(lambda t: t.next_to(- interval.number_to_point(get_mu()),- UP, buff=0,- ))-- equation = VGroup(- TexMobject("\\mu = "),- DecimalNumber(),- )- equation.add_updater(- lambda e: e.arrange(RIGHT).next_to(- triangle, UP, SMALL_BUFF,- ).shift(0.4 * RIGHT)- )- equation[-1].add_updater(- lambda d: d.set_value(get_mu()).shift(0.05 * UL)- )-- self.add(ode)- self.play(ShowCreation(lil_rect))- self.play(- GrowFromPoint(interval, mu.get_center()),- GrowFromPoint(triangle, mu.get_center()),- GrowFromPoint(equation, mu.get_center()),- TransformFromCopy(lil_rect, big_rect),- ShowCreation(arrow)- )- self.wait()- self.play(mu_tracker.set_value, 0.9, run_time=5)- self.wait()---class TweakMuInVectorField(ShowPendulumPhaseFlow):- def construct(self):- self.initialize_plane()- plane = self.plane- self.add(plane)-- mu_tracker = ValueTracker(0.1)- get_mu = mu_tracker.get_value-- def vector_field_func(p):- x, y = plane.point_to_coords(p)- mu = get_mu()- g = self.big_pendulum_config.get("gravity")- L = self.big_pendulum_config.get("length")- return pendulum_vector_field_func(- x * RIGHT + y * UP,- mu=mu, g=g, L=L- )-- def get_vector_field():- return VectorField(- vector_field_func,- **self.vector_field_config,- )-- field = always_redraw(get_vector_field)- self.add(field)-- self.play(- mu_tracker.set_value, 0.9,- run_time=5,- )- field.suspend_updating()-- stream_lines = StreamLines(- field.func,- delta_x=0.3,- delta_y=0.3,- )- animated_stream_lines = AnimatedStreamLines(- stream_lines,- line_anim_class=ShowPassingFlashWithThinningStrokeWidth,- )- self.add(animated_stream_lines)- self.wait(self.flow_time)---class HighAmplitudePendulum(ShowHighVelocityCase):- CONFIG = {- "big_pendulum_config": {- "damping": 0.02,- },- "initial_theta": 175 * DEGREES,- "initial_theta_dot": 0,- "frame_shift_vect": 0 * RIGHT,- }-- def construct(self):- self.initialize_plane_and_field()- self.add_flexible_state()- self.show_trajectory()---class SpectrumOfStartingStates(ShowHighVelocityCase):- CONFIG = {- "run_time": 15,- }-- def construct(self):- self.initialize_plane_and_field()- self.vector_field.set_opacity(0.5)- self.show_many_trajectories()-- def show_many_trajectories(self):- plane = self.plane-- delta_x = 0.5- delta_y = 0.5- n = 20-- start_points = [- plane.coords_to_point(x, y)- for x in np.linspace(PI - delta_x, PI + delta_x, n)- for y in np.linspace(-delta_y, delta_y, n)- ]- start_points.sort(- key=lambda p: np.dot(p, UL)- )- time = self.run_time-- # Count points- dots = VGroup(*[- Dot(sp, radius=0.025)- for sp in start_points- ])- dots.set_color_by_gradient(PINK, BLUE, YELLOW)- words = TextMobject(- "Spectrum of\\\\", "initial conditions"- )- words.set_stroke(BLACK, 5, background=True)- words.next_to(dots, UP)-- self.play(- # ShowIncreasingSubsets(dots, run_time=2),- LaggedStartMap(- FadeInFromLarge, dots,- lambda m: (m, 10),- run_time=2- ),- FadeInFromDown(words),- )- self.wait()-- trajs = VGroup()- for sp in start_points:- trajs.add(- self.get_trajectory(- sp, time,- added_steps=10,- )- )- for traj, dot in zip(trajs, dots):- traj.set_stroke(dot.get_color(), 1)-- def update_dots(ds):- for d, t in zip(ds, trajs):- d.move_to(t.points[-1])- return ds- dots.add_updater(update_dots)-- self.add(dots, trajs, words)- self.play(- ShowCreation(- trajs,- lag_ratio=0,- ),- rate_func=linear,- run_time=time,- )- self.wait()---class AskAboutStability(ShowHighVelocityCase):- CONFIG = {- "initial_theta": 60 * DEGREES,- "initial_theta_dot": 1,- }-- def construct(self):- self.initialize_plane_and_field()- self.add_flexible_state()- self.show_fixed_points()- self.label_fixed_points()- self.ask_about_stability()- self.show_nudges()-- def show_fixed_points(self):- state1 = self.state- plane = self.plane- dot1 = self.dot-- state2 = self.get_flexible_state_picture()- state2.to_corner(DR, buff=SMALL_BUFF)- dot2 = self.get_state_controlling_dot(state2)- dot2.set_color(BLUE)-- fp1 = plane.coords_to_point(0, 0)- fp2 = plane.coords_to_point(PI, 0)-- self.play(- dot1.move_to, fp1,- run_time=3,- )- self.wait()- self.play(FadeIn(state2))- self.play(- dot2.move_to, fp2,- path_arc=-30 * DEGREES,- run_time=2,- )- self.wait()-- self.state1 = state1- self.state2 = state2- self.dot1 = dot1- self.dot2 = dot2-- def label_fixed_points(self):- dots = VGroup(self.dot1, self.dot2)-- label = TextMobject("Fixed points")- label.scale(1.5)- label.set_stroke(BLACK, 5, background=True)- label.next_to(dots, UP, buff=2)- label.shift(SMALL_BUFF * DOWN)-- arrows = VGroup(*[- Arrow(- label.get_bottom(), dot.get_center(),- color=dot.get_color(),- )- for dot in dots- ])-- self.play(- self.vector_field.set_opacity, 0.5,- FadeInFromDown(label)- )- self.play(ShowCreation(arrows))- self.wait(2)-- self.to_fade = VGroup(label, arrows)-- def ask_about_stability(self):- question = TextMobject("Stable?")- question.scale(2)- question.shift(FRAME_WIDTH * RIGHT / 4)- question.to_edge(UP)- question.set_stroke(BLACK, 5, background=True)-- self.play(Write(question))- self.play(FadeOut(self.to_fade))-- def show_nudges(self):- dots = VGroup(self.dot1, self.dot2)- time = 20-- self.play(*[- ApplyMethod(- dot.shift, 0.1 * UL,- rate_func=rush_from,- )- for dot in dots- ])-- trajs = VGroup()- for dot in dots:- traj = self.get_trajectory(- dot.get_center(),- time,- )- traj.set_stroke(dot.get_color(), 2)- trajs.add(traj)-- def update_dots(ds):- for t, d in zip(trajs, ds):- d.move_to(t.points[-1])- dots.add_updater(update_dots)- self.add(trajs, dots)- self.play(- ShowCreation(trajs, lag_ratio=0),- rate_func=linear,- run_time=time- )- self.wait()---class LovePhaseSpace(ShowHighVelocityCase):- CONFIG = {- "vector_field_config": {- "max_magnitude": 4,- # "delta_x": 2,- # "delta_y": 2,- },- "a": 0.5,- "b": 0.3,- "mu": 0.2,- }-- def construct(self):- self.setup_plane()- self.add_equations()- self.show_vector_field()- self.show_example_trajectories()- self.add_resistance_term()- self.show_new_trajectories()-- def setup_plane(self):- plane = self.plane = NumberPlane()- plane.add_coordinates()- self.add(plane)-- h1, h2 = hearts = VGroup(*[- get_heart_var(i)- for i in (1, 2)- ])- hearts.scale(0.5)- hearts.set_stroke(BLACK, 5, background=True)-- h1.next_to(plane.x_axis.get_right(), UL, SMALL_BUFF)- h2.next_to(plane.y_axis.get_top(), DR, SMALL_BUFF)- for h in hearts:- h.shift_onto_screen(buff=MED_SMALL_BUFF)- plane.add(hearts)-- self.axis_hearts = hearts-- def add_equations(self):- equations = VGroup(- get_love_equation1(),- get_love_equation2(),- )- equations.scale(0.5)- equations.arrange(- DOWN,- aligned_edge=LEFT,- buff=MED_LARGE_BUFF- )- equations.to_corner(UL)- equations.add_background_rectangle_to_submobjects()- # for eq in equations:- # eq.add_background_rectangle_to_submobjects()-- self.add(equations)- self.equations = equations-- def show_vector_field(self):- field = VectorField(- lambda p: np.array([- self.a * p[1], -self.b * p[0], 0- ]),- **self.vector_field_config- )- field.sort(get_norm)- x_range = np.arange(-7, 7.5, 0.5)- y_range = np.arange(-4, 4.5, 0.5)- x_axis_arrows = VGroup(*[- field.get_vector([x, 0, 0])- for x in x_range- ])- y_axis_arrows = VGroup(*[- field.get_vector([0, y, 0])- for y in y_range- ])- axis_arrows = VGroup(*x_axis_arrows, *y_axis_arrows)-- axis_arrows.save_state()- for arrow in axis_arrows:- real_len = get_norm(field.func(arrow.get_start()))- arrow.scale(- 0.5 * real_len / arrow.get_length(),- about_point=arrow.get_start()- )-- self.play(- LaggedStartMap(GrowArrow, x_axis_arrows),- )- self.play(- LaggedStartMap(GrowArrow, y_axis_arrows),- )- self.wait()- self.add(field, self.equations, self.axis_hearts)- self.play(- axis_arrows.restore,- # axis_arrows.fade, 1,- ShowCreation(field),- run_time=3- )- self.remove(axis_arrows)- self.wait()-- self.field = self.vector_field = field-- def show_example_trajectories(self):- n_points = 20- total_time = 30-- start_points = self.start_points = [- 2.5 * np.random.random() * rotate_vector(- RIGHT,- TAU * np.random.random()- )- for x in range(n_points)- ]- dots = VGroup(*[Dot(sp) for sp in start_points])- dots.set_color_by_gradient(BLUE, WHITE)-- words = TextMobject("Possible initial\\\\", "conditions")- words.scale(1.5)- words.add_background_rectangle_to_submobjects()- words.set_stroke(BLACK, 5, background=True)- words.shift(FRAME_WIDTH * RIGHT / 4)- words.to_edge(UP)- self.possibility_words = words-- self.play(- LaggedStartMap(- FadeInFromLarge, dots,- lambda m: (m, 5)- ),- FadeInFromDown(words)- )-- trajs = VGroup(*[- self.get_trajectory(- sp, total_time,- added_steps=10,- )- for sp in start_points- ])- trajs.set_color_by_gradient(BLUE, WHITE)-- dots.trajs = trajs-- def update_dots(ds):- for d, t in zip(ds, ds.trajs):- d.move_to(t.points[-1])- dots.add_updater(update_dots)-- self.add(trajs, dots)- self.play(- ShowCreation(- trajs,- lag_ratio=0,- run_time=10,- rate_func=linear,- )- )-- self.trajs = trajs- self.dots = dots-- def add_resistance_term(self):- added_term = VGroup(- TexMobject("-\\mu"),- get_heart_var(2).scale(0.5),- )- added_term.arrange(RIGHT, buff=SMALL_BUFF)- equation2 = self.equations[1]- equation2.generate_target()- br, deriv, eq, neg_b, h1 = equation2.target- added_term.next_to(eq, RIGHT, SMALL_BUFF)- added_term.align_to(h1, DOWN)- VGroup(neg_b, h1).next_to(- added_term, RIGHT, SMALL_BUFF,- aligned_edge=DOWN,- )- br.stretch(1.2, 0, about_edge=LEFT)-- brace = Brace(added_term, DOWN, buff=SMALL_BUFF)- words = brace.get_text(- "``Resistance'' term"- )- words.set_stroke(BLACK, 5, background=True)- words.add_background_rectangle()-- self.add(equation2, added_term)- self.play(- MoveToTarget(equation2),- FadeInFromDown(added_term),- GrowFromCenter(brace),- Write(words),- )- self.play(ShowCreationThenFadeAround(added_term))-- equation2.add(added_term, brace, words)-- def show_new_trajectories(self):- dots = self.dots- trajs = self.trajs- field = self.field-- new_field = VectorField(- lambda p: np.array([- self.a * p[1],- -self.mu * p[1] - self.b * p[0],- 0- ]),- **self.vector_field_config- )- new_field.sort(get_norm)-- field.generate_target()- for vect in field.target:- vect.become(new_field.get_vector(vect.get_start()))-- self.play(*map(- FadeOut,- [trajs, dots, self.possibility_words]- ))- self.play(MoveToTarget(field))- self.vector_field = new_field-- total_time = 30- new_trajs = VGroup(*[- self.get_trajectory(- sp, total_time,- added_steps=10,- )- for sp in self.start_points- ])- new_trajs.set_color_by_gradient(BLUE, WHITE)- dots.trajs = new_trajs-- self.add(new_trajs, dots)- self.play(- ShowCreation(- new_trajs,- lag_ratio=0,- run_time=10,- rate_func=linear,- ),- )- self.wait()---class TakeManyTinySteps(IntroduceVectorField):- CONFIG = {- "initial_theta": 60 * DEGREES,- "initial_theta_dot": 0,- "initial_theta_tex": "\\pi / 3",- "initial_theta_dot_tex": "0",- }-- def construct(self):- self.initialize_plane_and_field()- self.take_many_time_steps()-- def initialize_plane_and_field(self):- self.initialize_plane()- self.initialize_vector_field()- field = self.vector_field- field.set_opacity(0.35)- self.add(self.plane, field)-- def take_many_time_steps(self):- self.setup_trackers()- delta_t_tracker = self.delta_t_tracker- get_delta_t = delta_t_tracker.get_value- time_tracker = self.time_tracker- get_t = time_tracker.get_value-- traj = always_redraw(- lambda: self.get_time_step_trajectory(- get_delta_t(),- get_t(),- self.initial_theta,- self.initial_theta_dot,- )- )- vectors = always_redraw(- lambda: self.get_path_vectors(- get_delta_t(),- get_t(),- self.initial_theta,- self.initial_theta_dot,- )- )-- # Labels- labels, init_labels = self.get_labels(get_t, get_delta_t)- t_label, dt_label = labels-- theta_t_label = TexMobject("\\theta(t)...\\text{ish}")- theta_t_label.scale(0.75)- theta_t_label.add_updater(lambda m: m.next_to(- vectors[-1].get_end(),- vectors[-1].get_vector(),- SMALL_BUFF,- ))-- self.add(traj, vectors, init_labels, labels)- time_tracker.set_value(0)- target_time = 10- self.play(- VFadeIn(theta_t_label),- ApplyMethod(- time_tracker.set_value, target_time,- run_time=5,- rate_func=linear,- )- )- self.wait()- t_label[-1].clear_updaters()- self.remove(theta_t_label)- target_delta_t = 0.01- self.play(- delta_t_tracker.set_value, target_delta_t,- run_time=7,- )- self.wait()- traj.clear_updaters()- vectors.clear_updaters()-- # Show steps- count_tracker = ValueTracker(0)- count = Integer()- count.scale(1.5)- count.to_edge(LEFT)- count.shift(UP + MED_SMALL_BUFF * UR)- count.add_updater(lambda c: c.set_value(- count_tracker.get_value()- ))- count_label = TextMobject("steps")- count_label.scale(1.5)- count_label.add_updater(- lambda m: m.next_to(- count[-1], RIGHT,- submobject_to_align=m[0][0],- aligned_edge=DOWN- )- )-- scaled_vectors = vectors.copy()- scaled_vectors.clear_updaters()- for vector in scaled_vectors:- vector.scale(- 1 / vector.get_length(),- about_point=vector.get_start()- )- vector.set_color(YELLOW)-- def update_scaled_vectors(group):- group.set_opacity(0)- group[min(- int(count.get_value()),- len(group) - 1,- )].set_opacity(1)-- scaled_vectors.add_updater(update_scaled_vectors)-- self.add(count, count_label, scaled_vectors)- self.play(- ApplyMethod(- count_tracker.set_value,- int(target_time / target_delta_t),- rate_func=linear,- ),- run_time=5,- )- self.play(FadeOut(scaled_vectors))- self.wait()-- def setup_trackers(self):- self.delta_t_tracker = ValueTracker(0.5)- self.time_tracker = ValueTracker(10)-- def get_labels(self, get_t, get_delta_t):- t_label, dt_label = labels = VGroup(*[- VGroup(- TexMobject("{} = ".format(s)),- DecimalNumber(0)- ).arrange(RIGHT, aligned_edge=DOWN)- for s in ("t", "{\\Delta t}")- ])-- dt_label[-1].add_updater(- lambda d: d.set_value(get_delta_t())- )- t_label[-1].add_updater(- lambda d: d.set_value(- int(np.ceil(get_t() / get_delta_t())) * get_delta_t()- )- )-- init_labels = VGroup(- TexMobject(- "\\theta_0", "=", self.initial_theta_tex,- tex_to_color_map={"\\theta": BLUE},- ),- TexMobject(- "{\\dot\\theta}_0 =", self.initial_theta_dot_tex,- tex_to_color_map={"{\\dot\\theta}": YELLOW},- ),- )- for group in labels, init_labels:- for label in group:- label.scale(1.25)- label.add_background_rectangle()- group.arrange(DOWN)- group.shift(FRAME_WIDTH * RIGHT / 4)- labels.to_edge(UP)- init_labels.shift(2 * DOWN)-- return labels, init_labels-- #- def get_time_step_points(self, delta_t, total_time, theta_0, theta_dot_0):- plane = self.plane- field = self.vector_field- curr_point = plane.coords_to_point(- theta_0,- theta_dot_0,- )- points = [curr_point]- t = 0- while t < total_time:- new_point = curr_point + field.func(curr_point) * delta_t- points.append(new_point)- curr_point = new_point- t += delta_t- return points-- def get_time_step_trajectory(self, delta_t, total_time, theta_0, theta_dot_0):- traj = VMobject()- traj.set_points_as_corners(- self.get_time_step_points(- delta_t, total_time,- theta_0, theta_dot_0,- )- )- traj.set_stroke(WHITE, 2)- return traj-- def get_path_vectors(self, delta_t, total_time, theta_0, theta_dot_0):- corners = self.get_time_step_points(- delta_t, total_time,- theta_0, theta_dot_0,- )- result = VGroup()- for a1, a2 in zip(corners, corners[1:]):- vector = Arrow(- a1, a2, buff=0,- )- vector.match_style(- self.vector_field.get_vector(a1)- )- result.add(vector)- return result---class SetupToTakingManyTinySteps(TakeManyTinySteps):- CONFIG = {- }-- def construct(self):- self.initialize_plane_and_field()- self.show_step()-- def show_step(self):- self.setup_trackers()- get_delta_t = self.delta_t_tracker.get_value- get_t = self.time_tracker.get_value-- labels, init_labels = self.get_labels(get_t, get_delta_t)- t_label, dt_label = labels-- dt_part = dt_label[1][0][:-1].copy()-- init_labels_rect = SurroundingRectangle(init_labels)- init_labels_rect.set_color(PINK)-- field = self.vector_field- point = self.plane.coords_to_point(- self.initial_theta,- self.initial_theta_dot,- )- dot = Dot(point, color=init_labels_rect.get_color())-- vector_value = field.func(point)- vector = field.get_vector(point)- vector.scale(- get_norm(vector_value) / vector.get_length(),- about_point=vector.get_start()- )- scaled_vector = vector.copy()- scaled_vector.scale(- get_delta_t(),- about_point=scaled_vector.get_start()- )-- v_label = TexMobject("\\vec{\\textbf{v}}")- v_label.set_stroke(BLACK, 5, background=True)- v_label.next_to(vector, LEFT, SMALL_BUFF)-- real_field = field.copy()- for v in real_field:- p = v.get_start()- v.scale(- get_norm(field.func(p)) / v.get_length(),- about_point=p- )-- self.add(init_labels)- self.play(ShowCreation(init_labels_rect))- self.play(ReplacementTransform(- init_labels_rect,- dot,- ))- self.wait()- self.add(vector, dot)- self.play(- ShowCreation(vector),- FadeInFrom(v_label, RIGHT),- )- self.play(FadeInFromDown(dt_label))- self.wait()-- #- v_label.generate_target()- dt_part.generate_target()- dt_part.target.next_to(scaled_vector, LEFT, SMALL_BUFF)- v_label.target.next_to(dt_part.target, LEFT, SMALL_BUFF)- rect = BackgroundRectangle(- VGroup(v_label.target, dt_part.target)- )-- self.add(rect, v_label, dt_part)- self.play(- ReplacementTransform(vector, scaled_vector),- FadeIn(rect),- MoveToTarget(v_label),- MoveToTarget(dt_part),- )- self.add(scaled_vector, dot)- self.wait()-- self.play(- LaggedStart(*[- Transform(- sm1, sm2,- rate_func=there_and_back_with_pause,- )- for sm1, sm2 in zip(field, real_field)- ], lag_ratio=0.001, run_time=3)- )- self.wait()---class ShowClutterPrevention(SetupToTakingManyTinySteps):- def construct(self):- self.initialize_plane_and_field()-- # Copied from above scene- field = self.vector_field- real_field = field.copy()- for v in real_field:- p = v.get_start()- v.scale(- get_norm(field.func(p)) / v.get_length(),- about_point=p- )-- self.play(- LaggedStart(*[- Transform(- sm1, sm2,- rate_func=there_and_back_with_pause,- )- for sm1, sm2 in zip(field, real_field)- ], lag_ratio=0.001, run_time=3)- )- self.wait()---class ManyStepsFromDifferentStartingPoints(TakeManyTinySteps):- CONFIG = {- "initial_thetas": np.linspace(0.1, PI - 0.1, 10),- "initial_theta_dot": 0,- }-- def construct(self):- self.initialize_plane_and_field()- self.take_many_time_steps()-- def take_many_time_steps(self):- delta_t_tracker = ValueTracker(0.2)- get_delta_t = delta_t_tracker.get_value-- time_tracker = ValueTracker(10)- get_t = time_tracker.get_value- # traj = always_redraw(- # lambda: VGroup(*[- # self.get_time_step_trajectory(- # get_delta_t(),- # get_t(),- # theta,- # self.initial_theta_dot,- # )- # for theta in self.initial_thetas- # ])- # )- vectors = always_redraw(- lambda: VGroup(*[- self.get_path_vectors(- get_delta_t(),- get_t(),- theta,- self.initial_theta_dot,- )- for theta in self.initial_thetas- ])- )-- self.add(vectors)- time_tracker.set_value(0)- self.play(- time_tracker.set_value, 5,- run_time=5,- rate_func=linear,- )---class Thumbnail(IntroduceVectorField):- CONFIG = {- "vector_field_config": {- "delta_x": 0.5,- "delta_y": 0.5,- "max_magnitude": 5,- "length_func": lambda norm: 0.5 * sigmoid(norm),- }- }-- def construct(self):- self.initialize_plane()- self.plane.axes.set_stroke(width=0.5)- self.initialize_vector_field()-- field = self.vector_field- field.set_stroke(width=5)- for vector in field:- vector.set_stroke(width=3)- vector.tip.set_stroke(width=0)- vector.tip.scale(1.5, about_point=vector.get_last_point())- vector.set_opacity(1)-- title = TextMobject("Differential\\\\", "equations")- title.space_out_submobjects(0.8)- # title.scale(3)- title.set_width(FRAME_WIDTH - 3)- # title.to_edge(UP)- # title[1].to_edge(DOWN)-- subtitle = TextMobject("Studying the unsolvable")- subtitle.set_width(FRAME_WIDTH - 1)- subtitle.set_color(WHITE)- subtitle.to_edge(DOWN, buff=1)-- # title.center()- title.to_edge(UP, buff=1)- title.add(subtitle)- # title.set_stroke(BLACK, 15, background=True)- # title.add_background_rectangle_to_submobjects(opacity=0.5)- title.set_stroke(BLACK, 15, background=True)- subtitle.set_stroke(RED, 2, background=True)- # for part in title:- # part[0].set_fill(opacity=0.25)- # part[0].set_stroke(width=0)- black_parts = VGroup()- for mob in title.family_members_with_points():- for sp in mob.get_subpaths():- new_mob = VMobject()- new_mob.set_points(sp)- new_mob.set_fill(BLACK, 0.25)- new_mob.set_stroke(width=0)- black_parts.add(new_mob)-- for vect in field:- for mob in title.family_members_with_points():- for p in [vect.get_start(), vect.get_end()]:- x, y = p[:2]- x0, y0 = mob.get_corner(DL)[:2]- x1, y1 = mob.get_corner(UR)[:2]- if x0 < x < x1 and y0 < y < y1:- vect.set_opacity(0.25)- vect.tip.set_stroke(width=0)-- self.add(self.plane)- self.add(field)- self.add(black_parts)- self.add(title)diff --git a/active_projects/ode/part1/pi_scenes.py b/active_projects/ode/part1/pi_scenes.pydeleted file mode 100644index ab0d60faf..000000000--- a/active_projects/ode/part1/pi_scenes.py+++ /dev/null@@ -1,515 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.shared_constructs import *---class SomeOfYouWatching(TeacherStudentsScene):- CONFIG = {- "camera_config": {- "background_color": DARKER_GREY,- }- }-- def construct(self):- screen = self.screen- screen.scale(1.25, about_edge=UL)- screen.set_fill(BLACK, 1)- self.add(screen)-- self.teacher.change("raise_right_hand")- for student in self.students:- student.change("pondering", screen)-- self.student_says(- "Well...yeah",- target_mode="tease"- )- self.wait(3)---class FormulasAreLies(PiCreatureScene):- def construct(self):- you = self.pi_creature- t2c = {- "{L}": BLUE,- "{g}": YELLOW,- "\\theta_0": WHITE,- "\\sqrt{\\,": WHITE,- }- kwargs = {"tex_to_color_map": t2c}- period_eq = TexMobject(- "\\text{Period} = 2\\pi \\sqrt{\\,{L} / {g}}",- **kwargs- )- theta_eq = TexMobject(- "\\theta(t) = \\theta_0 \\cos\\left("- "\\sqrt{\\,{L} / {g}} \\cdot t"- "\\right)",- **kwargs- )- equations = VGroup(theta_eq, period_eq)- equations.arrange(DOWN, buff=LARGE_BUFF)-- for eq in period_eq, theta_eq:- i = eq.index_of_part_by_tex("\\sqrt")- eq.sqrt_part = eq[i:i + 4]-- theta0 = theta_eq.get_part_by_tex("\\theta_0")- theta0_words = TextMobject("Starting angle")- theta0_words.next_to(theta0, UL)- theta0_words.shift(UP + 0.5 * RIGHT)- arrow = Arrow(- theta0_words.get_bottom(),- theta0,- color=WHITE,- tip_length=0.25,- )-- bubble = SpeechBubble()- bubble.pin_to(you)- bubble.write("Lies!")- bubble.content.scale(2)- bubble.resize_to_content()-- self.add(period_eq)- you.change("pondering", period_eq)- self.wait()- theta_eq.remove(*theta_eq.sqrt_part)- self.play(- TransformFromCopy(- period_eq.sqrt_part,- theta_eq.sqrt_part,- ),- FadeIn(theta_eq)- )- theta_eq.add(*theta_eq.sqrt_part)- self.play(- FadeInFrom(theta0_words, LEFT),- GrowArrow(arrow),- )- self.wait()- self.play(you.change, "confused")- self.wait()- self.play(- you.change, "angry",- ShowCreation(bubble),- FadeInFromPoint(bubble.content, you.mouth),- equations.to_edge, LEFT,- FadeOut(arrow),- FadeOut(theta0_words),- )- self.wait()-- def create_pi_creature(self):- return You().flip().to_corner(DR)---# class TourOfDifferentialEquations(Scene):-# def construct(self):-# pass---class SoWhatIsThetaThen(TeacherStudentsScene):- def construct(self):- ode = get_ode()- ode.to_corner(UL)- self.add(ode)-- self.student_says(- "Okay, but then\\\\"- "what \\emph{is} $\\theta(t)$?"- )- self.wait()- self.play(self.teacher.change, "happy")- self.wait(2)- self.teacher_says(- "First, you must appreciate\\\\"- "a deep truth...",- added_anims=[self.get_student_changes(- *3 * ["confused"]- )]- )- self.wait(4)---class ProveTeacherWrong(TeacherStudentsScene):- def construct(self):- tex_config = {- "tex_to_color_map": {- "{\\theta}": BLUE,- "{\\dot\\theta}": YELLOW,- "{\\ddot\\theta}": RED,- }- }- func = TexMobject(- "{\\theta}(t)", "=",- "\\theta_0", "\\cos(\\sqrt{g / L} \\cdot t)",- **tex_config,- )- d_func = TexMobject(- "{\\dot\\theta}(t)", "=",- "-\\left(\\sqrt{g / L}\\right)",- "\\theta_0", "\\sin(\\sqrt{g / L} \\cdot t)",- **tex_config,- )- dd_func = TexMobject(- "{\\ddot\\theta}(t)", "=",- "-\\left(g / L\\right)",- "\\theta_0", "\\cos(\\sqrt{g / L} \\cdot t)",- **tex_config,- )- # ode = TexMobject(- # "\\ddot {\\theta}({t})", "=",- # "-\\mu \\dot {\\theta}({t})",- # "-{g \\over L} \\sin\\big({\\theta}({t})\\big)",- # **tex_config,- # )- ode = get_ode()- arrows = [TexMobject("\\Downarrow") for x in range(2)]-- VGroup(func, d_func, dd_func, ode, *arrows).scale(0.7)-- teacher = self.teacher- you = self.students[2]-- self.student_thinks(ode)- you.add_updater(lambda m: m.look_at(func))- self.teacher_holds_up(func)- self.wait()-- group = VGroup(arrows[0], d_func, arrows[1], dd_func)- group.arrange(DOWN)- group.move_to(func, DOWN)-- arrow = Arrow(- group.get_corner(UL),- ode.get_top(),- path_arc=PI / 2,- )- q_marks = VGroup(*[- TexMobject("?").scale(1.5).next_to(- arrow.point_from_proportion(a),- UP- )- for a in np.linspace(0.2, 0.8, 5)- ])- cycle_animation(VFadeInThenOut(- q_marks,- lag_ratio=0.2,- run_time=4,- rate_func=squish_rate_func(smooth, 0, 0.5)- ))-- self.play(- func.next_to, group, UP,- LaggedStartMap(- FadeInFrom, group,- lambda m: (m, UP)- ),- teacher.change, "guilty",- you.change, "sassy",- )-- rect = SurroundingRectangle(- VGroup(group, func)- )- dashed_rect = DashedVMobject(rect, num_dashes=75)- animated_rect = AnimatedBoundary(dashed_rect, cycle_rate=1)-- self.wait()- self.add(animated_rect, q_marks)- self.play(- ShowCreation(arrow),- # FadeInFromDown(q_mark),- self.get_student_changes("confused", "confused")- )- self.wait(4)- self.change_student_modes(- *3 * ["pondering"],- self.teacher.change, "maybe"- )- self.wait(8)---class PhysicistPhaseSpace(PiCreatureScene):- def construct(self):- physy = self.pi_creature- name = TextMobject("Physicist")- name.scale(1.5)- name.to_corner(DL, buff=MED_SMALL_BUFF)- physy.next_to(name, UP, SMALL_BUFF)- VGroup(name, physy).shift_onto_screen()-- axes = Axes(- x_min=-1,- x_max=10,- y_min=-1,- y_max=7,- )- axes.set_height(6)- axes.next_to(physy, RIGHT)- axes.to_edge(UP)- axes.set_stroke(width=1)- x_label = TextMobject("Position")- x_label.next_to(axes.x_axis.get_right(), UP)- y_label = TextMobject("Momentum")- y_label.next_to(axes.y_axis.get_top(), RIGHT)-- title = TextMobject("Phase space")- title.scale(1.5)- title.set_color(YELLOW)- title.move_to(axes)-- self.add(name, physy)-- self.play(- physy.change, "angry",- Write(axes),- FadeInFromDown(title)- )- self.wait(2)- self.play(- GrowFromPoint(x_label, physy.get_corner(UR)),- physy.change, "raise_right_hand",- axes.x_axis.get_right()- )- self.play(- GrowFromPoint(y_label, physy.get_corner(UR)),- physy.look_at, axes.y_axis.get_top(),- )- self.wait(3)-- def create_pi_creature(self):- return PiCreature(color=GREY).to_corner(DL)---class AskAboutActuallySolving(TeacherStudentsScene):- def construct(self):- ode = get_ode()- ode.to_corner(UL)- self.add(ode)- morty = self.teacher-- self.student_says(- "Yeah yeah, but how do\\\\"- "you actually \\emph{solve} it?",- student_index=1,- target_mode="sassy",- added_anims=[morty.change, "thinking"],- )- self.change_student_modes(- "confused", "sassy", "confused",- look_at_arg=ode,- )- self.wait()- self.teacher_says(- "What do you mean\\\\ by ``solve''?",- target_mode="speaking",- added_anims=[self.get_student_changes(- *3 * ["erm"]- )]- )- self.play(self.students[1].change, "angry")- self.wait(3)---class HungerForExactness(TeacherStudentsScene):- def construct(self):- students = self.students- you = students[2]- teacher = self.teacher-- ode = get_ode()- ode.to_corner(UL)- left_part = ode[:5]- friction_part = ode[5:11]- self.add(ode)-- proposed_solution = TexMobject(- "\\theta_0\\cos((\\sqrt{g/L})t)e^{-\\mu t}"- )- proposed_solution.next_to(- you.get_corner(UL), UP, buff=0.7- )- proposed_solution_rect = SurroundingRectangle(- proposed_solution, buff=MED_SMALL_BUFF,- )- proposed_solution_rect.set_color(BLUE)- proposed_solution_rect.round_corners()-- solution_p1 = TexMobject(- """- \\theta(t) = 2\\text{am}\\left(- \\frac{\\sqrt{2g + Lc_1} (t + c_2)}{2\\sqrt{L}},- \\frac{4g}{2g + Lc_1}- \\right)- """,- )- solution_p1.to_corner(UL)- solution_p2 = TexMobject(- "c_1, c_2 = \\text{Constants depending on initial conditions}"- )- solution_p2.set_color(LIGHT_GREY)- solution_p2.scale(0.75)- solution_p3 = TexMobject(- """- \\text{am}(u, k) =- \\int_0^u \\text{dn}(v, k)\\,dv- """- )- solution_p3.name = TextMobject(- "(Jacobi amplitude function)"- )- solution_p4 = TexMobject(- """- \\text{dn}(u, k) =- \\sqrt{1 - k^2 \\sin^2(\\phi)}- """- )- solution_p4.name = TextMobject(- "(Jacobi elliptic function)"- )- solution_p5 = TextMobject("Where $\\phi$ satisfies")- solution_p6 = TexMobject(- """- u = \\int_0^\\phi \\frac{dt}{\\sqrt{1 - k^2 \\sin^2(t)}}- """- )-- solution = VGroup(- solution_p1,- solution_p2,- solution_p3,- solution_p4,- solution_p5,- solution_p6,- )- solution.arrange(DOWN)- solution.scale(0.7)- solution.to_corner(UL, buff=MED_SMALL_BUFF)- solution.set_stroke(width=0, background=True)-- solution.remove(solution_p2)- solution_p1.add(solution_p2)- solution.remove(solution_p5)- solution_p6.add(solution_p5)-- for part in [solution_p3, solution_p4]:- part.name.scale(0.7 * 0.7)- part.name.set_color(LIGHT_GREY)- part.name.next_to(part, RIGHT)- part.add(part.name)-- self.student_says(- "Right, but like,\\\\"- "what \\emph{is} $\\theta(t)$?",- target_mode="sassy",- added_anims=[teacher.change, "guilty"],- )- self.wait()- self.play(- FadeInFromDown(proposed_solution),- RemovePiCreatureBubble(- you,- target_mode="raise_left_hand",- look_at_arg=proposed_solution,- ),- teacher.change, "pondering",- students[0].change, "pondering",- students[1].change, "hesitant",- )- self.play(ShowCreation(proposed_solution_rect))- self.play(- proposed_solution.shift, 3 * RIGHT,- proposed_solution_rect.shift, 3 * RIGHT,- you.change, "raise_right_hand", teacher.eyes,- )- self.wait(3)-- self.play(- FadeOut(proposed_solution),- FadeOut(proposed_solution_rect),- ode.move_to, self.hold_up_spot, DOWN,- ode.shift, LEFT,- teacher.change, "raise_right_hand",- self.get_student_changes(*3 * ["pondering"])- )- self.wait()- ode.save_state()- self.play(- left_part.move_to, friction_part, RIGHT,- left_part.match_y, left_part,- friction_part.to_corner, DR,- friction_part.fade, 0.5,- )- self.wait()-- modes = ["erm", "sad", "sad", "horrified"]- for part, mode in zip(solution, modes):- self.play(- FadeInFrom(part, UP),- self.get_student_changes(- *3 * [mode],- look_at_arg=part,- )- )- self.wait()- self.wait(3)- self.change_student_modes("tired", "sad", "concerned_musician")- self.wait(4)- self.look_at(solution)- self.wait(5)- self.play(- FadeOutAndShift(solution, 2 * LEFT),- Restore(ode),- self.get_student_changes(- "sick", "angry", "tired",- )- )- self.wait(3)-- mystery = TexMobject(- "\\theta(t) = ???",- tex_to_color_map={"\\theta": BLUE},- )- mystery.scale(2)- mystery.to_edge(UP)- mystery.set_stroke(width=0, background=True)- mystery_boundary = AnimatedBoundary(- mystery, stroke_width=1- )-- self.play(- FadeInFromDown(mystery),- self.teacher.change, "pondering"- )- self.add(mystery_boundary, mystery)- self.change_all_student_modes("sad")- self.look_at(mystery)- self.wait(5)-- # Define- self.student_says(- "Let $\\text{P}(\\mu, g, L; t)$ be a\\\\"- "function satisfying this ODE.",- student_index=0,- target_mode="speaking",- added_anims=[- FadeOut(mystery),- FadeOut(mystery_boundary),- ode.to_corner, UR- ]- )- self.change_student_modes(- "hooray", "sassy", "sassy",- look_at_arg=students[0].eyes.get_corner(UR),- )- self.wait(2)---class ItGetsWorse(TeacherStudentsScene):- def construct(self):- self.teacher_says("It gets\\\\worse")- self.change_student_modes(- "hesitant", "pleading", "erm"- )- self.wait(5)diff --git a/active_projects/ode/part1/shared_constructs.py b/active_projects/ode/part1/shared_constructs.pydeleted file mode 100644index 1dcfddf64..000000000--- a/active_projects/ode/part1/shared_constructs.py+++ /dev/null@@ -1,118 +0,0 @@-from manimlib.imports import *---Lg_formula_config = {- "tex_to_color_map": {- "\\theta_0": WHITE,- "{L}": BLUE,- "{g}": YELLOW,- },-}---class You(PiCreature):- CONFIG = {- "color": BLUE_C,- }---def get_ode():- tex_config = {- "tex_to_color_map": {- "{\\theta}": BLUE,- "{\\dot\\theta}": RED,- "{\\ddot\\theta}": YELLOW,- "{t}": WHITE,- "{\\mu}": WHITE,- }- }- ode = TexMobject(- "{\\ddot\\theta}({t})", "=",- "-{\\mu} {\\dot\\theta}({t})",- "-{g \\over L} \\sin\\big({\\theta}({t})\\big)",- **tex_config,- )- return ode---def get_period_formula():- return TexMobject(- "2\\pi", "\\sqrt{\\,", "L", "/", "g", "}",- tex_to_color_map={- "L": BLUE,- "g": YELLOW,- }- )---def pendulum_vector_field_func(point, mu=0.1, g=9.8, L=3):- theta, omega = point[:2]- return np.array([- omega,- -np.sqrt(g / L) * np.sin(theta) - mu * omega,- 0,- ])---def get_vector_symbol(*texs, **kwargs):- config = {- "include_background_rectangle": True,- "bracket_h_buff": SMALL_BUFF,- "bracket_v_buff": SMALL_BUFF,- "element_alignment_corner": ORIGIN,- }- config.update(kwargs)- array = [[tex] for tex in texs]- return Matrix(array, **config)---def get_heart_var(index):- heart = SuitSymbol("hearts")- if index == 1:- heart.set_color(BLUE_C)- elif index == 2:- heart.set_color(GREEN)- heart.set_height(0.7)- index = Integer(index)- index.move_to(heart.get_corner(DR))- heart.add(index)- return heart---def get_heart_var_deriv(index):- heart = get_heart_var(index)- filler_tex = "T"- deriv = TexMobject("{d", filler_tex, "\\over", "dt}")- deriv.scale(2)- filler = deriv.get_part_by_tex(filler_tex)- heart.match_height(filler)- heart.move_to(filler)- heart.scale(1.5, about_edge=UL)- deriv.remove(filler)- deriv.add(heart)- deriv.heart = heart- return deriv---def get_love_equation1():- equation = VGroup(- get_heart_var_deriv(1),- TexMobject("=").scale(2),- TexMobject("a").scale(2),- get_heart_var(2)- )- equation.arrange(RIGHT)- equation[-1].shift(SMALL_BUFF * DL)- return equation---def get_love_equation2():- equation = VGroup(- get_heart_var_deriv(2),- TexMobject("=").scale(2),- TexMobject("-b").scale(2),- get_heart_var(1),- )- equation.arrange(RIGHT)- equation[-1].shift(SMALL_BUFF * DL)- return equationdiff --git a/active_projects/ode/part1/staging.py b/active_projects/ode/part1/staging.pydeleted file mode 100644index 823bd1fea..000000000--- a/active_projects/ode/part1/staging.py+++ /dev/null@@ -1,3028 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.shared_constructs import *-from active_projects.ode.part1.pendulum import Pendulum-from active_projects.ode.part1.pendulum import ThetaVsTAxes-from active_projects.ode.part1.phase_space import IntroduceVectorField-from old_projects.div_curl import PhaseSpaceOfPopulationModel-from old_projects.div_curl import ShowTwoPopulations---# Scenes---class VectorFieldTest(Scene):- def construct(self):- plane = NumberPlane(- # axis_config={"unit_size": 2}- )- mu_tracker = ValueTracker(1)- field = VectorField(- lambda p: pendulum_vector_field_func(- plane.point_to_coords(p),- mu=mu_tracker.get_value()- ),- delta_x=0.5,- delta_y=0.5,- max_magnitude=6,- opacity=0.5,- # length_func=lambda norm: norm,- )- field.set_opacity(1)-- self.add(plane, field)- return-- stream_lines = StreamLines(- field.func,- delta_x=0.5,- delta_y=0.5,- )- animated_stream_lines = AnimatedStreamLines(- stream_lines,- line_anim_class=ShowPassingFlashWithThinningStrokeWidth,- )-- self.add(plane, field, animated_stream_lines)- self.wait(10)---class ShowRect(Scene):- CONFIG = {- "height": 1,- "width": 3,- }-- def construct(self):- rect = Rectangle(- height=self.height,- width=self.width,- )- rect.set_stroke(YELLOW)- self.play(ShowCreation(rect))- self.play(FadeOut(rect))---class ShowSquare(ShowRect):- CONFIG = {- "height": 3,- "width": 3,- }---class WhenChangeIsEasier(Scene):- def construct(self):- pass---class AirResistanceBrace(Scene):- def construct(self):- brace = Brace(Line(ORIGIN, RIGHT), DOWN)- word = TextMobject("Air resistance")- word.next_to(brace, DOWN)- self.play(GrowFromCenter(brace), FadeInFrom(word, UP))- self.wait()---class PeriodFormula(Scene):- def construct(self):- formula = get_period_formula()- formula.scale(2)- q_mark = TexMobject("?")- q_mark.scale(3)- q_mark.next_to(formula, RIGHT)- self.add(formula, q_mark)---class TourOfDifferentialEquations(MovingCameraScene):- CONFIG = {- "screen_rect_style": {- "stroke_width": 2,- "stroke_color": WHITE,- "fill_opacity": 1,- "fill_color": BLACK,- },- "camera_config": {"background_color": DARKER_GREY},- "zoomed_thumbnail_index": 0,- }-- def construct(self):- self.add_title()- self.show_thumbnails()- self.zoom_in_to_one_thumbnail()- # self.show_words()-- def add_title(self):- title = TextMobject(- "A Tourist's Guide \\\\to Differential\\\\Equations"- )- title.scale(1.5)- title.to_corner(UR)- self.add(title)-- def show_thumbnails(self):- thumbnails = self.thumbnails = Group(- Group(ScreenRectangle(**self.screen_rect_style)),- Group(ScreenRectangle(**self.screen_rect_style)),- Group(ScreenRectangle(**self.screen_rect_style)),- Group(ScreenRectangle(**self.screen_rect_style)),- Group(ScreenRectangle(**self.screen_rect_style)),- )- n = len(thumbnails)- thumbnails.set_height(1.5)-- line = self.line = CubicBezier([- [-5, 3, 0],- [3, 3, 0],- [-3, -3, 0],- [5, -3, 0],- ])- line.shift(MED_SMALL_BUFF * LEFT)- for thumbnail, a in zip(thumbnails, np.linspace(0, 1, n)):- thumbnail.move_to(line.point_from_proportion(a))- dots = TexMobject("\\dots")- dots.next_to(thumbnails[-1], RIGHT)-- self.add_phase_space_preview(thumbnails[0])- self.add_heat_preview(thumbnails[1])- self.add_fourier_series(thumbnails[2])- self.add_matrix_exponent(thumbnails[3])- self.add_laplace_symbol(thumbnails[4])-- self.play(- ShowCreation(- line,- rate_func=lambda t: np.clip(t * (n + 1) / n, 0, 1)- ),- LaggedStart(*[- GrowFromCenter(- thumbnail,- rate_func=squish_rate_func(- smooth,- 0, 0.7,- )- )- for thumbnail in thumbnails- ], lag_ratio=1),- run_time=5- )- self.play(Write(dots))- self.wait()-- self.thumbnails = thumbnails-- def zoom_in_to_one_thumbnail(self):- self.play(- self.camera_frame.replace,- self.thumbnails[self.zoomed_thumbnail_index],- run_time=3,- )- self.wait()-- def show_words(self):- words = VGroup(- TextMobject("Generalize"),- TextMobject("Put in context"),- TextMobject("Modify"),- )- # words.arrange(DOWN, aligned_edge=LEFT, buff=LARGE_BUFF)- words.scale(1.5)- words.to_corner(UR)- words.add_to_back(VectorizedPoint(words.get_center()))- words.add(VectorizedPoint(words.get_center()))-- diffEq = TextMobject("Differential\\\\equations")- diffEq.scale(1.5)- diffEq.to_corner(DL, buff=LARGE_BUFF)-- for word1, word2 in zip(words, words[1:]):- self.play(- FadeInFromDown(word2),- FadeOutAndShift(word1, UP),- )- self.wait()- self.play(- ReplacementTransform(- VGroup(self.thumbnails).copy().fade(1),- diffEq,- lag_ratio=0.01,- )- )- self.wait()-- #- def add_phase_space_preview(self, thumbnail):- image = ImageMobject("LovePhaseSpace")- image.replace(thumbnail)- thumbnail.add(image)-- def add_heat_preview(self, thumbnail):- image = ImageMobject("HeatSurfaceExample")- image.replace(thumbnail)- thumbnail.add(image)-- def add_matrix_exponent(self, thumbnail):- matrix = IntegerMatrix(- [[3, 1], [4, 1]],- v_buff=MED_LARGE_BUFF,- h_buff=MED_LARGE_BUFF,- bracket_h_buff=SMALL_BUFF,- bracket_v_buff=SMALL_BUFF,- )- e = TexMobject("e")- t = TexMobject("t")- t.scale(1.5)- t.next_to(matrix, RIGHT, SMALL_BUFF)- e.scale(2)- e.move_to(matrix.get_corner(DL), UR)- group = VGroup(e, matrix, t)- group.set_height(0.7 * thumbnail.get_height())- randy = Randolph(mode="confused", height=0.75)- randy.next_to(group, LEFT, aligned_edge=DOWN)- randy.look_at(matrix)- group.add(randy)- group.move_to(thumbnail)- thumbnail.add(group)-- def add_fourier_series(self, thumbnail):- colors = [BLUE, GREEN, YELLOW, RED, RED_E, PINK]-- waves = VGroup(*[- self.get_square_wave_approx(N, color)- for N, color in enumerate(colors)- ])- waves.set_stroke(width=1.5)- waves.replace(thumbnail, stretch=True)- waves.scale(0.8)- waves.move_to(thumbnail)- thumbnail.add(waves)-- def get_square_wave_approx(self, N, color):- return FunctionGraph(- lambda x: sum([- (1 / n) * np.sin(n * PI * x)- for n in range(1, 2 * N + 3, 2)- ]),- x_min=0,- x_max=2,- color=color- )-- def add_laplace_symbol(self, thumbnail):- mob = TexMobject(- "\\mathcal{L}\\left\\{f(t)\\right\\}"- )- mob.set_width(0.8 * thumbnail.get_width())- mob.move_to(thumbnail)- thumbnail.add(mob)---class HeatEquationPreview(ExternallyAnimatedScene):- pass---class ShowHorizontalDashedLine(Scene):- def construct(self):- line = DashedLine(LEFT_SIDE, RIGHT_SIDE)- self.play(ShowCreation(line))- self.wait()---class RabbitFoxPopulations(ShowTwoPopulations):- pass---class RabbitFoxEquation(PhaseSpaceOfPopulationModel):- def construct(self):- equations = self.get_equations()- self.add(equations)---class ShowGravityAcceleration(Scene):- CONFIG = {- "flash": True,- "add_ball_copies": True,- }-- def construct(self):- self.add_gravity_field()- self.add_title()- self.pulse_gravity_down()- self.show_g_value()- self.show_trajectory()- self.combine_v_vects()- self.show_g_symbol()-- def add_gravity_field(self):- gravity_field = self.gravity_field = VectorField(- lambda p: DOWN,- # delta_x=2,- # delta_y=2,- )- gravity_field.set_opacity(0.5)- gravity_field.sort_submobjects(- lambda p: -p[1],- )- self.add(gravity_field)-- def add_title(self):- title = self.title = TextMobject("Gravitational acceleration")- title.scale(1.5)- title.to_edge(UP)- title.add_background_rectangle(- buff=0.05,- opacity=1,- )- self.play(FadeInFromDown(title))-- def pulse_gravity_down(self):- field = self.gravity_field- self.play(LaggedStart(*[- ApplyFunction(- lambda v: v.set_opacity(1).scale(1.2),- vector,- rate_func=there_and_back,- )- for vector in field- ]), run_time=2, lag_ratio=0.001)- self.add(self.title)-- def show_g_value(self):- title = self.title- g_eq = self.g_eq = TexMobject(- "-9.8", "{\\text{m/s}", "\\over", "\\text{s}}",- **Lg_formula_config- )- g_eq.add_background_rectangle_to_submobjects()- g_eq.scale(2)- g_eq.center()- num, ms, per, s = g_eq-- self.add(num)- self.wait(0.75)- self.play(- FadeInFrom(ms, 0.25 * DOWN, run_time=0.5)- )- self.wait(0.25)- self.play(LaggedStart(- GrowFromPoint(per, per.get_left()),- FadeInFrom(s, 0.5 * UP),- lag_ratio=0.7,- run_time=0.75- ))- self.wait()- self.play(- g_eq.scale, 0.5,- g_eq.next_to, title, DOWN,- )-- def show_trajectory(self):- total_time = 6-- ball = self.get_ball()-- p0 = 3 * DOWN + 5 * LEFT- v0 = 2.8 * UP + 1.5 * RIGHT- g = 0.9 * DOWN- graph = ParametricFunction(- lambda t: p0 + v0 * t + 0.5 * g * t**2,- t_min=0,- t_max=total_time,- )- # graph.center().to_edge(DOWN)- dashed_graph = DashedVMobject(graph, num_dashes=60)- dashed_graph.set_stroke(WHITE, 1)-- ball.move_to(graph.get_start())- randy.add_updater(- lambda m, dt: m.rotate(dt).move_to(ball)- )- times = np.arange(0, total_time + 1)-- velocity_graph = ParametricFunction(- lambda t: v0 + g * t,- t_min=0, t_max=total_time,- )- v_point = VectorizedPoint()- v_point.move_to(velocity_graph.get_start())-- def get_v_vect():- result = Vector(- v_point.get_location(),- color=RED,- tip_length=0.2,- )- result.scale(0.5, about_point=result.get_start())- result.shift(ball.get_center())- result.set_stroke(width=2, family=False)- return result- v_vect = always_redraw(get_v_vect)- self.add(v_vect)-- flash_rect = FullScreenRectangle(- stroke_width=0,- fill_color=WHITE,- fill_opacity=0.2,- )- flash = FadeOut(- flash_rect,- rate_func=squish_rate_func(smooth, 0, 0.1)- )-- time_label = TextMobject("Time = ")- time_label.shift(MED_SMALL_BUFF * LEFT)- time_tracker = ValueTracker(0)- time = DecimalNumber(0)- time.next_to(time_label, RIGHT)- time.add_updater(lambda d, dt: d.set_value(- time_tracker.get_value()- ))- time_group = VGroup(time_label, time)- time_group.center().to_edge(DOWN)- self.add(time_group)-- ball_copies = VGroup()- v_vect_copies = VGroup()- self.add(dashed_graph, ball)- for t1, t2 in zip(times, times[1:]):- v_vect_copy = v_vect.copy()- v_vect_copies.add(v_vect_copy)- ball_copy = ball.copy()- ball_copy.clear_updaters()- ball_copies.add(ball_copy)-- if self.add_ball_copies:- self.add(v_vect_copy)- self.add(ball_copy, ball)-- dashed_graph.save_state()- kw = {- "rate_func": lambda alpha: interpolate(- t1 / total_time,- t2 / total_time,- alpha- )- }- anims = [- ShowCreation(dashed_graph, **kw),- MoveAlongPath(ball, graph, **kw),- MoveAlongPath(v_point, velocity_graph, **kw),- ApplyMethod(- time_tracker.increment_value, 1,- rate_func=linear- ),- ]- if self.flash:- anims.append(flash)- self.play(*anims, run_time=1)- dashed_graph.restore()- randy.clear_updaters()- self.play(FadeOut(time_group))- self.wait()-- self.v_vects = v_vect_copies-- def combine_v_vects(self):- v_vects = self.v_vects.copy()- v_vects.generate_target()- new_center = 2 * DOWN + 2 * LEFT- for vect in v_vects.target:- vect.scale(1.5)- vect.set_stroke(width=2)- vect.shift(new_center - vect.get_start())-- self.play(MoveToTarget(v_vects))-- delta_vects = VGroup(*[- Arrow(- v1.get_end(),- v2.get_end(),- buff=0.01,- color=YELLOW,- ).set_opacity(0.5)- for v1, v2 in zip(v_vects, v_vects[1:])- ])- brace = Brace(Line(ORIGIN, UP), RIGHT)- braces = VGroup(*[- brace.copy().match_height(arrow).next_to(- arrow, RIGHT, buff=0.2 * SMALL_BUFF- )- for arrow in delta_vects- ])- amounts = VGroup(*[- TextMobject("9.8 m/s").scale(0.5).next_to(- brace, RIGHT, SMALL_BUFF- )- for brace in braces- ])-- self.play(- FadeOut(self.gravity_field),- FadeIn(delta_vects, lag_ratio=0.1),- )- self.play(- LaggedStartMap(GrowFromCenter, braces),- LaggedStartMap(FadeInFrom, amounts, lambda m: (m, LEFT)),- )- self.wait()-- def show_g_symbol(self):- g = TexMobject("g")- brace = Brace(self.g_eq[0][2:], UP, buff=SMALL_BUFF)- g.scale(1.5)- g.next_to(brace, UP)- g.set_color(YELLOW)- self.play(- FadeOut(self.title),- GrowFromCenter(brace),- FadeInFrom(g, UP),- )- self.wait()-- #- def get_ball(self):- ball = Circle(- stroke_width=1,- stroke_color=WHITE,- fill_color=GREY,- fill_opacity=1,- sheen_factor=1,- sheen_direction=UL,- radius=0.25,- )- randy = Randolph(mode="pondering")- randy.eyes.set_stroke(BLACK, 0.5)- randy.match_height(ball)- randy.scale(0.75)- randy.move_to(ball)- ball.add(randy)- return ball---class ShowSimpleTrajectory(ShowGravityAcceleration):- CONFIG = {- "flash": False,- }-- def construct(self):- self.show_trajectory()---class SimpleProjectileEquation(ShowGravityAcceleration):- CONFIG = {- "y0": 0,- "g": 9.8,- "axes_config": {- "x_min": 0,- "x_max": 6,- "x_axis_config": {- "unit_size": 1.5,- "tip_width": 0.15,- },- "y_min": -30,- "y_max": 35,- "y_axis_config": {- "unit_size": 0.1,- "numbers_with_elongated_ticks": range(- -30, 35, 10- ),- "tick_size": 0.05,- "numbers_to_show": range(-30, 31, 10),- "tip_width": 0.15,- },- "center_point": 2 * LEFT,- }- }-- def construct(self):- self.add_axes()- self.setup_trajectory()-- self.show_trajectory()- self.show_equation()- self.solve_for_velocity()- self.solve_for_position()-- def add_axes(self):- axes = self.axes = Axes(**self.axes_config)- axes.set_stroke(width=2)- axes.add_coordinates()-- t_label = TexMobject("t")- t_label.next_to(axes.x_axis.get_right(), UL)- axes.add(t_label)-- self.add(axes)-- def setup_trajectory(self):- axes = self.axes- total_time = self.total_time = 5-- ball = self.get_ball()- offset_vector = 3 * LEFT-- g = self.g- y0 = self.y0- v0 = 0.5 * g * total_time-- t_tracker = ValueTracker(0)- get_t = t_tracker.get_value-- # Position- def y_func(t):- return -0.5 * g * t**2 + v0 * t + y0-- graph_template = axes.get_graph(y_func, x_max=total_time)- graph_template.set_stroke(width=2)- traj_template = graph_template.copy()- traj_template.stretch(0, 0)- traj_template.move_to(- axes.coords_to_point(0, 0), DOWN- )- traj_template.shift(offset_vector)- traj_template.set_stroke(width=0.5)-- graph = VMobject()- graph.set_stroke(BLUE, 2)- traj = VMobject()- traj.set_stroke(WHITE, 0.5)- graph.add_updater(lambda g: g.pointwise_become_partial(- graph_template, 0, get_t() / total_time- ))- traj.add_updater(lambda t: t.pointwise_become_partial(- traj_template, 0, get_t() / total_time- ))-- def get_ball_point():- return axes.coords_to_point(- 0, y_func(get_t())- ) + offset_vector-- f_always(ball.move_to, get_ball_point)-- h_line = always_redraw(lambda: DashedLine(- get_ball_point(),- axes.input_to_graph_point(get_t(), graph_template),- stroke_width=1,- ))-- y_label = TexMobject("y", "(t)")- y_label.set_color_by_tex("y", BLUE)- y_label.add_updater(- lambda m: m.next_to(- graph.get_last_point(),- UR, SMALL_BUFF,- )- )-- # Velocity- def v_func(t):- return -g * t + v0-- def get_v_vect():- return Vector(- axes.y_axis.unit_size * v_func(get_t()) * UP,- color=RED,- )- v_vect = always_redraw(- lambda: get_v_vect().shift(get_ball_point())- )- v_brace = always_redraw(lambda: Brace(v_vect, LEFT))- dy_dt_label = TexMobject(- "{d", "y", "\\over dt}", "(t)",- )- dy_dt_label.scale(0.8)- dy_dt_label.set_color_by_tex("y", BLUE)- y_dot_label = TexMobject("\\dot y", "(t)")- y_dot_label.set_color_by_tex("\\dot y", RED)- for label in dy_dt_label, y_dot_label:- label.add_updater(lambda m: m.next_to(- v_brace, LEFT, SMALL_BUFF,- ))-- graphed_v_vect = always_redraw(- lambda: get_v_vect().shift(- axes.coords_to_point(get_t(), 0)- )- )- v_graph_template = axes.get_graph(- v_func, x_max=total_time,- )- v_graph = VMobject()- v_graph.set_stroke(RED, 2)- v_graph.add_updater(lambda m: m.pointwise_become_partial(- v_graph_template,- 0, get_t() / total_time,- ))-- # Acceleration- def get_a_vect():- return Vector(- axes.y_axis.unit_size * g * DOWN- )-- a_vect = get_a_vect()- a_vect.add_updater(lambda a: a.move_to(- get_ball_point(), UP,- ))- a_brace = Brace(a_vect, RIGHT)- always(a_brace.next_to, a_vect, RIGHT, SMALL_BUFF)- d2y_dt2_label = TexMobject(- "d^2", "{y}", "\\over dt}", "(t)"- )- d2y_dt2_label.scale(0.8)- d2y_dt2_label.set_color_by_tex(- "y", BLUE,- )- y_ddot_label = TexMobject("\\ddot y", "(t)")- y_ddot_label.set_color_by_tex("\\ddot y", YELLOW)- for label in d2y_dt2_label, y_ddot_label:- label.add_updater(lambda m: m.next_to(- a_brace, RIGHT, SMALL_BUFF- ))- a_graph = axes.get_graph(- lambda t: -g, x_max=total_time,- )- a_graph.set_stroke(YELLOW, 2)-- graphed_a_vect = get_a_vect()- graphed_a_vect.add_updater(lambda a: a.move_to(- axes.coords_to_point(get_t(), 0), UP,- ))-- self.set_variables_as_attrs(- t_tracker,- graph,- y_label,- traj,- h_line,- v_vect,- v_brace,- dy_dt_label,- y_dot_label,- ball,- graphed_v_vect,- v_graph,- a_vect,- a_brace,- d2y_dt2_label,- y_ddot_label,- a_graph,- graphed_a_vect,- )-- def show_trajectory(self):- self.add(- self.h_line,- self.traj,- self.ball,- self.graph,- self.y_label,- )- self.play_trajectory()- self.wait()-- self.add(- self.v_vect,- self.v_brace,- self.dy_dt_label,- self.ball,- self.graphed_v_vect,- self.v_graph,- )- self.play_trajectory()- self.wait()-- self.add(- self.a_vect,- self.ball,- self.a_brace,- self.d2y_dt2_label,- self.a_graph,- self.graphed_a_vect,- )- self.play_trajectory()- self.wait()-- self.play(- ReplacementTransform(- self.dy_dt_label,- self.y_dot_label,- ),- ShowCreationThenFadeAround(- self.y_dot_label,- ),- )- self.play(- ReplacementTransform(- self.d2y_dt2_label,- self.y_ddot_label,- ),- ShowCreationThenFadeAround(- self.y_ddot_label,- ),- )-- def show_equation(self):- y_ddot = self.y_ddot_label- new_y_ddot = y_ddot.deepcopy()- new_y_ddot.clear_updaters()-- equation = VGroup(- new_y_ddot,- *TexMobject(- "=", "-g",- tex_to_color_map={"-g": YELLOW},- ),- )- new_y_ddot.next_to(equation[1], LEFT, SMALL_BUFF)- equation.move_to(self.axes)- equation.to_edge(UP)-- self.play(- TransformFromCopy(y_ddot, new_y_ddot),- Write(equation[1:]),- FadeOut(self.graph),- FadeOut(self.y_label),- FadeOut(self.h_line),- FadeOut(self.v_graph),- FadeOut(self.graphed_v_vect),- FadeOut(self.graphed_a_vect),- )-- self.equation = equation-- def solve_for_velocity(self):- axes = self.axes- equation = self.equation- v_graph = self.v_graph.deepcopy()- v_graph.clear_updaters()- v_start_point = v_graph.get_start()- origin = axes.coords_to_point(0, 0)- offset = v_start_point - origin- v_graph.shift(-offset)-- tex_question, answer1, answer2 = derivs = [- TexMobject(- "{d", "(", *term, ")", "\\over", "dt}", "(t)",- "=", "-g",- tex_to_color_map={- "-g": YELLOW,- "v_0": RED,- "?": RED,- }- )- for term in [- ("?", "?", "?", "?"),- ("-g", "t"),- ("-g", "t", "+", "v_0",),- ]- ]- for x in range(2):- answer1.submobjects.insert(- 4, VectorizedPoint(answer1[4].get_left())- )- for deriv in derivs:- deriv.next_to(equation, DOWN, MED_LARGE_BUFF)-- question = TextMobject(- "What function has slope $-g$?",- tex_to_color_map={"$-g$": YELLOW},- )- question.next_to(tex_question, DOWN)- question.set_stroke(BLACK, 5, background=True)- question.add_background_rectangle()-- v0_dot = Dot(v_start_point, color=PINK)- v0_label = TexMobject("v_0")- v0_label.set_color(RED)- v0_label.next_to(v0_dot, UR, buff=0)-- y_dot_equation = TexMobject(- "{\\dot y}", "(t)", "=",- "-g", "t", "+", "v_0",- tex_to_color_map={- "{\\dot y}": RED,- "-g": YELLOW,- "v_0": RED,- }- )- y_dot_equation.to_corner(UR)-- self.play(- FadeInFrom(tex_question, DOWN),- FadeInFrom(question, UP)- )- self.wait()- self.add(v_graph, question)- self.play(- ReplacementTransform(tex_question, answer1),- ShowCreation(v_graph),- )- self.wait()- self.play(- ReplacementTransform(answer1, answer2),- v_graph.shift, offset,- )- self.play(- FadeInFromLarge(v0_dot),- FadeInFromDown(v0_label),- )- self.wait()- self.play(- TransformFromCopy(- answer2[2:6], y_dot_equation[3:],- ),- Write(y_dot_equation[:3]),- equation.shift, LEFT,- )- self.play(- FadeOut(question),- FadeOut(answer2),- )-- self.remove(v_graph)- self.add(self.v_graph)- self.y_dot_equation = y_dot_equation-- def solve_for_position(self):- # Largely copied from above...not great- equation = self.equation- y_dot_equation = self.y_dot_equation- graph = self.graph-- all_terms = [- ("?", "?", "?", "?"),- ("-", "(1/2)", "g", "t^2", "+", "v_0", "t"),- ("-", "(1/2)", "g", "t^2", "+", "v_0", "t", "+", "y_0"),- ]- tex_question, answer1, answer2 = derivs = [- TexMobject(- "{d", "(", *term, ")", "\\over", "dt}", "(t)",- "=",- "-g", "t", "+", "v_0",- tex_to_color_map={- "g": YELLOW,- "v_0": RED,- "?": BLUE,- "y_0": BLUE,- }- )- for term in all_terms- ]- answer1.scale(0.8)- answer2.scale(0.8)- for deriv, terms in zip(derivs, all_terms):- for x in range(len(all_terms[-1]) - len(terms)):- n = 2 + len(terms)- deriv.submobjects.insert(- n, VectorizedPoint(deriv[n].get_left())- )- deriv.next_to(- VGroup(equation, y_dot_equation),- DOWN, MED_LARGE_BUFF + SMALL_BUFF- )- deriv.shift_onto_screen()- deriv.add_background_rectangle_to_submobjects()-- y_equation = TexMobject(- "y", "(t)", "=",- "-", "(1/2)", "g", "t^2",- "+", "v_0", "t",- "+", "y_0",- tex_to_color_map={- "y": BLUE,- "g": YELLOW,- "v_0": RED,- }- )- y_equation.next_to(- VGroup(equation, y_dot_equation),- DOWN, MED_LARGE_BUFF,- )-- self.play(- FadeInFrom(tex_question, DOWN),- )- self.wait()- self.add(graph, tex_question)- self.play(- ReplacementTransform(tex_question, answer1),- ShowCreation(graph),- )- self.add(graph, answer1)- self.wait()- self.play(ReplacementTransform(answer1, answer2))- self.add(graph, answer2)- g_updaters = graph.updaters- graph.clear_updaters()- self.play(- graph.shift, 2 * DOWN,- rate_func=there_and_back,- run_time=2,- )- graph.add_updater(g_updaters[0])- self.wait()- br = BackgroundRectangle(y_equation)- self.play(- FadeIn(br),- ReplacementTransform(- answer2[2:11],- y_equation[3:]- ),- FadeIn(y_equation[:3]),- FadeOut(answer2[:2]),- FadeOut(answer2[11:]),- )- self.play(ShowCreationThenFadeAround(y_equation))- self.play_trajectory()-- #- def play_trajectory(self, *added_anims, **kwargs):- self.t_tracker.set_value(0)- self.play(- ApplyMethod(- self.t_tracker.set_value, 5,- rate_func=linear,- run_time=self.total_time,- ),- *added_anims,- )- self.wait()---class SimpleProjectileEquationVGraphFreedom(SimpleProjectileEquation):- def construct(self):- self.add_axes()- self.setup_trajectory()- self.clear()- v_graph = self.v_graph- self.t_tracker.set_value(5)- v_graph.update()- v_graph.clear_updaters()- self.add(v_graph)- self.play(v_graph.shift, 5 * DOWN, run_time=2)- self.play(v_graph.shift, 5 * UP, run_time=2)---class UniversalGravityLawSymbols(Scene):- def construct(self):- x1_tex = "\\vec{\\textbf{x}}_1"- x2_tex = "\\vec{\\textbf{x}}_2"- a1_tex = "\\vec{\\textbf{a}}_1"- new_brown = interpolate_color(LIGHT_GREY, LIGHT_BROWN, 0.5)- law = TexMobject(- "F_1", "=", "m_1", a1_tex, "=",- "G", "m_1", "m_2",- "\\left({", x2_tex, "-", x1_tex, "\\over",- "||", x2_tex, "-", x1_tex, "||", "}\\right)",- "\\left({", "1", "\\over",- "||", x2_tex, "-", x1_tex, "||^2", "}\\right)",- tex_to_color_map={- x1_tex: BLUE_C,- "m_1": BLUE_C,- x2_tex: new_brown,- "m_2": new_brown,- a1_tex: YELLOW,- }- )- law.to_edge(UP)-- force = law[:4]- constants = law[4:8]- unit_vect = law[8:19]- inverse_square = law[19:]- parts = VGroup(- force, unit_vect, inverse_square- )-- words = VGroup(- TextMobject("Force on\\\\mass 1"),- TextMobject("Unit vector\\\\towards mass 2"),- TextMobject("Inverse square\\\\law"),- )-- self.add(law)-- braces = VGroup()- rects = VGroup()- for part, word in zip(parts, words):- brace = Brace(part, DOWN)- word.scale(0.8)- word.next_to(brace, DOWN)- rect = SurroundingRectangle(part)- rect.set_stroke(YELLOW, 1)- braces.add(brace)- rects.add(rect)-- self.play(- ShowCreationThenFadeOut(rects[0]),- GrowFromCenter(braces[0]),- FadeInFrom(words[0], UP)- )- self.wait()- self.play(- ShowCreationThenFadeOut(rects[1]),- GrowFromCenter(braces[1]),- FadeInFrom(words[1], UP)- )- self.wait()- self.play(- ShowCreationThenFadeOut(rects[2]),- TransformFromCopy(*braces[1:3]),- FadeInFrom(words[2], UP),- )- self.wait()-- # Position derivative- v1_tex = "\\vec{\\textbf{v}}_1"- kw = {- "tex_to_color_map": {- x1_tex: BLUE_C,- v1_tex: RED,- }- }- x_deriv = TexMobject(- "{d", x1_tex, "\\over", "dt}", "=", v1_tex, **kw- )- x_deriv.to_corner(UL)- v_deriv = TexMobject(- "{d", v1_tex, "\\over", "dt}", "=", **kw- )-- # Make way- law.generate_target()- lt = law.target- lt.to_edge(RIGHT)- lt[6].fade(1)- lt[:6].align_to(lt[6], RIGHT)- lt[:3].fade(1)- v_deriv.next_to(lt[3], LEFT)-- self.play(- FadeInFromDown(x_deriv),- MoveToTarget(law),- braces[1:].align_to, lt, RIGHT,- MaintainPositionRelativeTo(words[1:], braces[1:]),- FadeOut(words[0]),- FadeOut(braces[0]),- )- self.play(ShowCreationThenFadeAround(x_deriv))-- self.play(- TransformFromCopy(- x_deriv.get_part_by_tex(v1_tex),- v_deriv.get_part_by_tex(v1_tex),- ),- Write(VGroup(*filter(- lambda m: m is not v_deriv.get_part_by_tex(v1_tex),- v_deriv,- )))- )-- x_parts = law.get_parts_by_tex(x1_tex)- self.play(- TransformFromCopy(- x_deriv.get_parts_by_tex(x1_tex),- x_parts.copy(),- remover=True,- path_arc=30 * DEGREES,- )- )- self.play(- LaggedStartMap(- ShowCreationThenFadeAround,- x_parts- )- )- self.wait()---class ExampleTypicalODE(TeacherStudentsScene):- def construct(self):- examples = VGroup(- TexMobject(- "{\\dot x}(t) = k{x}(t)",- tex_to_color_map={- "{\\dot x}": BLUE,- "{x}": BLUE,- },- ),- get_ode(),- TexMobject(- "{\\partial T", "\\over", "\\partial t} = ",- "{\\partial^2 T", "\\over", "\\partial x^2}", "+",- "{\\partial^2 T", "\\over", "\\partial y^2}", "+",- "{\\partial^2 T", "\\over", "\\partial z^2}",- tex_to_color_map={- "T": RED,- }- ),- )- examples[1].get_parts_by_tex("theta").set_color(GREEN)- examples.arrange(DOWN, buff=MED_LARGE_BUFF)- examples.to_edge(UP)-- self.play(- FadeInFrom(examples[0], UP),- self.teacher.change, "raise_right_hand",- )- self.play(- FadeInFrom(examples[1], UP),- self.get_student_changes(- *3 * ["pondering"],- look_at_arg=examples,- ),- )- self.play(- FadeInFrom(examples[2], UP)- )- self.wait(5)---class ShowDerivativeVideo(Scene):- def construct(self):- title = TextMobject("Essence of", "Calculus")- title.scale(1.5)- title.to_edge(UP)-- title2 = TextMobject("Essence of", "Linear Algebra")- title2.scale(1.5)- title2.move_to(title, DOWN)-- rect = ScreenRectangle(height=6)- rect = rect.copy()- rect.set_style(- fill_opacity=1,- fill_color=BLACK,- stroke_width=0,- )- rect.next_to(title, DOWN)- animated_rect = AnimatedBoundary(rect)-- self.add(title, rect)- self.add(animated_rect)- self.wait(5)- self.play(ReplacementTransform(title, title2))- self.wait(10)---class SubtleAirCurrents(Scene):- def construct(self):- pass---class DefineODE(Scene):- CONFIG = {- "pendulum_config": {- "length": 2,- "top_point": 5 * RIGHT + 2 * UP,- "initial_theta": 150 * DEGREES,- "mu": 0.3,- },- "axes_config": {- "y_axis_config": {"unit_size": 0.75},- "y_max": PI,- "y_min": -PI,- "x_max": 10,- "x_axis_config": {- "numbers_to_show": range(2, 10, 2),- "unit_size": 1,- }- },- }-- def construct(self):- self.add_graph()- self.write_differential_equation()- self.dont_know_the_value()- self.show_value_slope_curvature()- self.write_ode()- self.show_second_order()- self.show_higher_order_examples()- self.show_changing_curvature_group()-- def add_graph(self):- pendulum = Pendulum(**self.pendulum_config)- axes = ThetaVsTAxes(**self.axes_config)-- axes.center()- axes.to_corner(DL)- graph = axes.get_live_drawn_graph(pendulum)-- pendulum.start_swinging()- self.add(axes, pendulum, graph)-- self.pendulum = pendulum- self.axes = axes- self.graph = graph-- def write_differential_equation(self):- de_word = TextMobject("Differential", "Equation")- de_word.to_edge(UP, buff=MED_SMALL_BUFF)-- equation = get_ode()- equation.next_to(de_word, DOWN)- thetas = equation.get_parts_by_tex("\\theta")-- lines = VGroup(*[- Line(v, 1.2 * v)- for v in compass_directions(25)- ])- lines.replace(equation, stretch=True)- lines.scale(1.5)- lines.set_stroke(YELLOW)- lines.shuffle()-- self.add(equation)- self.wait(5)- self.play(- ShowPassingFlashWithThinningStrokeWidth(- lines,- lag_ratio=0.002,- run_time=1.5,- time_width=0.9,- n_segments=5,- )- )- self.play(FadeInFromDown(de_word))- self.wait(2)- self.play(- LaggedStartMap(- ApplyMethod, thetas,- lambda m: (m.shift, 0.25 * DOWN),- rate_func=there_and_back,- )- )- self.wait()-- self.de_word = de_word- self.equation = equation-- def dont_know_the_value(self):- graph = self.graph- pendulum = self.pendulum-- q_marks = VGroup(*[- TexMobject("?").move_to(graph.point_from_proportion(a))- for a in np.linspace(0, 1, 20)- ])- q_marks.set_stroke(width=0, background=True)- self.play(- VFadeOut(graph),- FadeOut(pendulum),- LaggedStart(*[- UpdateFromAlphaFunc(- q_mark,- lambda m, a: m.set_height(0.5 * (1 + a)).set_fill(- opacity=there_and_back(a)- ),- )- for q_mark in q_marks- ], lag_ratio=0.01, run_time=2)- )- self.remove(q_marks)-- def show_value_slope_curvature(self):- axes = self.axes- p = self.pendulum- graph = axes.get_graph(- lambda t: p.initial_theta * np.cos(- np.sqrt(p.gravity / p.length) * t- ) * np.exp(-p.mu * t / 2)- )-- tex_config = {- "tex_to_color_map": {- "{\\theta}": BLUE,- "{\\dot\\theta}": RED,- "{\\ddot\\theta}": YELLOW,- },- "height": 0.5,- }- theta, d_theta, dd_theta = [- TexMobject(- "{" + s + "\\theta}(t)",- **tex_config- )- for s in ("", "\\dot", "\\ddot")- ]-- t_tracker = ValueTracker(2.5)- get_t = t_tracker.get_value-- def get_point(t):- return graph.point_from_proportion(t / axes.x_max)-- def get_dot():- return Dot(get_point(get_t())).scale(0.5)-- def get_v_line():- point = get_point(get_t())- x_point = axes.x_axis.number_to_point(- axes.x_axis.point_to_number(point)- )- return DashedLine(- x_point, point,- dash_length=0.025,- stroke_color=BLUE,- stroke_width=2,- )-- def get_tangent_line(curve, alpha):- line = Line(- ORIGIN, 1.5 * RIGHT,- color=RED,- stroke_width=1.5,- )- da = 0.0001- p0 = curve.point_from_proportion(alpha)- p1 = curve.point_from_proportion(alpha - da)- p2 = curve.point_from_proportion(alpha + da)- angle = angle_of_vector(p2 - p1)- line.rotate(angle)- line.move_to(p0)- return line-- def get_slope_line():- return get_tangent_line(- graph, get_t() / axes.x_max- )-- def get_curve():- curve = VMobject()- t = get_t()- curve.set_points_smoothly([- get_point(t + a)- for a in np.linspace(-0.5, 0.5, 11)- ])- curve.set_stroke(YELLOW, 1)- return curve-- v_line = always_redraw(get_v_line)- dot = always_redraw(get_dot)- slope_line = always_redraw(get_slope_line)- curve = always_redraw(get_curve)-- theta.next_to(v_line, RIGHT, SMALL_BUFF)- d_theta.next_to(slope_line.get_end(), UP, SMALL_BUFF)- dd_theta.next_to(curve.get_end(), RIGHT, SMALL_BUFF)- thetas = VGroup(theta, d_theta, dd_theta)-- words = VGroup(- TextMobject("= Height").set_color(BLUE),- TextMobject("= Slope").set_color(RED),- TextMobject("= ``Curvature''").set_color(YELLOW),- )- words.scale(0.75)- for word, sym in zip(words, thetas):- word.next_to(sym, RIGHT, buff=2 * SMALL_BUFF)- sym.word = word-- self.play(- ShowCreation(v_line),- FadeInFromPoint(dot, v_line.get_start()),- FadeInFrom(theta, DOWN),- FadeInFrom(theta.word, DOWN),- )- self.add(slope_line, dot)- self.play(- ShowCreation(slope_line),- FadeInFrom(d_theta, LEFT),- FadeInFrom(d_theta.word, LEFT),- )-- a_tracker = ValueTracker(0)- curve_copy = curve.copy()- changing_slope = always_redraw(- lambda: get_tangent_line(- curve_copy,- a_tracker.get_value(),- ).set_stroke(- opacity=there_and_back(a_tracker.get_value())- )- )- self.add(curve, dot)- self.play(- ShowCreation(curve),- FadeInFrom(dd_theta, LEFT),- FadeInFrom(dd_theta.word, LEFT),- )- self.add(changing_slope)- self.play(- a_tracker.set_value, 1,- run_time=3,- )- self.remove(changing_slope, a_tracker)-- self.t_tracker = t_tracker- self.curvature_group = VGroup(- v_line, slope_line, curve, dot- )- self.curvature_group_labels = VGroup(thetas, words)- self.fake_graph = graph-- def write_ode(self):- equation = self.equation- axes = self.axes- de_word = self.de_word-- ts = equation.get_parts_by_tex("{t}")- t_rects = VGroup(*map(SurroundingRectangle, ts)) # Rawr- x_axis = axes.x_axis- x_axis_line = Line(- x_axis.get_start(), x_axis.get_end(),- stroke_color=YELLOW,- stroke_width=5,- )-- ordinary = TextMobject("Ordinary")- de_word.generate_target()- group = VGroup(ordinary, de_word.target)- group.arrange(RIGHT)- group.to_edge(UP)- ordinary_underline = Line(LEFT, RIGHT)- ordinary_underline.replace(ordinary, dim_to_match=0)- ordinary_underline.next_to(ordinary, DOWN, SMALL_BUFF)- ordinary_underline.set_color(YELLOW)-- self.play(- ShowCreationThenFadeOut(- t_rects,- lag_ratio=0.8- ),- ShowCreationThenFadeOut(x_axis_line)- )- self.play(- MoveToTarget(de_word),- FadeInFrom(ordinary, RIGHT),- GrowFromCenter(ordinary_underline)- )- self.play(FadeOut(ordinary_underline))- self.wait()-- self.remove(ordinary, de_word)- ode_word = self.ode_word = VGroup(*ordinary, *de_word)- ode_initials = VGroup(*[word[0] for word in ode_word])- ode_initials.generate_target()- ode_initials.target.scale(1.2)- ode_initials.target.set_color(PINK)- ode_initials.target.arrange(- RIGHT, buff=0.5 * SMALL_BUFF, aligned_edge=DOWN- )- ode_initials.target.to_edge(UP, buff=MED_SMALL_BUFF)-- ode_remaining_letters = VGroup(*it.chain(*[- word[1:] for word in ode_word- ]))- ode_remaining_letters.generate_target()- for mob in ode_remaining_letters.target:- mob.shift(0.2 * UP)- mob.fade(1)-- self.play(- MoveToTarget(ode_initials),- MoveToTarget(ode_remaining_letters, lag_ratio=0.05),- )- self.wait()-- self.ode_initials = ode_initials-- def show_second_order(self):- so = TextMobject("Second order")- so.scale(1.4)- ode = self.ode_initials- ode.generate_target()- group = VGroup(so, ode.target)- group.arrange(RIGHT, aligned_edge=DOWN)- group.to_edge(UP, buff=MED_SMALL_BUFF)-- second_deriv = self.equation[:5]-- self.play(- Write(so),- MoveToTarget(ode),- )- self.wait()- self.play(FocusOn(second_deriv))- self.play(- Indicate(second_deriv, color=YELLOW),- )- self.wait()-- self.second_order_word = so-- def show_higher_order_examples(self):- main_example = self.get_main_example()- tex_config = {"tex_to_color_map": {"{x}": BLUE}}- example3 = VGroup(- TextMobject("Third order ODE"),- TexMobject(- "\\dddot {x}(t) + \\dot {x}(t)^2 = 0",- **tex_config,- )- )- example4 = VGroup(- TextMobject("Fourth order ODE"),- TexMobject(- "\\ddddot {x}(t) +",- "a\\dddot {x}(t) \\dot {x}(t) + ",- "b \\ddot {x}(t) {x}(t)",- "= 1",- **tex_config,- )- )- for example in [example3, example4]:- example[0].scale(1.2)- example.arrange(DOWN, buff=MED_LARGE_BUFF)- example.to_edge(UP, buff=MED_SMALL_BUFF)-- self.play(- FadeOut(main_example),- FadeIn(example3),- )- self.wait(2)- self.play(- FadeOut(example3),- FadeIn(example4),- )- self.wait(2)- self.play(- FadeOut(example4),- FadeIn(main_example),- )- self.wait(2)-- def get_main_example(self):- return VGroup(- self.second_order_word,- self.ode_initials,- self.equation- )-- def show_changing_curvature_group(self):- t_tracker = self.t_tracker- curvature_group = self.curvature_group- labels = self.curvature_group_labels- graph = VMobject()- graph.pointwise_become_partial(- self.fake_graph,- t_tracker.get_value() / self.axes.x_max,- 1,- )- dashed_graph = DashedVMobject(graph, num_dashes=100)- dashed_graph.set_stroke(GREEN, 1)-- self.play(FadeOut(labels))- self.add(dashed_graph, curvature_group)- self.play(- t_tracker.set_value, 10,- ShowCreation(dashed_graph),- run_time=15,- rate_func=linear,- )- self.wait()---# Largely a copy of DefineODE, which is not great.-# But what can you do?-class SecondOrderEquationExample(DefineODE):- def construct(self):- self.add_graph()- self.write_differential_equation()- self.show_value_slope_curvature()- self.show_higher_order_examples()- self.show_changing_curvature_group()-- def add_graph(self):- axes = self.axes = Axes(- x_min=0,- x_max=10.5,- y_min=-2.5,- y_max=2.5,- )- axes.center()- axes.to_edge(DOWN)- x_t = TexMobject("x", "(t)")- x_t.set_color_by_tex("x", BLUE)- t = TexMobject("t")- t.next_to(axes.x_axis.get_right(), UP)- x_t.next_to(axes.y_axis.get_top(), UP)-- axes.add(t, x_t)- axes.add_coordinates()-- self.add(axes)-- def write_differential_equation(self):- de_word = TextMobject("Differential", "Equation")- de_word.scale(1.25)- de_word.to_edge(UP, buff=MED_SMALL_BUFF)- so_word = TextMobject("Second Order")- so_word.scale(1.25)- de_word.generate_target()- group = VGroup(so_word, de_word.target)- group.arrange(RIGHT)- group.to_edge(UP, buff=MED_SMALL_BUFF)- so_word.align_to(de_word.target[0], DOWN)- so_line = Line(LEFT, RIGHT, color=YELLOW)- so_line.match_width(so_word)- so_line.next_to(so_word, DOWN, buff=SMALL_BUFF)-- equation = TexMobject(- "{\\ddot x}(t)", "=",- "-\\mu", "{\\dot x}(t)",- "-", "\\omega", "{x}(t)",- tex_to_color_map={- "{x}": BLUE,- "{\\dot x}": RED,- "{\\ddot x}": YELLOW,- }- )- equation.next_to(de_word, DOWN)-- dd_x_part = equation[:2]- dd_x_rect = SurroundingRectangle(dd_x_part)-- self.add(de_word, equation)- self.play(- MoveToTarget(de_word),- FadeInFrom(so_word, RIGHT),- GrowFromCenter(so_line),- )- self.play(ReplacementTransform(so_line, dd_x_rect))- self.play(FadeOut(dd_x_rect))-- self.equation = equation- self.title = VGroup(*so_word, *de_word)-- def show_value_slope_curvature(self):- axes = self.axes- graph = axes.get_graph(- lambda t: -2.5 * np.cos(2 * t) * np.exp(-0.2 * t)- )-- tex_config = {- "tex_to_color_map": {- "{x}": BLUE,- "{\\dot x}": RED,- "{\\ddot x}": YELLOW,- },- "height": 0.5,- }- x, d_x, dd_x = [- TexMobject(- "{" + s + "x}(t)",- **tex_config- )- for s in ("", "\\dot ", "\\ddot ")- ]-- t_tracker = ValueTracker(1.25)- get_t = t_tracker.get_value-- def get_point(t):- return graph.point_from_proportion(t / axes.x_max)-- def get_dot():- return Dot(get_point(get_t())).scale(0.5)-- def get_v_line():- point = get_point(get_t())- x_point = axes.x_axis.number_to_point(- axes.x_axis.point_to_number(point)- )- return DashedLine(- x_point, point,- dash_length=0.025,- stroke_color=BLUE,- stroke_width=2,- )-- def get_tangent_line(curve, alpha):- line = Line(- ORIGIN, 1.5 * RIGHT,- color=RED,- stroke_width=1.5,- )- da = 0.0001- p0 = curve.point_from_proportion(alpha)- p1 = curve.point_from_proportion(alpha - da)- p2 = curve.point_from_proportion(alpha + da)- angle = angle_of_vector(p2 - p1)- line.rotate(angle)- line.move_to(p0)- return line-- def get_slope_line():- return get_tangent_line(- graph, get_t() / axes.x_max- )-- def get_curve():- curve = VMobject()- t = get_t()- curve.set_points_smoothly([- get_point(t + a)- for a in np.linspace(-0.5, 0.5, 11)- ])- curve.set_stroke(YELLOW, 1)- return curve-- v_line = always_redraw(get_v_line)- dot = always_redraw(get_dot)- slope_line = always_redraw(get_slope_line)- curve = always_redraw(get_curve)-- x.next_to(v_line, RIGHT, SMALL_BUFF)- d_x.next_to(slope_line.get_end(), UP, SMALL_BUFF)- dd_x.next_to(curve.get_end(), RIGHT, SMALL_BUFF)- xs = VGroup(x, d_x, dd_x)-- words = VGroup(- TextMobject("= Height").set_color(BLUE),- TextMobject("= Slope").set_color(RED),- TextMobject("= ``Curvature''").set_color(YELLOW),- )- words.scale(0.75)- for word, sym in zip(words, xs):- word.next_to(sym, RIGHT, buff=2 * SMALL_BUFF)- sym.word = word-- self.play(- ShowCreation(v_line),- FadeInFromPoint(dot, v_line.get_start()),- FadeInFrom(x, DOWN),- FadeInFrom(x.word, DOWN),- )- self.add(slope_line, dot)- self.play(- ShowCreation(slope_line),- FadeInFrom(d_x, LEFT),- FadeInFrom(d_x.word, LEFT),- )-- a_tracker = ValueTracker(0)- curve_copy = curve.copy()- changing_slope = always_redraw(- lambda: get_tangent_line(- curve_copy,- a_tracker.get_value(),- ).set_stroke(- opacity=there_and_back(a_tracker.get_value())- )- )- self.add(curve, dot)- self.play(- ShowCreation(curve),- FadeInFrom(dd_x, LEFT),- FadeInFrom(dd_x.word, LEFT),- )- self.add(changing_slope)- self.play(- a_tracker.set_value, 1,- run_time=3,- )- self.remove(changing_slope, a_tracker)-- self.t_tracker = t_tracker- self.curvature_group = VGroup(- v_line, slope_line, curve, dot- )- self.curvature_group_labels = VGroup(xs, words)- self.fake_graph = graph-- def get_main_example(self):- return VGroup(- self.equation,- self.title,- )--# class VisualizeHeightSlopeCurvature(DefineODE):-# CONFIG = {-# "pendulum_config": {-# "length": 2,-# "top_point": 5 * RIGHT + 2 * UP,-# "initial_theta": 175 * DEGREES,-# "mu": 0.3,-# },-# }--# def construct(self):-# self.add_graph()-# self.show_value_slope_curvature()-# self.show_changing_curvature_group()---class ODEvsPDEinFrames(Scene):- CONFIG = {- "camera_config": {"background_color": DARKER_GREY}- }-- def construct(self):- frames = VGroup(*[- ScreenRectangle(- height=3.5,- fill_opacity=1,- fill_color=BLACK,- stroke_width=0,- )- for x in range(2)- ])- frames.arrange(RIGHT, buff=LARGE_BUFF)- frames.shift(0.5 * DOWN)-- animated_frames = VGroup(*[- AnimatedBoundary(- frame,- cycle_rate=0.2,- max_stroke_width=1,- )- for frame in frames- ])-- titles = VGroup(- # TextMobject("ODEs"),- # TextMobject("PDEs"),- TextMobject("Ordinary", "Differential", "Equations"),- TextMobject("Partial", "Differential", "Equations"),- )- for title, frame in zip(titles, frames):- title.arrange(- DOWN,- buff=MED_SMALL_BUFF,- aligned_edge=LEFT- )- title.next_to(frame, UP, MED_LARGE_BUFF)- title.initials = VGroup(*[- part[0] for part in title- ])- titles[0][1].shift(0.05 * UP)-- # ODE content- ode = get_ode()- ode.set_width(frames[0].get_width() - MED_LARGE_BUFF)- ode.next_to(frames[0].get_top(), DOWN)- ts = ode.get_parts_by_tex("{t}")- one_input = TextMobject("One input")- one_input.next_to(frames[0].get_bottom(), UP)- o_arrows = VGroup(*[- Arrow(- one_input.get_top(),- t.get_bottom(),- buff=0.2,- color=WHITE,- max_tip_length_to_length_ratio=0.075,- path_arc=pa- )- for t, pa in zip(ts, [-0.7, 0, 0.7])- ])- o_arrows.set_stroke(width=3)- frames[0].add(ode, one_input, o_arrows)-- # PDE content- pde = TexMobject(- """- \\frac{\\partial T}{\\partial t}- {(x, y, t)} =- \\frac{\\partial^2 T}{\\partial x^2}- {(x, y, t)} +- \\frac{\\partial^2 T}{\\partial y^2}- {(x, y, t)}- """,- tex_to_color_map={"{(x, y, t)}": WHITE}- )- pde.set_width(frames[1].get_width() - MED_LARGE_BUFF)- pde.next_to(frames[1].get_top(), DOWN)- inputs = pde.get_parts_by_tex("{(x, y, t)}")- multi_input = TextMobject("Multiple inputs")- multi_input.next_to(frames[1].get_bottom(), UP)- p_arrows = VGroup(*[- Arrow(- multi_input.get_top(),- mob.get_bottom(),- buff=0.2,- color=WHITE,- max_tip_length_to_length_ratio=0.075,- path_arc=pa- )- for mob, pa in zip(inputs, [-0.7, 0, 0.7])- ])- p_arrows.set_stroke(width=3)- frames[1].add(pde, multi_input, p_arrows)-- self.add(- frames[0],- animated_frames[0],- titles[0]- )- self.play(- Write(one_input),- ShowCreation(o_arrows, lag_ratio=0.5)- )- self.wait(2)- self.play(titles[0].initials.set_color, BLUE)- self.wait(7)-- # Transition- self.play(- TransformFromCopy(*titles),- TransformFromCopy(*frames),- )- self.play(VFadeIn(animated_frames[1]))- self.wait()- self.play(titles[1].initials.set_color, YELLOW)- self.wait(30)---class ReferencePiCollisionStateSpaces(Scene):- CONFIG = {- "camera_config": {"background_color": DARKER_GREY}- }-- def construct(self):- title = TextMobject("The block collision puzzle")- title.scale(1.5)- title.to_edge(UP)- self.add(title)-- frames = VGroup(*[- ScreenRectangle(- height=3.5,- fill_opacity=1,- fill_color=BLACK,- stroke_width=0,- )- for x in range(2)- ])- frames.arrange(RIGHT, buff=LARGE_BUFF)- boundary = AnimatedBoundary(frames)- self.add(frames, boundary)- self.wait(15)---class XComponentArrows(Scene):- def construct(self):- field = VectorField(- lambda p: np.array([p[1], 0, 0])- )- field.set_opacity(0.75)- for u in (1, -1):- field.sort(lambda p: u * p[0])- self.play(LaggedStartMap(- GrowArrow, field,- lag_ratio=0.1,- run_time=1- ))- self.play(FadeOut(field))---class BreakingSecondOrderIntoTwoFirstOrder(IntroduceVectorField):- def construct(self):- ode = TexMobject(- "{\\ddot\\theta}", "(t)", "=",- "-\\mu", "{\\dot\\theta}", "(t)"- "-(g / L)\\sin\\big(", "{\\theta}", "(t)\\big)",- tex_to_color_map={- "{\\ddot\\theta}": RED,- "{\\dot\\theta}": YELLOW,- "{\\theta}": BLUE,- # "{t}": WHITE,- }- )- so_word = TextMobject("Second order ODE")- sys_word = TextMobject("System of two first order ODEs")-- system1 = self.get_system("{\\theta}", "{\\dot\\theta}")- system2 = self.get_system("{\\theta}", "{\\omega}")-- so_word.to_edge(UP)- ode.next_to(so_word, DOWN)- sys_word.move_to(ORIGIN)- system1.next_to(sys_word, DOWN)- system2.move_to(system1)-- theta_dots = VGroup(*filter(- lambda m: (- isinstance(m, SingleStringTexMobject) and- "{\\dot\\theta}" == m.get_tex_string()- ),- system1.get_family(),- ))-- self.add(ode)- self.play(FadeInFrom(so_word, 0.5 * DOWN))- self.wait()-- self.play(- TransformFromCopy(- ode[3:], system1[3].get_entries()[1],- ),- TransformFromCopy(ode[2], system1[2]),- TransformFromCopy(- ode[:2], VGroup(- system1[0],- system1[1].get_entries()[1],- )- ),- )- self.play(- FadeIn(system1[1].get_brackets()),- FadeIn(system1[1].get_entries()[0]),- FadeIn(system1[3].get_brackets()),- FadeIn(system1[3].get_entries()[0]),- )- self.play(- FadeInFromDown(sys_word)- )- self.wait()- self.play(LaggedStartMap(- ShowCreationThenFadeAround,- theta_dots,- surrounding_rectangle_config={- "color": PINK,- }- ))-- self.play(ReplacementTransform(system1, system2))- self.wait()-- def get_system(self, tex1, tex2):- system = VGroup(- TexMobject("d \\over dt"),- self.get_vector_symbol(- tex1 + "(t)",- tex2 + "(t)",- ),- TexMobject("="),- self.get_vector_symbol(- tex2 + "(t)",- "".join([- "-\\mu", tex2, "(t)",- "-(g / L) \\sin\\big(",- tex1, "(t)", "\\big)",- ])- )- )- system.arrange(RIGHT)- return system---class FromODEToVectorField(Scene):- def construct(self):- matrix_config = {- "bracket_v_buff": 2 * SMALL_BUFF,- "element_to_mobject_config": {- "tex_to_color_map": {- "x": GREEN,- "y": RED,- "z": BLUE,- },- }- }- vect = get_vector_symbol(- "x(t)", "y(t)", "z(t)",- **matrix_config,- )- d_vect = get_vector_symbol(- "\\sigma\\big(y(t) - x(t)\\big)",- "x(t)\\big(\\rho - z(t)\\big) - y(t)",- "x(t)y(t) - \\beta z(t)",- **matrix_config- )- equation = VGroup(- TexMobject("d \\over dt").scale(1.5),- vect,- TexMobject("="),- d_vect- )- equation.scale(0.8)- equation.arrange(RIGHT)- equation.to_edge(UP)-- arrow = Vector(DOWN, color=YELLOW)- arrow.next_to(equation, DOWN)-- self.add(equation)- self.play(ShowCreation(arrow))- self.wait()---class LorenzVectorField(ExternallyAnimatedScene):- pass---class ThreeBodiesInSpace(SpecialThreeDScene):- CONFIG = {- "masses": [1, 6, 3],- "colors": [RED_E, GREEN_E, BLUE_E],- "G": 0.5,- "play_time": 60,- }-- def construct(self):- self.add_axes()- self.add_bodies()- self.add_trajectories()- self.let_play()-- def add_axes(self):- axes = self.axes = self.get_axes()- axes.set_stroke(width=0.5)- self.add(axes)-- # Orient- self.set_camera_orientation(- phi=70 * DEGREES,- theta=-110 * DEGREES,- )- self.begin_ambient_camera_rotation()-- def add_bodies(self):- masses = self.masses- colors = self.colors-- bodies = self.bodies = VGroup()- velocity_vectors = VGroup()-- centers = self.get_initial_positions()-- for mass, color, center in zip(masses, colors, centers):- body = self.get_sphere(- checkerboard_colors=[- color, color- ],- color=color,- stroke_width=0.1,- )- body.set_opacity(0.75)- body.mass = mass- body.radius = 0.08 * np.sqrt(mass)- body.set_width(2 * body.radius)-- body.point = center- body.move_to(center)-- body.velocity = self.get_initial_velocity(- center, centers, mass- )-- vect = self.get_velocity_vector_mob(body)-- bodies.add(body)- velocity_vectors.add(vect)-- total_mass = np.sum([body.mass for body in bodies])- center_of_mass = reduce(op.add, [- body.mass * body.get_center() / total_mass- for body in bodies- ])- average_momentum = reduce(op.add, [- body.mass * body.velocity / total_mass- for body in bodies- ])- for body in bodies:- body.shift(-center_of_mass)- body.velocity -= average_momentum-- def get_initial_positions(self):- return [- np.dot(- 4 * (np.random.random(3) - 0.5),- [RIGHT, UP, OUT]- )- for x in range(len(self.masses))- ]-- def get_initial_velocity(self, center, centers, mass):- to_others = [- center - center2- for center2 in centers- ]- velocity = 0.2 * mass * normalize(np.cross(*filter(- lambda diff: get_norm(diff) > 0,- to_others- )))- return velocity-- def add_trajectories(self):- def update_trajectory(traj, dt):- new_point = traj.body.point- if get_norm(new_point - traj.points[-1]) > 0.01:- traj.add_smooth_curve_to(new_point)-- for body in self.bodies:- traj = VMobject()- traj.body = body- traj.start_new_path(body.point)- traj.set_stroke(body.color, 1, opacity=0.75)- traj.add_updater(update_trajectory)- self.add(traj, body)-- def let_play(self):- bodies = self.bodies- bodies.add_updater(self.update_bodies)- # Break it up to see partial files as- # it's rendered- self.add(bodies)- for x in range(int(self.play_time)):- self.wait()-- #- def get_velocity_vector_mob(self, body):- def draw_vector():- center = body.get_center()- vect = Arrow(- center,- center + body.velocity,- buff=0,- color=RED,- )- vect.set_shade_in_3d(True)- return vect- # length = vect.get_length()- # if length > 2:- # vect.scale(- # 2 / length,- # about_point=vect.get_start(),- # )- return always_redraw(draw_vector)-- def update_bodies(self, bodies, dt):- G = self.G-- num_mid_steps = 1000- for x in range(num_mid_steps):- for body in bodies:- acceleration = np.zeros(3)- for body2 in bodies:- if body2 is body:- continue- diff = body2.point - body.point- m2 = body2.mass- R = get_norm(diff)- acceleration += G * m2 * diff / (R**3)- body.point += body.velocity * dt / num_mid_steps- body.velocity += acceleration * dt / num_mid_steps- for body in bodies:- body.move_to(body.point)- return bodies---class AltThreeBodiesInSpace(ThreeBodiesInSpace):- CONFIG = {- "random_seed": 6,- "masses": [1, 2, 6],- }---class TwoBodiesInSpace(ThreeBodiesInSpace):- CONFIG = {- "colors": [GREY, BLUE],- "masses": [6, 36],- "play_time": 60,- }-- def construct(self):- self.add_axes()- self.add_bodies()- self.add_trajectories()- self.add_velocity_vectors()- self.add_force_vectors()- self.let_play()-- def add_bodies(self):- super().add_bodies()- for body in self.bodies:- body.point = 3 * normalize(body.get_center())- # body.point += 2 * IN- # body.velocity += (4 / 60) * OUT- body.move_to(body.point)-- def get_initial_positions(self):- return [- np.dot(- 6 * (np.random.random(3) - 0.5),- [RIGHT, UP, ORIGIN]- )- for x in range(len(self.masses))- ]-- def get_initial_velocity(self, center, centers, mass):- return 0.75 * normalize(np.cross(center, OUT))-- def add_velocity_vectors(self):- vectors = VGroup(*[- self.get_velocity_vector(body)- for body in self.bodies- ])- self.velocity_vectors = vectors- self.add(vectors)-- def get_velocity_vector(self, body):- def create_vector(b):- v = Vector(- b.velocity,- color=RED,- max_stroke_width_to_length_ratio=3,- )- v.set_stroke(width=3)- v.shift(- b.point + b.radius * normalize(b.velocity) -- v.get_start(),- )- v.set_shade_in_3d(True)- return v- return always_redraw(lambda: create_vector(body))-- def add_force_vectors(self):- vectors = VGroup(*[- self.get_force_vector(b1, b2)- for (b1, b2) in (self.bodies, self.bodies[::-1])- ])- self.force_vectors = vectors- self.add(vectors)-- def get_force_vector(self, body1, body2):- def create_vector(b1, b2):- r = b2.point - b1.point- F = r / (get_norm(r)**3)- v = Vector(- 4 * F,- color=YELLOW,- max_stroke_width_to_length_ratio=3,- )- v.set_stroke(width=3)- v.shift(- b1.point + b1.radius * normalize(F) -- v.get_start(),- )- v.set_shade_in_3d(True)- return v- return always_redraw(lambda: create_vector(body1, body2))---class TwoBodiesWithZPart(TwoBodiesInSpace):- def add_bodies(self):- super().add_bodies()- for body in self.bodies:- body.point += 3 * IN- body.velocity += (6 / 60) * OUT---class LoveExample(PiCreatureScene):- def construct(self):- self.show_hearts()- self.add_love_trackers()- self.break_down_your_rule()- self.break_down_their_rule()-- def create_pi_creatures(self):- you = You()- you.shift(FRAME_WIDTH * LEFT / 4)- you.to_edge(DOWN)-- tau = TauCreature(color=GREEN)- tau.flip()- tau.shift(FRAME_WIDTH * RIGHT / 4)- tau.to_edge(DOWN)-- self.you = you- self.tau = tau- return (you, tau)-- def show_hearts(self):- you, tau = self.you, self.tau- hearts = VGroup()- n_hearts = 20- for x in range(n_hearts):- heart = SuitSymbol("hearts")- heart.scale(0.5 + 2 * np.random.random())- heart.shift(np.random.random() * 4 * RIGHT)- heart.shift(np.random.random() * 4 * UP)- hearts.add(heart)- hearts.move_to(2 * DOWN)- hearts.add_updater(lambda m, dt: m.shift(2 * dt * UP))-- self.add(hearts)- self.play(- LaggedStartMap(- UpdateFromAlphaFunc, hearts,- lambda heart: (- heart,- lambda h, a: h.set_opacity(- there_and_back(a)- ).shift(0.02 * UP)- ),- lag_ratio=0.01,- run_time=3,- suspend_mobject_updating=False,- ),- ApplyMethod(- you.change, 'hooray', tau.eyes,- run_time=2,- rate_func=squish_rate_func(smooth, 0.5, 1)- ),- ApplyMethod(- tau.change, 'hooray', you.eyes,- run_time=2,- rate_func=squish_rate_func(smooth, 0.5, 1)- ),- )- self.remove(hearts)- self.wait()-- def add_love_trackers(self):- self.init_ps_point()- self.add_love_decimals()- self.add_love_number_lines()- self.tie_creature_state_to_ps_point()-- self.play(Rotating(- self.ps_point,- radians=-7 * TAU / 8,- about_point=ORIGIN,- run_time=10,- rate_func=linear,- ))- self.wait()-- def break_down_your_rule(self):- label1 = self.love_1_label- label2 = self.love_2_label- ps_point = self.ps_point-- up_arrow = Vector(UP, color=GREEN)- down_arrow = Vector(DOWN, color=RED)- for arrow in (up_arrow, down_arrow):- arrow.next_to(label1, RIGHT)-- self.play(GrowArrow(up_arrow))- self.play(- self.tau.love_eyes.scale, 1.25,- self.tau.love_eyes.set_color, BLUE_C,- rate_func=there_and_back,- )- self.play(- ps_point.shift, 6 * RIGHT,- run_time=2,- )- self.wait()- ps_point.shift(13 * DOWN)- self.play(- FadeOut(up_arrow),- GrowArrow(down_arrow),- )- self.play(- ps_point.shift, 11 * LEFT,- run_time=3,- )- self.wait()-- # Derivative- equation = get_love_equation1()- equation.shift(0.5 * UP)- deriv, equals, a, h2 = equation-- self.play(- Write(deriv[:-1]),- Write(equals),- Write(a),- TransformFromCopy(label1[0], deriv.heart),- TransformFromCopy(label2[0], h2),- )- self.wait()- self.play(- equation.scale, 0.5,- equation.to_corner, UL,- FadeOut(down_arrow)- )-- def break_down_their_rule(self):- label1 = self.love_1_label- label2 = self.love_2_label- ps_point = self.ps_point-- up_arrow = Vector(UP, color=GREEN)- down_arrow = Vector(DOWN, color=RED)- for arrow in (up_arrow, down_arrow):- arrow.next_to(label2, RIGHT)-- # Derivative- equation = get_love_equation2()- equation.shift(0.5 * UP)- deriv, equals, mb, h1 = equation-- self.play(- Write(deriv[:-1]),- Write(equals),- Write(mb),- TransformFromCopy(label1[0], h1),- TransformFromCopy(label2[0], deriv.heart),- )-- self.play(GrowArrow(up_arrow))- self.play(- ps_point.shift, 13 * UP,- run_time=3,- )- self.wait()- self.play(- ps_point.shift, 11 * RIGHT,- )- self.play(- FadeOut(up_arrow),- GrowArrow(down_arrow),- )- self.play(- ps_point.shift, 13 * DOWN,- run_time=3,- )- self.wait()-- #- def init_ps_point(self):- self.ps_point = VectorizedPoint(np.array([5.0, 5.0, 0]))-- def get_love1(self):- return self.ps_point.get_location()[0]-- def get_love2(self):- return self.ps_point.get_location()[1]-- def set_loves(self, love1=None, love2=None):- if love1 is not None:- self.ps_point.set_x(love1)- if love2 is not None:- self.ps_point.set_x(love2)-- def add_love_decimals(self):- self.love_1_label = self.add_love_decimal(- 1, self.get_love1, self.you.get_color(), -3,- )- self.love_2_label = self.add_love_decimal(- 2, self.get_love2, self.tau.get_color(), 3,- )-- def add_love_decimal(self, index, value_func, color, x_coord):- d = DecimalNumber(include_sign=True)- d.add_updater(lambda d: d.set_value(value_func()))-- label = get_heart_var(index)- label.move_to(x_coord * RIGHT)- label.to_edge(UP)- eq = TexMobject("=")- eq.next_to(label, RIGHT, SMALL_BUFF)- eq.shift(SMALL_BUFF * UP)- d.next_to(eq, RIGHT, SMALL_BUFF)-- self.add(label, eq, d)- return VGroup(label, eq, d)-- def add_love_number_lines(self):- nl1 = NumberLine(- x_min=-8,- x_max=8,- unit_size=0.25,- tick_frequency=2,- number_scale_val=0.25,- )- nl1.set_stroke(width=1)- nl1.next_to(self.love_1_label, DOWN)- nl1.add_numbers(*range(-6, 8, 2))-- nl2 = nl1.copy()- nl2.next_to(self.love_2_label, DOWN)-- dot1 = Dot(color=self.you.get_color())- dot1.add_updater(lambda d: d.move_to(- nl1.number_to_point(self.get_love1())- ))- dot2 = Dot(color=self.tau.get_color())- dot2.add_updater(lambda d: d.move_to(- nl2.number_to_point(self.get_love2())- ))-- self.add(nl1, nl2, dot1, dot2)-- def get_love_eyes(self, eyes):- hearts = VGroup()- for eye in eyes:- heart = SuitSymbol("hearts")- heart.match_width(eye)- heart.move_to(eye)- heart.scale(1.25)- heart.set_stroke(BLACK, 1)- hearts.add(heart)- hearts.add_updater(- lambda m: m.move_to(eyes)- )- return hearts-- def tie_creature_state_to_ps_point(self):- # Quite a mess, but I'm coding in a rush here...- you = self.you- you_copy = you.copy()- tau = self.tau- tau_copy = tau.copy()-- you.love_eyes = self.get_love_eyes(you.eyes)- tau.love_eyes = self.get_love_eyes(tau.eyes)-- self.add(you.love_eyes)- self.add(tau.love_eyes)-- you_height = you.get_height()- tau_height = tau.get_height()-- you_bottom = you.get_bottom()- tau_bottom = tau.get_bottom()-- def update_you(y):- love = self.get_love1()-- cutoff_values = [- -5, -3, -1, 1, 3, 5- ]- modes = [- "angry", "sassy", "hesitant",- "plain",- "happy", "hooray", "surprised",- ]-- if love < cutoff_values[0]:- y.change(modes[0])- elif love >= cutoff_values[-1]:- y.change(modes[-1])- else:- i = 0- while cutoff_values[i] < love:- i += 1- m1 = modes[i - 1]- m2 = modes[i]- y.change(m1)- you_copy.change(m2)- for mob in y, you_copy:- mob.set_height(you_height)- mob.move_to(you_bottom, DOWN)-- alpha = inverse_interpolate(- cutoff_values[i - 1],- cutoff_values[i],- love,- )- s_alpha = squish_rate_func(smooth, 0.25, 1)(alpha)- if s_alpha > 0:- y.align_data(you_copy)- f1 = y.family_members_with_points()- f2 = you_copy.family_members_with_points()- for sm1, sm2 in zip(f1, f2):- sm1.interpolate(sm1, sm2, s_alpha)- y.look_at(tau.eyes)- if love < -4:- y.look_at(LEFT_SIDE)- # y.move_to(- # you_bottom + 0.025 * love * RIGHT, DOWN,- # )-- l_alpha = np.clip(- inverse_interpolate(5, 5.5, love),- 0, 1- )- y.eyes.set_opacity(1 - l_alpha)- y.love_eyes.set_opacity(l_alpha)-- return y-- def update_tau(t):- love = self.get_love2()-- cutoff_values = [- -5, -1.7, 1.7, 5- ]- modes = [- "angry", "confused", "plain",- "hooray", "hooray"- ]-- if love < cutoff_values[0]:- t.change(modes[0])- elif love >= cutoff_values[-1]:- t.change(modes[-1])- else:- i = 0- while cutoff_values[i] < love:- i += 1- m1 = modes[i - 1]- m2 = modes[i]- t.change(m1)- tau_copy.change(m2)- for mob in t, tau_copy:- mob.set_height(tau_height)- mob.move_to(tau_bottom, DOWN)-- alpha = inverse_interpolate(- cutoff_values[i - 1],- cutoff_values[i],- love,- )- s_alpha = squish_rate_func(smooth, 0.25, 1)(alpha)- if s_alpha > 0:- t.align_data(tau_copy)- f1 = t.family_members_with_points()- f2 = tau_copy.family_members_with_points()- for sm1, sm2 in zip(f1, f2):- sm1.interpolate(sm1, sm2, s_alpha)- # t.move_to(- # tau_bottom + 0.025 * love * LEFT, DOWN,- # )- t.look_at(you.eyes)- if love < -4:- t.look_at(RIGHT_SIDE)-- l_alpha = np.clip(- inverse_interpolate(5, 5.5, love),- 0, 1- )- t.eyes.set_opacity(1 - l_alpha)- t.love_eyes.set_opacity(l_alpha)-- you.add_updater(update_you)- tau.add_updater(update_tau)-- self.pi_creatures = VGroup()---class ComparePhysicsToLove(Scene):- def construct(self):- ode = get_ode()- ode.to_edge(UP)- thetas = ode.get_parts_by_tex("theta")-- love = VGroup(- get_love_equation1(),- get_love_equation2(),- )- love.scale(0.5)- love.arrange(DOWN, buff=MED_LARGE_BUFF, aligned_edge=LEFT)- love.move_to(DOWN)- hearts = VGroup(*filter(- lambda sm: isinstance(sm, SuitSymbol),- love.get_family()- ))-- arrow = DoubleArrow(love.get_top(), ode.get_bottom())-- self.play(FadeInFrom(ode, DOWN))- self.play(FadeInFrom(love, UP))- self.wait()- self.play(LaggedStartMap(- ShowCreationThenFadeAround,- thetas,- ))- self.play(LaggedStartMap(- ShowCreationThenFadeAround,- hearts,- ))- self.wait()- self.play(ShowCreation(arrow))- self.wait()---class FramesComparingPhysicsToLove(Scene):- CONFIG = {- "camera_config": {"background_color": DARKER_GREY}- }-- def construct(self):- ode = get_ode()- ode.to_edge(UP)-- love = VGroup(- get_love_equation1(),- get_love_equation2(),- )- love.scale(0.5)- love.arrange(DOWN, buff=MED_LARGE_BUFF, aligned_edge=LEFT)-- frames = VGroup(*[- ScreenRectangle(- height=3.5,- fill_color=BLACK,- fill_opacity=1,- stroke_width=0,- )- for x in range(2)- ])- frames.arrange(RIGHT, buff=LARGE_BUFF)- frames.shift(DOWN)-- animated_frames = AnimatedBoundary(frames)-- ode.next_to(frames[0], UP)- love.next_to(frames[1], UP)-- self.add(frames, animated_frames)- self.add(ode, love)-- self.wait(15)---class PassageOfTime(Scene):- def construct(self):- clock = Clock()- clock[0].set_color(BLUE)- clock.set_stroke(width=1)- clock.scale(0.8)- clock.to_corner(UL)- passage = ClockPassesTime(- clock,- hours_passed=48,- )- self.play(passage, run_time=10)---class WriteODESolvingCode(ExternallyAnimatedScene):- pass---class InaccurateComputation(Scene):- def construct(self):- h_line = DashedLine(LEFT_SIDE, RIGHT_SIDE)- h_line.to_edge(UP, buff=1.5)- words = VGroup(- TextMobject("Real number"),- TextMobject("IEEE 754\\\\representation"),- TextMobject("Error"),- )- for i, word in zip([-1, 0, 1], words):- word.next_to(h_line, UP)- word.shift(i * FRAME_WIDTH * RIGHT / 3)-- lines = VGroup(*[- DashedLine(TOP, BOTTOM)- for x in range(4)- ])- lines.arrange(RIGHT)- lines.stretch_to_fit_width(FRAME_WIDTH)-- self.add(h_line, lines[1:-1], words)-- numbers = VGroup(- TexMobject("\\pi").scale(2),- TexMobject("e^{\\sqrt{163}\\pi}").scale(1.5),- )- numbers.set_color(YELLOW)- numbers.set_stroke(width=0, background=True)-- bit_strings = VGroup(- TexMobject(- "01000000",- "01001001",- "00001111",- "11011011",- ),- TexMobject(- "01011100",- "01101001",- "00101110",- "00011001",- )- )- for mob in bit_strings:- mob.arrange(DOWN, buff=SMALL_BUFF)- for word in mob:- for submob, bit in zip(word, word.get_tex_string()):- if bit == "0":- submob.set_color(LIGHT_GREY)- errors = VGroup(- TexMobject(- "\\approx 8.7422 \\times 10^{-8}"- ),- TexMobject(- "\\approx 5{,}289{,}803{,}032.00",- ),- )- errors.set_color(RED)-- content = VGroup(numbers, bit_strings, errors)-- for group, word in zip(content, words):- group[1].shift(3 * DOWN)- group.move_to(DOWN)- group.match_x(word)-- self.play(*map(Write, numbers))- self.wait()- self.play(- TransformFromCopy(numbers, bit_strings),- lag_ratio=0.01,- run_time=2,- )- self.wait()- self.play(FadeInFrom(errors, 3 * LEFT))- self.wait()---class NewSceneName(Scene):- def construct(self):- passdiff --git a/active_projects/ode/part1/wordy_scenes.py b/active_projects/ode/part1/wordy_scenes.pydeleted file mode 100644index 91dc0ff18..000000000--- a/active_projects/ode/part1/wordy_scenes.py+++ /dev/null@@ -1,855 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.shared_constructs import *---class SmallAngleApproximationTex(Scene):- def construct(self):- approx = TexMobject(- "\\sin", "(", "\\theta", ") \\approx \\theta",- tex_to_color_map={"\\theta": RED},- arg_separator="",- )-- implies = TexMobject("\\Downarrow")- period = TexMobject(- "\\text{Period}", "\\approx",- "2\\pi \\sqrt{\\,{L} / {g}}",- **Lg_formula_config,- )- group = VGroup(approx, implies, period)- group.arrange(DOWN)-- approx_brace = Brace(approx, UP, buff=SMALL_BUFF)- approx_words = TextMobject(- "For small $\\theta$",- tex_to_color_map={"$\\theta$": RED},- )- approx_words.scale(0.75)- approx_words.next_to(approx_brace, UP, SMALL_BUFF)-- self.add(approx, approx_brace, approx_words)- self.play(- Write(implies),- FadeInFrom(period, LEFT)- )- self.wait()---class StrogatzQuote(Scene):- def construct(self):- quote = self.get_quote()- movers = VGroup(*quote[:-1].family_members_with_points())- for mover in movers:- mover.save_state()- disc = Circle(radius=0.05)- disc.set_stroke(width=0)- disc.set_fill(BLACK, 0)- disc.move_to(mover)- mover.become(disc)- self.play(- FadeInFrom(quote.author_part, LEFT),- LaggedStartMap(- # FadeInFromLarge,- # quote[:-1].family_members_with_points(),- Restore, movers,- lag_ratio=0.005,- run_time=2,- )- # FadeInFromDown(quote[:-1]),- # lag_ratio=0.01,- )- self.wait()- self.play(- Write(quote.law_part.copy().set_color(YELLOW)),- run_time=1,- )- self.wait()- self.play(- Write(quote.language_part.copy().set_color(BLUE)),- run_time=1.5,- )- self.wait(2)-- def get_quote(self):- law_words = "laws of physics"- language_words = "language of differential equations"- author = "-Steven Strogatz"- quote = TextMobject(- """- \\Large- ``Since Newton, mankind has come to realize- that the laws of physics are always expressed- in the language of differential equations.''\\\\- """ + author,- alignment="",- arg_separator=" ",- substrings_to_isolate=[law_words, language_words, author]- )- quote.law_part = quote.get_part_by_tex(law_words)- quote.language_part = quote.get_part_by_tex(language_words)- quote.author_part = quote.get_part_by_tex(author)- quote.set_width(12)- quote.to_edge(UP)- quote[-2].shift(SMALL_BUFF * LEFT)- quote.author_part.shift(RIGHT + 0.5 * DOWN)- quote.author_part.scale(1.2, about_edge=UL)-- return quote---class WriteInRadians(Scene):- def construct(self):- words = TextMobject("In radians")- words.set_color(YELLOW)- square = SurroundingRectangle(TexMobject("\\theta"))- square.next_to(words, UP)- self.play(ShowCreation(square))- self.play(Write(words), FadeOut(square))- self.wait()---class XEqLThetaToCorner(Scene):- def construct(self):- equation = TexMobject(- "x = L\\theta",- tex_to_color_map={- "x": GREEN,- "\\theta": BLUE,- }- )- equation.move_to(DOWN + 3 * RIGHT)- self.add(equation)- self.play(equation.to_corner, DL, {"buff": LARGE_BUFF})- self.wait()---class ComingUp(Scene):- CONFIG = {- "camera_config": {"background_color": DARKER_GREY}- }-- def construct(self):- frame = ScreenRectangle(- stroke_width=0,- fill_color=BLACK,- fill_opacity=1,- height=6- )- title = TextMobject("Coming up")- title.scale(1.5)- title.to_edge(UP)- frame.next_to(title, DOWN)- animated_frame = AnimatedBoundary(frame)- self.add(frame, title, animated_frame)- self.wait(10)---class InputLabel(Scene):- def construct(self):- label = TextMobject("Input")- label.scale(1.25)- arrow = Vector(UP)- arrow.next_to(label, UP)- self.play(- FadeInFrom(label, UP),- GrowArrow(arrow)- )- self.wait()---class ReallyHardToSolve(Scene):- def construct(self):- words = TextMobject(- "They're", "really\\\\",- "freaking", "hard\\\\",- "to", "solve\\\\",- )- words.set_height(6)-- self.wait()- for word in words:- wait_time = 0.05 * len(word)- self.add(word)- self.wait(wait_time)- self.wait()---class ReasonForSolution(Scene):- def construct(self):- # Words- eq_word = TextMobject("Differential\\\\Equation")- s_word = TextMobject("Solution")- u_word = TextMobject("Understanding")- c_word = TextMobject("Computation")- cu_group = VGroup(u_word, c_word)- cu_group.arrange(DOWN, buff=2)- group = VGroup(eq_word, s_word, cu_group)- group.arrange(RIGHT, buff=2)- # words = VGroup(eq_word, s_word, u_word, c_word)-- # Arrows- arrows = VGroup(- Arrow(eq_word.get_right(), s_word.get_left()),- Arrow(s_word.get_right(), u_word.get_left()),- Arrow(s_word.get_right(), c_word.get_left()),- )- arrows.set_color(LIGHT_GREY)- new_arrows = VGroup(- Arrow(- eq_word.get_corner(UR),- u_word.get_left(),- path_arc=-60 * DEGREES,- ),- Arrow(- eq_word.get_corner(DR),- c_word.get_left(),- path_arc=60 * DEGREES,- ),- )- new_arrows.set_color(BLUE)-- # Define first examples- t2c = {- "{x}": BLUE,- "{\\dot x}": RED,- }- equation = TexMobject(- "{\\dot x}(t) = k {x}(t)",- tex_to_color_map=t2c,- )- equation.next_to(eq_word, DOWN)- solution = TexMobject(- "{x}(t) = x_0 e^{kt}",- tex_to_color_map=t2c,- )- solution.next_to(s_word, DOWN, MED_LARGE_BUFF)- equation.align_to(solution, DOWN)-- axes = Axes(- x_min=-1,- x_max=5.5,- y_min=-1,- y_max=4.5,- y_axis_config={"unit_size": 0.5}- )- axes.set_stroke(width=2)- graph_line = axes.get_graph(- lambda x: np.exp(0.4 * x)- )- graph_line.set_stroke(width=2)- graph = VGroup(axes, graph_line)- graph.scale(0.5)- graph.next_to(u_word, UP)-- computation = TexMobject(- # "\\displaystyle "- "e^x = \\sum_{n=0}^\\infty "- "\\frac{x^n}{n!}"- )- computation.next_to(c_word, DOWN)-- first_examples = VGroup(- equation, solution, graph, computation- )-- # Second example- ode = get_ode()- ode.scale(0.75)- second_examples = VGroup(- ode,- TexMobject("???").set_color(LIGHT_GREY),- ScreenRectangle(- height=2,- stroke_width=1,- ),- )- for fe, se in zip(first_examples, second_examples):- se.move_to(fe, DOWN)-- ode.shift(2 * SMALL_BUFF * DOWN)- ode.add_to_back(BackgroundRectangle(ode[-4:]))-- self.add(eq_word)- self.add(equation)- self.play(- FadeInFrom(s_word, LEFT),- GrowArrow(arrows[0]),- TransformFromCopy(equation, solution)- )- self.wait()- self.play(- FadeInFrom(c_word, UL),- GrowArrow(arrows[2]),- FadeInFrom(computation, UP)- )- self.wait()- self.play(- FadeInFrom(u_word, DL),- GrowArrow(arrows[1]),- FadeInFromDown(graph)- )- self.wait(2)-- self.play(- FadeOut(first_examples),- FadeIn(second_examples[:2])- )- self.wait()- self.play(- arrows.fade, 0.75,- s_word.fade, 0.75,- second_examples[1].fade, 0.75,- ShowCreation(new_arrows[0]),- FadeIn(second_examples[2])- )- self.play(- ShowCreation(new_arrows[1]),- Animation(second_examples),- )- self.wait()---class WritePhaseSpace(Scene):- def construct(self):- word = TextMobject("Phase space")- word.scale(2)- word.shift(FRAME_WIDTH * LEFT / 4)- word.to_edge(UP)- word.add_background_rectangle()-- lines = VGroup(*[- Line(v, 1.3 * v)- for v in compass_directions(50)- ])- lines.replace(word, stretch=True)- lines.scale(1.5)- lines.set_stroke(YELLOW)- lines.shuffle()-- self.add(word)- self.play(- ShowPassingFlashWithThinningStrokeWidth(- lines,- lag_ratio=0.002,- run_time=1.5,- time_width=0.9,- n_segments=5,- )- )- self.wait()---class GleickQuote(Scene):- def construct(self):- quote = TextMobject(- "``[Phase space is] one of the most\\\\",- "powerful inventions", "of modern science.''\\\\",- )- quote.power_part = quote.get_part_by_tex("power")- book = ImageMobject("ChaosBookCover")- book.set_height(5)- book.next_to(ORIGIN, LEFT)- book.to_edge(DOWN)- gleick = ImageMobject("JamesGleick")- gleick.set_height(5)- gleick.next_to(ORIGIN, RIGHT)- gleick.to_edge(DOWN)- quote.to_edge(UP)-- self.play(- FadeInFrom(book, RIGHT),- FadeInFrom(gleick, LEFT),- )- self.wait()- self.play(Write(quote))- self.play(Write(- quote.power_part.copy().set_color(BLUE),- run_time=1- ))- self.wait()---class WritePhaseFlow(Scene):- def construct(self):- words = TextMobject("Phase flow")- words.scale(2)- words.shift(FRAME_WIDTH * LEFT / 4)- words.to_edge(UP)- words.add_background_rectangle()- self.play(Write(words))- self.wait()---class ShowSineValues(Scene):- def construct(self):- angle_tracker = ValueTracker(60 * DEGREES)- get_angle = angle_tracker.get_value- formula = always_redraw(- lambda: self.get_sine_formula(get_angle())- )- self.add(formula)-- self.play(- angle_tracker.set_value, 0,- run_time=3,- )- self.wait()- self.play(- angle_tracker.set_value, 90 * DEGREES,- run_time=3,- )- self.wait()-- def get_sine_formula(self, angle):- sin, lp, rp = TexMobject(- "\\sin", "(", ") = "- )- input_part = Integer(- angle / DEGREES,- unit="^\\circ",- )- input_part.set_color(YELLOW)- output_part = DecimalNumber(- np.sin(input_part.get_value() * DEGREES),- num_decimal_places=3,- )- result = VGroup(- sin, lp, input_part, rp, output_part- )- result.arrange(RIGHT, buff=SMALL_BUFF)- sin.scale(1.1, about_edge=DOWN)- lp.align_to(rp, UP)- return result---class SetAsideSeekingSolution(Scene):- def construct(self):- ode = get_ode()- ode.to_edge(UP)- q1 = TextMobject("Find an exact solution")- q1.set_color(YELLOW)- q2 = TexMobject(- "\\text{What is }", "\\theta", "(t)",- "\\text{'s personality?}",- tex_to_color_map={"\\theta": BLUE},- arg_separator="",- )- theta = q2.get_part_by_tex("\\theta")-- for q in q1, q2:- q.scale(1.5)- q.next_to(ode, DOWN, MED_LARGE_BUFF)- eyes = Eyes(theta, height=0.1)-- self.add(ode)- self.add(q1)- self.wait()- self.play(- q1.scale, 0.3,- q1.to_corner, UR, MED_SMALL_BUFF,- )- self.play(FadeInFrom(q2, DOWN))- self.play(- eyes.blink,- rate_func=lambda t: smooth(1 - t),- )- self.play(eyes.look_at, q2.get_left())- self.play(eyes.look_at, q2.get_right())- self.play(- eyes.blink,- rate_func=squish_rate_func(there_and_back)- )- self.wait()- self.play(- eyes.change_mode, "confused",- eyes.look_at, ode.get_left(),- )- self.play(- eyes.blink,- rate_func=squish_rate_func(there_and_back)- )---class ThreeBodyTitle(Scene):- def construct(self):- title = TextMobject("Three body problem")- title.scale(1.5)- title.to_edge(UP)- self.add(title)---class ThreeBodySymbols(Scene):- def construct(self):- self.init_coord_groups()- self.introduce_coord_groups()- self.count_coords()-- def init_coord_groups(self):- kwargs = {- "bracket_v_buff": 2 * SMALL_BUFF- }- positions = VGroup(*[- get_vector_symbol(*[- "{}_{}".format(s, i)- for s in "xyz"- ], **kwargs)- for i in range(1, 4)- ])- velocities = VGroup(*[- get_vector_symbol(*[- "p^{}_{}".format(s, i)- for s in "xyz"- ], **kwargs)- for i in range(1, 4)- ])- groups = VGroup(positions, velocities)- colors = [GREEN, RED, BLUE]- for group in groups:- for matrix in group:- matrix.coords = matrix.get_entries()- for coord, color in zip(matrix.coords, colors):- coord.set_color(color)- group.arrange(RIGHT)- groups.arrange(DOWN, buff=LARGE_BUFF)- groups.to_edge(LEFT)-- self.coord_groups = groups-- def introduce_coord_groups(self):- groups = self.coord_groups- x_group, p_group = groups- x_word = TextMobject("Positions")- p_word = TextMobject("Momenta")- words = VGroup(x_word, p_word)- for word, group in zip(words, groups):- word.next_to(group, UP)-- rect_groups = VGroup()- for group in groups:- rect_group = VGroup(*[- SurroundingRectangle(- VGroup(*[- tm.coords[i]- for tm in group- ]),- color=WHITE,- stroke_width=2,- )- for i in range(3)- ])- rect_groups.add(rect_group)-- self.play(- *[- LaggedStartMap(- FadeInFrom, group,- lambda m: (m, UP),- run_time=1,- )- for group in groups- ],- *map(FadeInFromDown, words),- )- for rect_group in rect_groups:- self.play(- ShowCreationThenFadeOut(- rect_group,- lag_ratio=0.5,- )- )- self.wait()-- def count_coords(self):- coord_copies = VGroup()- for group in self.coord_groups:- for tex_mob in group:- for coord in tex_mob.coords:- coord_copy = coord.copy()- coord_copy.set_stroke(- WHITE, 2, background=True- )- coord_copies.add(coord_copy)-- count = Integer()- count_word = TextMobject("18", "degrees \\\\ of freedom")[1]- count_group = VGroup(count, count_word)- count_group.arrange(- RIGHT,- aligned_edge=DOWN,- )- count_group.scale(1.5)- count_group.next_to(- self.coord_groups, RIGHT,- aligned_edge=DOWN,- )- count.add_updater(- lambda m: m.set_value(len(coord_copies))- )- count.add_updater(- lambda m: m.next_to(count_word[0][0], LEFT, aligned_edge=DOWN)- )-- self.add(count_group)- self.play(- # ChangeDecimalToValue(count, len(coord_copies)),- ShowIncreasingSubsets(coord_copies),- run_time=1.5,- rate_func=linear,- )- self.play(FadeOut(coord_copies))---class ThreeBodyEquation(Scene):- def construct(self):- x1 = "\\vec{\\textbf{x}}_1"- x2 = "\\vec{\\textbf{x}}_2"- x3 = "\\vec{\\textbf{x}}_3"- kw = {- "tex_to_color_map": {- x1: RED,- x2: GREEN,- x3: BLUE,- }- }- equations = VGroup(*[- TexMobject(- "{d^2", t1, "\\over dt^2}", "=",- "G", "\\left("- "{" + m2, "(", t2, "-", t1, ")"- "\\over"- "||", t2, "-", t1, "||^3}",- "+",- "{" + m3, "(", t3, "-", t1, ")"- "\\over"- "||", t3, "-", t1, "||^3}",- "\\right)",- **kw- )- for t1, t2, t3, m1, m2, m3 in [- (x1, x2, x3, "m_1", "m_2", "m_3"),- (x2, x3, x1, "m_2", "m_3", "m_1"),- (x3, x1, x2, "m_3", "m_1", "m_2"),- ]- ])- equations.arrange(DOWN, buff=LARGE_BUFF)-- self.play(LaggedStartMap(- FadeInFrom, equations,- lambda m: (m, UP),- lag_ratio=0.2,- ))- self.wait()---class JumpToThisPoint(Scene):- def construct(self):- dot = Dot(color=YELLOW)- dot.scale(0.5)-- arrow = Vector(DR, color=WHITE)- arrow.next_to(dot, UL, SMALL_BUFF)- words = TextMobject(- "Jump directly to\\\\",- "this point?",- )- words.add_background_rectangle_to_submobjects()- words.next_to(arrow.get_start(), UP, SMALL_BUFF)-- self.play(- FadeInFromLarge(dot, 20),- rate_func=rush_into,- )- self.play(- GrowArrow(arrow),- FadeInFromDown(words),- )---class ChaosTitle(Scene):- def construct(self):- title = TextMobject("Chaos theory")- title.scale(1.5)- title.to_edge(UP)- line = Line(LEFT, RIGHT)- line.set_width(FRAME_WIDTH - 1)- line.next_to(title, DOWN)-- self.play(- Write(title),- ShowCreation(line),- )- self.wait()---class RevisitQuote(StrogatzQuote, PiCreatureScene):- def construct(self):- quote = self.get_quote()- quote.law_part.set_color(YELLOW)- quote.language_part.set_color(BLUE)- quote.set_stroke(BLACK, 6, background=True)- quote.scale(0.8, about_edge=UL)-- new_langauge_part = TextMobject(- "\\Large Language of differential equations"- )- new_langauge_part.to_edge(UP)- new_langauge_part.match_style(quote.language_part)-- randy = self.pi_creature-- self.play(- FadeInFrom(quote[:-1], DOWN),- FadeInFrom(quote[-1:], LEFT),- randy.change, "raise_right_hand",- )- self.play(Blink(randy))- self.play(randy.change, "angry")- self.play(- Blink(randy),- VFadeOut(randy, run_time=3)- )- mover = VGroup(quote.language_part)- self.add(quote, mover)- self.play(- ReplacementTransform(- mover, new_langauge_part,- ),- *[- FadeOut(part)- for part in quote- if part is not quote.language_part- ],- run_time=2,- )- self.wait()---class EndScreen(PatreonEndScreen):- CONFIG = {- "specific_patrons": [- "Juan Benet",- "Vassili Philippov",- "Burt Humburg",- "Carlos Vergara Del Rio",- "Matt Russell",- "Scott Gray",- "soekul",- "Tihan Seale",- "Ali Yahya",- "dave nicponski",- "Evan Phillips",- "Graham",- "Joseph Kelly",- "Kaustuv DeBiswas",- "LambdaLabs",- "Lukas Biewald",- "Mike Coleman",- "Peter Mcinerney",- "Quantopian",- "Roy Larson",- "Scott Walter, Ph.D.",- "Yana Chernobilsky",- "Yu Jun",- "Jordan Scales",- "Lukas -krtek.net- Novy",- "John Shaughnessy",- "Britt Selvitelle",- "David Gow",- "J",- "Jonathan Wilson",- "Joseph John Cox",- "Magnus Dahlström",- "Randy C. Will",- "Ryan Atallah",- "Luc Ritchie",- "1stViewMaths",- "Adrian Robinson",- "Alexis Olson",- "Andreas Benjamin Brössel",- "Andrew Busey",- "Ankalagon",- "Antonio Juarez",- "Arjun Chakroborty",- "Art Ianuzzi",- "Awoo",- "Bernd Sing",- "Boris Veselinovich",- "Brian Staroselsky",- "Chad Hurst",- "Charles Southerland",- "Chris Connett",- "Christian Kaiser",- "Clark Gaebel",- "Cooper Jones",- "Danger Dai",- "Dave B",- "Dave Kester",- "David Clark",- "DeathByShrimp",- "Delton Ding",- "eaglle",- "emptymachine",- "Eric Younge",- "Eryq Ouithaqueue",- "Federico Lebron",- "Giovanni Filippi",- "Hal Hildebrand",- "Herman Dieset",- "Hitoshi Yamauchi",- "Isaac Jeffrey Lee",- "j eduardo perez",- "Jacob Magnuson",- "Jameel Syed",- "Jason Hise",- "Jeff Linse",- "Jeff Straathof",- "John Griffith",- "John Haley",- "John V Wertheim",- "Jonathan Eppele",- "Kai-Siang Ang",- "Kanan Gill",- "L0j1k",- "Lee Redden",- "Linh Tran",- "Ludwig Schubert",- "Magister Mugit",- "Mark B Bahu",- "Mark Heising",- "Martin Price",- "Mathias Jansson",- "Matt Langford",- "Matt Roveto",- "Matthew Cocke",- "Michael Faust",- "Michael Hardel",- "Mirik Gogri",- "Mustafa Mahdi",- "Márton Vaitkus",- "Nero Li",- "Nikita Lesnikov",- "Omar Zrien",- "Owen Campbell-Moore",- "Peter Ehrnstrom",- "RedAgent14",- "rehmi post",- "Richard Burgmann",- "Richard Comish",- "Ripta Pasay",- "Rish Kundalia",- "Robert Teed",- "Roobie",- "Ryan Williams",- "Samuel D. Judge",- "Solara570",- "Stevie Metke",- "Tal Einav",- "Ted Suzman",- "Valeriy Skobelev",- "Xavier Bernard",- "Yavor Ivanov",- "Yaw Etse",- "YinYangBalance.Asia",- "Zach Cardwell",- ]- }diff --git a/active_projects/ode/part2/fourier_series.py b/active_projects/ode/part2/fourier_series.pydeleted file mode 100644index 6a85ebfcf..000000000--- a/active_projects/ode/part2/fourier_series.py+++ /dev/null@@ -1,898 +0,0 @@-from manimlib.imports import *-# import scipy---class FourierCirclesScene(Scene):- CONFIG = {- "n_vectors": 10,- "big_radius": 2,- "colors": [- BLUE_D,- BLUE_C,- BLUE_E,- GREY_BROWN,- ],- "circle_style": {- "stroke_width": 2,- },- "vector_config": {- "buff": 0,- "max_tip_length_to_length_ratio": 0.35,- "tip_length": 0.15,- "max_stroke_width_to_length_ratio": 10,- "stroke_width": 2,- },- "circle_config": {- "stroke_width": 1,- },- "base_frequency": 1,- "slow_factor": 0.25,- "center_point": ORIGIN,- "parametric_function_step_size": 0.001,- }-- def setup(self):- self.slow_factor_tracker = ValueTracker(- self.slow_factor- )- self.vector_clock = ValueTracker(0)- self.vector_clock.add_updater(- lambda m, dt: m.increment_value(- self.get_slow_factor() * dt- )- )- self.add(self.vector_clock)-- def get_slow_factor(self):- return self.slow_factor_tracker.get_value()-- def get_vector_time(self):- return self.vector_clock.get_value()-- #- def get_freqs(self):- n = self.n_vectors- all_freqs = list(range(n // 2, -n // 2, -1))- all_freqs.sort(key=abs)- return all_freqs-- def get_coefficients(self):- return [complex(0) for x in range(self.n_vectors)]-- def get_color_iterator(self):- return it.cycle(self.colors)-- def get_rotating_vectors(self, freqs=None, coefficients=None):- vectors = VGroup()- self.center_tracker = VectorizedPoint(self.center_point)-- if freqs is None:- freqs = self.get_freqs()- if coefficients is None:- coefficients = self.get_coefficients()-- last_vector = None- for freq, coefficient in zip(freqs, coefficients):- if last_vector:- center_func = last_vector.get_end- else:- center_func = self.center_tracker.get_location- vector = self.get_rotating_vector(- coefficient=coefficient,- freq=freq,- center_func=center_func,- )- vectors.add(vector)- last_vector = vector- return vectors-- def get_rotating_vector(self, coefficient, freq, center_func):- vector = Vector(RIGHT, **self.vector_config)- vector.scale(abs(coefficient))- if abs(coefficient) == 0:- phase = 0- else:- phase = np.log(coefficient).imag- vector.rotate(phase, about_point=ORIGIN)- vector.freq = freq- vector.phase = phase- vector.coefficient = coefficient- vector.center_func = center_func- vector.add_updater(self.update_vector)- return vector-- def update_vector(self, vector, dt):- time = self.get_vector_time()- vector.set_angle(- vector.phase + time * vector.freq * TAU- )- vector.shift(- vector.center_func() - vector.get_start()- )- return vector-- def get_circles(self, vectors):- return VGroup(*[- self.get_circle(- vector,- color=color- )- for vector, color in zip(- vectors,- self.get_color_iterator()- )- ])-- def get_circle(self, vector, color=BLUE):- circle = Circle(color=color, **self.circle_config)- circle.center_func = vector.get_start- circle.radius_func = vector.get_length- circle.add_updater(self.update_circle)- return circle-- def update_circle(self, circle):- circle.set_width(2 * circle.radius_func())- circle.move_to(circle.center_func())- return circle-- def get_vector_sum_path(self, vectors, color=YELLOW):- coefs = [v.coefficient for v in vectors]- freqs = [v.freq for v in vectors]- center = vectors[0].get_start()-- path = ParametricFunction(- lambda t: center + reduce(op.add, [- complex_to_R3(- coef * np.exp(TAU * 1j * freq * t)- )- for coef, freq in zip(coefs, freqs)- ]),- t_min=0,- t_max=1,- color=color,- step_size=self.parametric_function_step_size,- )- return path-- # TODO, this should be a general animated mobect- def get_drawn_path(self, vectors, stroke_width=2, **kwargs):- path = self.get_vector_sum_path(vectors, **kwargs)- broken_path = CurvesAsSubmobjects(path)- broken_path.curr_time = 0-- def update_path(path, dt):- # alpha = path.curr_time * self.get_slow_factor()- alpha = self.get_vector_time()- n_curves = len(path)- for a, sp in zip(np.linspace(0, 1, n_curves), path):- b = alpha - a- if b < 0:- width = 0- else:- width = stroke_width * (1 - (b % 1))- sp.set_stroke(width=width)- path.curr_time += dt- return path-- broken_path.set_color(YELLOW)- broken_path.add_updater(update_path)- return broken_path-- def get_y_component_wave(self,- vectors,- left_x=1,- color=PINK,- n_copies=2,- right_shift_rate=5):- path = self.get_vector_sum_path(vectors)- wave = ParametricFunction(- lambda t: op.add(- right_shift_rate * t * LEFT,- path.function(t)[1] * UP- ),- t_min=path.t_min,- t_max=path.t_max,- color=color,- )- wave_copies = VGroup(*[- wave.copy()- for x in range(n_copies)- ])- wave_copies.arrange(RIGHT, buff=0)- top_point = wave_copies.get_top()- wave.creation = ShowCreation(- wave,- run_time=(1 / self.get_slow_factor()),- rate_func=linear,- )- cycle_animation(wave.creation)- wave.add_updater(lambda m: m.shift(- (m.get_left()[0] - left_x) * LEFT- ))-- def update_wave_copies(wcs):- index = int(- wave.creation.total_time * self.get_slow_factor()- )- wcs[:index].match_style(wave)- wcs[index:].set_stroke(width=0)- wcs.next_to(wave, RIGHT, buff=0)- wcs.align_to(top_point, UP)- wave_copies.add_updater(update_wave_copies)-- return VGroup(wave, wave_copies)-- def get_wave_y_line(self, vectors, wave):- return DashedLine(- vectors[-1].get_end(),- wave[0].get_end(),- stroke_width=1,- dash_length=DEFAULT_DASH_LENGTH * 0.5,- )-- # Computing Fourier series- # i.e. where all the math happens- def get_coefficients_of_path(self, path, n_samples=10000, freqs=None):- if freqs is None:- freqs = self.get_freqs()- dt = 1 / n_samples- ts = np.arange(0, 1, dt)- samples = np.array([- path.point_from_proportion(t)- for t in ts- ])- samples -= self.center_point- complex_samples = samples[:, 0] + 1j * samples[:, 1]-- result = []- for freq in freqs:- riemann_sum = np.array([- np.exp(-TAU * 1j * freq * t) * cs- for t, cs in zip(ts, complex_samples)- ]).sum() * dt- result.append(riemann_sum)-- return result---class FourierSeriesIntroBackground4(FourierCirclesScene):- CONFIG = {- "n_vectors": 4,- "center_point": 4 * LEFT,- "run_time": 30,- "big_radius": 1.5,- }-- def construct(self):- circles = self.get_circles()- path = self.get_drawn_path(circles)- wave = self.get_y_component_wave(circles)- h_line = always_redraw(- lambda: self.get_wave_y_line(circles, wave)- )-- # Why?- circles.update(-1 / self.camera.frame_rate)- #- self.add(circles, path, wave, h_line)- self.wait(self.run_time)-- def get_ks(self):- return np.arange(1, 2 * self.n_vectors + 1, 2)-- def get_freqs(self):- return self.base_frequency * self.get_ks()-- def get_coefficients(self):- return self.big_radius / self.get_ks()---class FourierSeriesIntroBackground8(FourierSeriesIntroBackground4):- CONFIG = {- "n_vectors": 8,- }---class FourierSeriesIntroBackground12(FourierSeriesIntroBackground4):- CONFIG = {- "n_vectors": 12,- }---class FourierSeriesIntroBackground20(FourierSeriesIntroBackground4):- CONFIG = {- "n_vectors": 20,- }---class FourierOfPiSymbol(FourierCirclesScene):- CONFIG = {- "n_vectors": 51,- "center_point": ORIGIN,- "slow_factor": 0.1,- "n_cycles": 1,- "tex": "\\pi",- "start_drawn": False,- "max_circle_stroke_width": 1,- }-- def construct(self):- self.add_vectors_circles_path()- for n in range(self.n_cycles):- self.run_one_cycle()-- def add_vectors_circles_path(self):- path = self.get_path()- coefs = self.get_coefficients_of_path(path)- vectors = self.get_rotating_vectors(coefficients=coefs)- circles = self.get_circles(vectors)- self.set_decreasing_stroke_widths(circles)- # approx_path = self.get_vector_sum_path(circles)- drawn_path = self.get_drawn_path(vectors)- if self.start_drawn:- self.vector_clock.increment_value(1)-- self.add(path)- self.add(vectors)- self.add(circles)- self.add(drawn_path)-- self.vectors = vectors- self.circles = circles- self.path = path- self.drawn_path = drawn_path-- def run_one_cycle(self):- time = 1 / self.slow_factor- self.wait(time)-- def set_decreasing_stroke_widths(self, circles):- mcsw = self.max_circle_stroke_width- for k, circle in zip(it.count(1), circles):- circle.set_stroke(width=max(- # mcsw / np.sqrt(k),- mcsw / k,- mcsw,- ))- return circles-- def get_path(self):- tex_mob = TexMobject(self.tex)- tex_mob.set_height(6)- path = tex_mob.family_members_with_points()[0]- path.set_fill(opacity=0)- path.set_stroke(WHITE, 1)- return path---class FourierOfName(FourierOfPiSymbol):- CONFIG = {- "n_vectors": 100,- "name_color": WHITE,- "name_text": "Abc",- "time_per_symbol": 5,- "slow_factor": 1 / 5,- }-- def construct(self):- name = TextMobject(self.name_text)- max_width = FRAME_WIDTH - 2- max_height = FRAME_HEIGHT - 2- name.set_width(max_width)- if name.get_height() > max_height:- name.set_height(max_height)-- circles = VGroup(VectorizedPoint())- for path in name.family_members_with_points():- for subpath in path.get_subpaths():- sp_mob = VMobject()- sp_mob.set_points(subpath)- coefs = self.get_coefficients_of_path(sp_mob)- new_circles = self.get_circles(- coefficients=coefs- )- self.set_decreasing_stroke_widths(new_circles)- drawn_path = self.get_drawn_path(new_circles)- drawn_path.clear_updaters()- drawn_path.set_stroke(self.name_color, 3)-- new_circles.suspend_updating()- self.play(ReplacementTransform(circles, new_circles))- new_circles.resume_updating()- circles = new_circles- self.play(- ShowCreation(drawn_path),- rate_func=linear,- run_time=self.time_per_symbol- )- circles.suspend_updating()- self.play(FadeOut(circles))- self.wait(3)---class FourierOfPiSymbol5(FourierOfPiSymbol):- CONFIG = {- "n_vectors": 5,- "run_time": 10,- }---class FourierOfTrebleClef(FourierOfPiSymbol):- CONFIG = {- "n_vectors": 101,- "run_time": 10,- "start_drawn": True,- "file_name": "TrebleClef",- "height": 7.5,- }-- def get_shape(self):- shape = SVGMobject(self.file_name)- return shape-- def get_path(self):- shape = self.get_shape()- path = shape.family_members_with_points()[0]- path.set_height(self.height)- path.set_fill(opacity=0)- path.set_stroke(WHITE, 0)- return path---class FourierOfIP(FourierOfTrebleClef):- CONFIG = {- "file_name": "IP_logo2",- "height": 6,- "n_vectors": 100,- }-- # def construct(self):- # path = self.get_path()- # self.add(path)-- def get_shape(self):- shape = SVGMobject(self.file_name)- return shape-- def get_path(self):- shape = self.get_shape()- path = shape.family_members_with_points()[0]- path.add_line_to(path.get_start())- # path.make_smooth()-- path.set_height(self.height)- path.set_fill(opacity=0)- path.set_stroke(WHITE, 0)- return path---class FourierOfEighthNote(FourierOfTrebleClef):- CONFIG = {- "file_name": "EighthNote"- }---class FourierOfN(FourierOfTrebleClef):- CONFIG = {- "height": 6,- "n_vectors": 1000,- }-- def get_shape(self):- return TexMobject("N")---class FourierNailAndGear(FourierOfTrebleClef):- CONFIG = {- "height": 6,- "n_vectors": 200,- "run_time": 100,- "slow_factor": 0.01,- "parametric_function_step_size": 0.0001,- "arrow_config": {- "tip_length": 0.1,- "stroke_width": 2,- }- }-- def get_shape(self):- shape = SVGMobject("Nail_And_Gear")[1]- return shape---class FourierBatman(FourierOfTrebleClef):- CONFIG = {- "height": 4,- "n_vectors": 100,- "run_time": 10,- "arrow_config": {- "tip_length": 0.1,- "stroke_width": 2,- }- }-- def get_shape(self):- shape = SVGMobject("BatmanLogo")[1]- return shape---class FourierHeart(FourierOfTrebleClef):- CONFIG = {- "height": 4,- "n_vectors": 100,- "run_time": 10,- "arrow_config": {- "tip_length": 0.1,- "stroke_width": 2,- }- }-- def get_shape(self):- shape = SuitSymbol("hearts")- return shape-- def get_drawn_path(self, *args, **kwargs):- kwargs["stroke_width"] = 5- path = super().get_drawn_path(*args, **kwargs)- path.set_color(PINK)- return path---class FourierNDQ(FourierOfTrebleClef):- CONFIG = {- "height": 4,- "n_vectors": 1000,- "run_time": 10,- "arrow_config": {- "tip_length": 0.1,- "stroke_width": 2,- }- }-- def get_shape(self):- path = VMobject()- shape = TexMobject("NDQ")- for sp in shape.family_members_with_points():- path.append_points(sp.points)- return path---class FourierGoogleG(FourierOfTrebleClef):- CONFIG = {- "n_vectors": 10,- "height": 5,- "g_colors": [- "#4285F4",- "#DB4437",- "#F4B400",- "#0F9D58",- ]- }-- def get_shape(self):- g = SVGMobject("google_logo")[5]- g.center()- self.add(g)- return g-- def get_drawn_path(self, *args, **kwargs):- kwargs["stroke_width"] = 7- path = super().get_drawn_path(*args, **kwargs)-- blue, red, yellow, green = self.g_colors-- path[:250].set_color(blue)- path[250:333].set_color(green)- path[333:370].set_color(yellow)- path[370:755].set_color(red)- path[755:780].set_color(yellow)- path[780:860].set_color(green)- path[860:].set_color(blue)-- return path---class ExplainCircleAnimations(FourierCirclesScene):- CONFIG = {- "n_vectors": 100,- "center_point": 2 * DOWN,- "n_top_circles": 9,- "path_height": 3,- }-- def construct(self):- self.add_path()- self.add_circles()- self.wait(8)- self.organize_circles_in_a_row()- self.show_frequencies()- self.show_examples_for_frequencies()- self.show_as_vectors()- self.show_vector_sum()- self.tweak_starting_vectors()-- def add_path(self):- self.path = self.get_path()- self.add(self.path)-- def add_circles(self):- coefs = self.get_coefficients_of_path(self.path)- self.circles = self.get_circles(coefficients=coefs)-- self.add(self.circles)- self.drawn_path = self.get_drawn_path(self.circles)- self.add(self.drawn_path)-- def organize_circles_in_a_row(self):- circles = self.circles- top_circles = circles[:self.n_top_circles].copy()-- center_trackers = VGroup()- for circle in top_circles:- tracker = VectorizedPoint(circle.center_func())- circle.center_func = tracker.get_location- center_trackers.add(tracker)- tracker.freq = circle.freq- tracker.circle = circle-- center_trackers.submobjects.sort(- key=lambda m: m.freq- )- center_trackers.generate_target()- right_buff = 1.45- center_trackers.target.arrange(RIGHT, buff=right_buff)- center_trackers.target.to_edge(UP, buff=1.25)-- self.add(top_circles)- self.play(- MoveToTarget(center_trackers),- run_time=2- )- self.wait(4)-- self.top_circles = top_circles- self.center_trackers = center_trackers-- def show_frequencies(self):- center_trackers = self.center_trackers-- freq_numbers = VGroup()- for ct in center_trackers:- number = Integer(ct.freq)- number.next_to(ct, DOWN, buff=1)- freq_numbers.add(number)- ct.circle.number = number-- ld, rd = [- TexMobject("\\dots")- for x in range(2)- ]- ld.next_to(freq_numbers, LEFT, MED_LARGE_BUFF)- rd.next_to(freq_numbers, RIGHT, MED_LARGE_BUFF)- freq_numbers.add_to_back(ld)- freq_numbers.add(rd)-- freq_word = TextMobject("Frequencies")- freq_word.scale(1.5)- freq_word.set_color(YELLOW)- freq_word.next_to(freq_numbers, DOWN, MED_LARGE_BUFF)-- self.play(- LaggedStartMap(- FadeInFromDown, freq_numbers- )- )- self.play(- Write(freq_word),- LaggedStartMap(- ShowCreationThenFadeAround, freq_numbers,- )- )- self.wait(2)-- self.freq_numbers = freq_numbers- self.freq_word = freq_word-- def show_examples_for_frequencies(self):- top_circles = self.top_circles- c1, c2, c3 = [- list(filter(- lambda c: c.freq == k,- top_circles- ))[0]- for k in (1, 2, 3)- ]-- neg_circles = VGroup(*filter(- lambda c: c.freq < 0,- top_circles- ))-- for c in [c1, c2, c3, *neg_circles]:- c.rect = SurroundingRectangle(c)-- self.play(- ShowCreation(c2.rect),- WiggleOutThenIn(c2.number),- )- self.wait(2)- self.play(- ReplacementTransform(c2.rect, c1.rect),- )- self.play(FadeOut(c1.rect))- self.wait()- self.play(- ShowCreation(c3.rect),- WiggleOutThenIn(c3.number),- )- self.play(- FadeOut(c3.rect),- )- self.wait(2)- self.play(- LaggedStart(*[- ShowCreationThenFadeOut(c.rect)- for c in neg_circles- ])- )- self.wait(3)- self.play(FadeOut(self.freq_word))-- def show_as_vectors(self):- top_circles = self.top_circles- top_vectors = self.get_rotating_vectors(top_circles)- top_vectors.set_color(WHITE)-- original_circles = top_circles.copy()- self.play(- FadeIn(top_vectors),- top_circles.set_opacity, 0,- )- self.wait(3)- self.play(- top_circles.match_style, original_circles- )- self.remove(top_vectors)-- self.top_vectors = top_vectors-- def show_vector_sum(self):- trackers = self.center_trackers.copy()- trackers.sort(- submob_func=lambda t: abs(t.circle.freq - 0.1)- )- plane = self.plane = NumberPlane(- x_min=-3,- x_max=3,- y_min=-2,- y_max=2,- axis_config={- "stroke_color": LIGHT_GREY,- }- )- plane.set_stroke(width=1)- plane.fade(0.5)- plane.move_to(self.center_point)-- self.play(- FadeOut(self.drawn_path),- FadeOut(self.circles),- self.slow_factor_tracker.set_value, 0.05,- )- self.add(plane, self.path)- self.play(FadeIn(plane))-- new_circles = VGroup()- last_tracker = None- for tracker in trackers:- if last_tracker:- tracker.new_location_func = last_tracker.circle.get_start- else:- tracker.new_location_func = lambda: self.center_point-- original_circle = tracker.circle- tracker.circle = original_circle.copy()- tracker.circle.center_func = tracker.get_location- new_circles.add(tracker.circle)-- self.add(tracker, tracker.circle)- start_point = tracker.get_location()- self.play(- UpdateFromAlphaFunc(- tracker, lambda t, a: t.move_to(- interpolate(- start_point,- tracker.new_location_func(),- a,- )- ),- run_time=2- )- )- tracker.add_updater(lambda t: t.move_to(- t.new_location_func()- ))- self.wait(2)- last_tracker = tracker-- self.wait(3)-- self.clear()- self.slow_factor_tracker.set_value(0.1)- self.add(- self.top_circles,- self.freq_numbers,- self.path,- )- self.add_circles()- for tc in self.top_circles:- for c in self.circles:- if c.freq == tc.freq:- tc.rotate(- angle_of_vector(c.get_start() - c.get_center()) -- angle_of_vector(tc.get_start() - tc.get_center())- )- self.wait(10)-- def tweak_starting_vectors(self):- top_circles = self.top_circles- circles = self.circles- path = self.path- drawn_path = self.drawn_path-- new_path = self.get_new_path()- new_coefs = self.get_coefficients_of_path(new_path)- new_circles = self.get_circles(coefficients=new_coefs)-- new_top_circles = VGroup()- new_top_vectors = VGroup()- for top_circle in top_circles:- for circle in new_circles:- if circle.freq == top_circle.freq:- new_top_circle = circle.copy()- new_top_circle.center_func = top_circle.get_center- new_top_vector = self.get_rotating_vector(- new_top_circle- )- new_top_circles.add(new_top_circle)- new_top_vectors.add(new_top_vector)-- self.play(- self.slow_factor_tracker.set_value, 0,- FadeOut(drawn_path)- )- self.wait()- self.play(- ReplacementTransform(top_circles, new_top_circles),- ReplacementTransform(circles, new_circles),- FadeOut(path),- run_time=3,- )- new_drawn_path = self.get_drawn_path(- new_circles, stroke_width=4,- )- self.add(new_drawn_path)- self.slow_factor_tracker.set_value(0.1)- self.wait(20)-- #- def configure_path(self, path):- path.set_stroke(WHITE, 1)- path.set_fill(BLACK, opacity=1)- path.set_height(self.path_height)- path.move_to(self.center_point)- return path-- def get_path(self):- tex = TexMobject("f")- path = tex.family_members_with_points()[0]- self.configure_path(path)- return path- # return Square().set_height(3)-- def get_new_path(self):- shape = SVGMobject("TrebleClef")- path = shape.family_members_with_points()[0]- self.configure_path(path)- path.scale(1.5, about_edge=DOWN)- return pathdiff --git a/active_projects/ode/part2/heat_equation.py b/active_projects/ode/part2/heat_equation.pydeleted file mode 100644index f50c1f415..000000000--- a/active_projects/ode/part2/heat_equation.py+++ /dev/null@@ -1,2969 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part2.shared_constructs import *---class TwoDBodyWithManyTemperatures(ThreeDScene):- CONFIG = {- "cells_per_side": 20,- "body_height": 6,- }-- def construct(self):- self.introduce_body()- self.show_temperature_at_all_points()-- def introduce_body(self):- height = self.body_height- buff = 0.025- rows = VGroup(*[- VGroup(*[- Dot(- # stroke_width=0.5,- stroke_width=0,- fill_opacity=1,- )- for x in range(self.cells_per_side)- ]).arrange(RIGHT, buff=buff)- for y in range(self.cells_per_side)- ]).arrange(DOWN, buff=buff)- for row in rows[1::2]:- row.submobjects.reverse()-- body = self.body = VGroup(*it.chain(*rows))- body.set_height(height)- body.center()- body.to_edge(LEFT)-- axes = self.axes = Axes(- x_min=-5, x_max=5,- y_min=-5, y_max=5,- )- axes.match_height(body)- axes.move_to(body)-- for cell in body:- self.color_cell(cell)- # body.set_stroke(WHITE, 0.5) # Do this?-- plate = Square(- stroke_width=0,- fill_color=DARK_GREY,- sheen_direction=UL,- sheen_factor=1,- fill_opacity=1,- )- plate.replace(body)-- plate_words = TextMobject("Piece of \\\\ metal")- plate_words.scale(2)- plate_words.set_stroke(BLACK, 2, background=True)- plate_words.set_color(BLACK)- plate_words.move_to(plate)-- self.play(- DrawBorderThenFill(plate),- Write(- plate_words,- run_time=2,- rate_func=squish_rate_func(smooth, 0.5, 1)- )- )- self.wait()-- self.remove(plate_words)-- def show_temperature_at_all_points(self):- body = self.body- start_corner = body[0].get_center()-- dot = Dot(radius=0.01, color=WHITE)- dot.move_to(start_corner)-- get_point = dot.get_center-- lhs = TexMobject("T = ")- lhs.next_to(body, RIGHT, LARGE_BUFF)-- decimal = DecimalNumber(- num_decimal_places=1,- unit="^\\circ"- )- decimal.next_to(lhs, RIGHT, MED_SMALL_BUFF, DOWN)- decimal.add_updater(- lambda d: d.set_value(- 40 + 50 * self.point_to_temp(get_point())- )- )-- arrow = Arrow(color=YELLOW)- arrow.set_stroke(BLACK, 8, background=True)- arrow.tip.set_stroke(BLACK, 2, background=True)- # arrow.add_to_back(arrow.copy().set_stroke(BLACK, 5))- arrow.add_updater(lambda a: a.put_start_and_end_on(- lhs.get_left() + MED_SMALL_BUFF * LEFT,- get_point(),- ))-- dot.add_updater(lambda p: p.move_to(- body[-1] if (1 < len(body)) else start_corner- ))- self.add(body, dot, lhs, decimal, arrow)- self.play(- ShowIncreasingSubsets(- body,- run_time=10,- rate_func=linear,- )- )- self.wait()- self.remove(dot)- self.play(- FadeOut(arrow),- FadeOut(lhs),- FadeOut(decimal),- )-- #- def point_to_temp(self, point, time=0):- x, y = self.axes.point_to_coords(point)- return two_d_temp_func(- 0.3 * x, 0.3 * y, t=time- )-- def color_cell(self, cell, vect=RIGHT):- p0 = cell.get_corner(-vect)- p1 = cell.get_corner(vect)- colors = []- for point in p0, p1:- temp = self.point_to_temp(point)- color = temperature_to_color(temp)- colors.append(color)- cell.set_color(color=colors)- cell.set_sheen_direction(vect)- return cell---class TwoDBodyWithManyTemperaturesGraph(ExternallyAnimatedScene):- pass---class TwoDBodyWithManyTemperaturesContour(ExternallyAnimatedScene):- pass---class BringTwoRodsTogether(Scene):- CONFIG = {- "step_size": 0.05,- "axes_config": {- "x_min": -1,- "x_max": 11,- "y_min": -10,- "y_max": 100,- "y_axis_config": {- "unit_size": 0.06,- "tick_frequency": 10,- },- },- "graph_x_min": 0,- "graph_x_max": 10,- "wait_time": 30,- "default_n_rod_pieces": 20,- "alpha": 1.0,- }-- def construct(self):- self.setup_axes()- self.setup_graph()- self.setup_clock()-- self.show_rods()- self.show_equilibration()-- def setup_axes(self):- axes = Axes(**self.axes_config)- axes.center().to_edge(UP)-- y_label = axes.get_y_axis_label("\\text{Temperature}")- y_label.to_edge(UP)- axes.y_axis.label = y_label- axes.y_axis.add(y_label)- axes.y_axis.add_numbers(- *range(20, 100, 20)- )-- self.axes = axes- self.y_label = y_label-- def setup_graph(self):- graph = self.axes.get_graph(- self.initial_function,- x_min=self.graph_x_min,- x_max=self.graph_x_max,- step_size=self.step_size,- discontinuities=[5],- )- graph.color_using_background_image("VerticalTempGradient")-- self.graph = graph-- def setup_clock(self):- clock = Clock()- clock.set_height(1)- clock.to_corner(UR)- clock.shift(MED_LARGE_BUFF * LEFT)-- time_lhs = TextMobject("Time: ")- time_label = DecimalNumber(- 0, num_decimal_places=2,- )- time_rhs = TextMobject("s")- time_group = VGroup(- time_lhs,- time_label,- # time_rhs- )- time_group.arrange(RIGHT, aligned_edge=DOWN)- time_rhs.shift(SMALL_BUFF * LEFT)- time_group.next_to(clock, DOWN)-- self.time_group = time_group- self.time_label = time_label- self.clock = clock-- def show_rods(self):- rod1, rod2 = rods = VGroup(- self.get_rod(0, 5),- self.get_rod(5, 10),- )- rod1.set_color(rod1[0].get_color())- rod2.set_color(rod2[-1].get_color())-- rods.save_state()- rods.space_out_submobjects(1.5)- rods.center()-- labels = VGroup(- TexMobject("90^\\circ"),- TexMobject("10^\\circ"),- )- for rod, label in zip(rods, labels):- label.next_to(rod, DOWN)- rod.label = label-- self.play(- FadeInFrom(rod1, UP),- Write(rod1.label),- )- self.play(- FadeInFrom(rod2, DOWN),- Write(rod2.label)- )- self.wait()-- self.rods = rods- self.rod_labels = labels-- def show_equilibration(self):- rods = self.rods- axes = self.axes- graph = self.graph- labels = self.rod_labels- self.play(- Write(axes),- rods.restore,- rods.space_out_submobjects, 1.1,- FadeIn(self.time_group),- FadeIn(self.clock),- *[- MaintainPositionRelativeTo(- rod.label, rod- )- for rod in rods- ],- )-- br1 = Rectangle(height=0.2, width=1)- br1.set_stroke(width=0)- br1.set_fill(BLACK, opacity=1)- br2 = br1.copy()- br1.add_updater(lambda b: b.move_to(axes.c2p(0, 90)))- br1.add_updater(- lambda b: b.align_to(rods[0].get_right(), LEFT)- )- br2.add_updater(lambda b: b.move_to(axes.c2p(0, 10)))- br2.add_updater(- lambda b: b.align_to(rods[1].get_left(), RIGHT)- )-- self.add(graph, br1, br2)- self.play(- ShowCreation(graph),- labels[0].align_to, axes.c2p(0, 87), UP,- labels[1].align_to, axes.c2p(0, 13), DOWN,- )- self.play()- self.play(- rods.restore,- rate_func=rush_into,- )- self.remove(br1, br2)-- graph.add_updater(self.update_graph)- self.time_label.add_updater(- lambda d, dt: d.increment_value(dt)- )- rods.add_updater(self.update_rods)-- self.play(- ClockPassesTime(- self.clock,- run_time=self.wait_time,- hours_passed=self.wait_time,- ),- FadeOut(labels)- )-- #- def initial_function(self, x):- if x <= 5:- return 90- else:- return 10-- def update_graph(self, graph, dt, alpha=None, n_mini_steps=500):- if alpha is None:- alpha = self.alpha- points = np.append(- graph.get_start_anchors(),- [graph.get_last_point()],- axis=0,- )- for k in range(n_mini_steps):- y_change = np.zeros(points.shape[0])- dx = points[1][0] - points[0][0]- for i in range(len(points)):- p = points[i]- lp = points[max(i - 1, 0)]- rp = points[min(i + 1, len(points) - 1)]- d2y = (rp[1] - 2 * p[1] + lp[1])-- if (0 < i < len(points) - 1):- second_deriv = d2y / (dx**2)- else:- second_deriv = 2 * d2y / (dx**2)- # second_deriv = 0-- y_change[i] = alpha * second_deriv * dt / n_mini_steps-- # y_change[0] = y_change[1]- # y_change[-1] = y_change[-2]- # y_change[0] = 0- # y_change[-1] = 0- # y_change -= np.mean(y_change)- points[:, 1] += y_change- graph.set_points_smoothly(points)- return graph-- def get_second_derivative(self, x, dx=0.001):- graph = self.graph- x_min = self.graph_x_min- x_max = self.graph_x_max-- ly, y, ry = [- graph.point_from_proportion(- inverse_interpolate(x_min, x_max, alt_x)- )[1]- for alt_x in (x - dx, x, x + dx)- ]-- # At the boundary, don't return the second deriv,- # but instead something matching the Neumann- # boundary condition.- if x == x_max:- return (ly - y) / dx- elif x == x_min:- return (ry - y) / dx- else:- d2y = ry - 2 * y + ly- return d2y / (dx**2)-- def get_rod(self, x_min, x_max, n_pieces=None):- if n_pieces is None:- n_pieces = self.default_n_rod_pieces- axes = self.axes- line = Line(axes.c2p(x_min, 0), axes.c2p(x_max, 0))- rod = VGroup(*[- Square()- for n in range(n_pieces)- ])- rod.arrange(RIGHT, buff=0)- rod.match_width(line)- rod.set_height(0.2, stretch=True)- rod.move_to(axes.c2p(x_min, 0), LEFT)- rod.set_fill(opacity=1)- rod.set_stroke(width=1)- rod.set_sheen_direction(RIGHT)- self.color_rod_by_graph(rod)- return rod-- def update_rods(self, rods):- for rod in rods:- self.color_rod_by_graph(rod)-- def color_rod_by_graph(self, rod):- for piece in rod:- piece.set_color(color=[- self.rod_point_to_color(piece.get_left()),- self.rod_point_to_color(piece.get_right()),- ])-- def rod_point_to_graph_y(self, point):- axes = self.axes- x = axes.x_axis.p2n(point)-- graph = self.graph- alpha = inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- x,- )- return axes.y_axis.p2n(- graph.point_from_proportion(alpha)- )-- def y_to_color(self, y):- return temperature_to_color((y - 45) / 45)-- def rod_point_to_color(self, point):- return self.y_to_color(- self.rod_point_to_graph_y(point)- )---class ShowEvolvingTempGraphWithArrows(BringTwoRodsTogether):- CONFIG = {- "alpha": 0.1,- "arrow_xs": np.linspace(0, 10, 22)[1:-1],- "arrow_scale_factor": 0.5,- "max_magnitude": 1.5,- "wait_time": 30,- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- (5, 0.3),- (7, 0.2),- (21, 0.1),- (41, 0.05),- ],- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_clock()- self.add_rod()- self.add_arrows()- self.initialize_updaters()- self.let_play()-- def add_axes(self):- self.setup_axes()- self.add(self.axes)-- def add_graph(self):- self.setup_graph()- self.add(self.graph)-- def add_clock(self):- self.setup_clock()- self.add(self.clock)- self.add(self.time_label)- self.time_label.next_to(self.clock, DOWN)-- def add_rod(self):- rod = self.rod = self.get_rod(- self.graph_x_min,- self.graph_x_max,- )- self.add(rod)-- def add_arrows(self):- graph = self.graph- x_min = self.graph_x_min- x_max = self.graph_x_max-- xs = self.arrow_xs- arrows = VGroup(*[Vector(DOWN) for x in xs])- asf = self.arrow_scale_factor-- def update_arrows(arrows):- for x, arrow in zip(xs, arrows):- d2y_dx2 = self.get_second_derivative(x)- mag = asf * np.sign(d2y_dx2) * abs(d2y_dx2)- mag = np.clip(- mag,- -self.max_magnitude,- self.max_magnitude,- )- arrow.put_start_and_end_on(- ORIGIN, mag * UP- )- point = graph.point_from_proportion(- inverse_interpolate(x_min, x_max, x)- )- arrow.shift(point - arrow.get_start())- arrow.set_color(- self.rod_point_to_color(point)- )-- arrows.add_updater(update_arrows)-- self.add(arrows)- self.arrows = arrows-- def initialize_updaters(self):- if hasattr(self, "graph"):- self.graph.add_updater(self.update_graph)- if hasattr(self, "rod"):- self.rod.add_updater(self.color_rod_by_graph)- if hasattr(self, "time_label"):- self.time_label.add_updater(- lambda d, dt: d.increment_value(dt)- )-- def let_play(self):- self.run_clock(self.wait_time)-- def run_clock(self, time):- self.play(- ClockPassesTime(- self.clock,- run_time=time,- hours_passed=time,- ),- )-- #- def temp_func(self, x, t):- new_x = TAU * x / 10- return 50 + 20 * np.sum([- amp * np.sin(freq * new_x) *- np.exp(-(self.alpha * freq**2) * t)- for freq, amp in self.freq_amplitude_pairs- ])-- def initial_function(self, x, time=0):- return self.temp_func(x, 0)---class TalkThrough1DHeatGraph(ShowEvolvingTempGraphWithArrows, SpecialThreeDScene):- CONFIG = {- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- (5, 0.3),- (7, 0.2),- ],- "surface_resolution": 20,- "graph_slice_step": 10 / 20,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_rod()-- self.emphasize_graph()- self.emphasize_rod()- self.show_x_axis()- self.show_changes_over_time()- self.show_surface()-- def add_graph(self):- self.graph = self.get_graph()- self.add(self.graph)-- def emphasize_graph(self):- graph = self.graph- q_marks = VGroup(*[- TexMobject("?").move_to(- graph.point_from_proportion(a),- UP,- ).set_stroke(BLACK, 3, background=True)- for a in np.linspace(0, 1, 20)- ])-- self.play(LaggedStart(*[- Succession(- FadeInFromLarge(q_mark),- FadeOutAndShift(q_mark, DOWN),- )- for q_mark in q_marks- ]))- self.wait()-- def emphasize_rod(self):- alt_rod = self.get_rod(0, 10, 50)- word = TextMobject("Rod")- word.scale(2)- word.next_to(alt_rod, UP, MED_SMALL_BUFF)-- self.play(- LaggedStart(- *[- Rotating(piece, rate_func=smooth)- for piece in alt_rod- ],- run_time=2,- lag_ratio=0.01,- ),- Write(word)- )- self.remove(*alt_rod)- self.wait()-- self.rod_word = word-- def show_x_axis(self):- rod = self.rod- axes = self.axes- graph = self.graph- x_axis = axes.x_axis- x_numbers = x_axis.get_number_mobjects(*range(1, 11))- x_axis_label = TexMobject("x")- x_axis_label.next_to(x_axis.get_right(), UP)-- self.play(- rod.set_opacity, 0.5,- FadeInFrom(x_axis_label, UL),- LaggedStartMap(- FadeInFrom, x_numbers,- lambda m: (m, UP),- )- )- self.wait()-- # Show x-values- triangle = ArrowTip(- start_angle=-90 * DEGREES,- color=LIGHT_GREY,- )- x_tracker = ValueTracker(PI)- get_x = x_tracker.get_value-- def get_x_point():- return x_axis.n2p(get_x())-- def get_graph_point():- return graph.point_from_proportion(- inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- get_x(),- )- )-- triangle.add_updater(- lambda t: t.next_to(get_x_point(), UP)- )- x_label = VGroup(- TexMobject("x"),- TexMobject("="),- DecimalNumber(- 0,- num_decimal_places=3,- include_background_rectangle=True,- ).scale(0.9)- )- x_label.set_stroke(BLACK, 5, background=True)- x_label.add_updater(lambda m: m[-1].set_value(get_x()))- x_label.add_updater(lambda m: m.arrange(RIGHT, buff=SMALL_BUFF))- x_label.add_updater(lambda m: m[-1].align_to(m[0], DOWN))- x_label.add_updater(lambda m: m.next_to(triangle, UP, SMALL_BUFF))- x_label.add_updater(lambda m: m.shift(SMALL_BUFF * RIGHT))- rod_piece = always_redraw(- lambda: self.get_rod(- get_x() - 0.05, get_x() + 0.05,- n_pieces=1,- )- )-- self.play(- FadeInFrom(triangle, UP),- FadeIn(x_label),- FadeIn(rod_piece),- FadeOut(self.rod_word),- )- for value in [np.exp(2), (np.sqrt(5) + 1) / 2]:- self.play(x_tracker.set_value, value, run_time=2)- self.wait()-- # Show graph- v_line = always_redraw(- lambda: DashedLine(- get_x_point(),- get_graph_point(),- color=self.rod_point_to_color(get_x_point()),- )- )- graph_dot = Dot()- graph_dot.add_updater(- lambda m: m.set_color(- self.rod_point_to_color(m.get_center())- )- )- graph_dot.add_updater(- lambda m: m.move_to(get_graph_point())- )- t_label = TexMobject("T(", "x", ")")- t_label.set_stroke(BLACK, 3, background=True)- t_label.add_updater(- lambda m: m.next_to(graph_dot, UR, buff=0)- )-- self.add(v_line, rod_piece, x_label, triangle)- self.play(- TransformFromCopy(x_label[0], t_label[1]),- FadeIn(t_label[0::2]),- ShowCreation(v_line),- GrowFromPoint(graph_dot, get_x_point()),- )- self.add(t_label)- self.wait()- self.play(- x_tracker.set_value, TAU,- run_time=5,- )-- self.x_tracker = x_tracker- self.graph_label_group = VGroup(- v_line, rod_piece, triangle, x_label,- graph_dot, t_label,- )- self.set_variables_as_attrs(*self.graph_label_group)- self.set_variables_as_attrs(x_numbers, x_axis_label)-- def show_changes_over_time(self):- graph = self.graph- t_label = self.t_label- new_t_label = TexMobject("T(", "x", ",", "t", ")")- new_t_label.set_color_by_tex("t", YELLOW)- new_t_label.match_updaters(t_label)-- self.setup_clock()- clock = self.clock- time_label = self.time_label- time_group = self.time_group-- time = 5- self.play(- FadeIn(clock),- FadeIn(time_group),- )- self.play(- self.get_graph_time_change_animation(- graph, time- ),- ClockPassesTime(clock),- ChangeDecimalToValue(- time_label, time,- rate_func=linear,- ),- ReplacementTransform(- t_label,- new_t_label,- rate_func=squish_rate_func(smooth, 0.5, 0.7),- ),- run_time=time- )- self.play(- ShowCreationThenFadeAround(- new_t_label.get_part_by_tex("t")- ),- )- self.wait()- self.play(- FadeOut(clock),- ChangeDecimalToValue(time_label, 0),- VFadeOut(time_group),- self.get_graph_time_change_animation(- graph,- new_time=0,- ),- run_time=1,- rate_func=smooth,- )-- self.graph_label_group.remove(t_label)- self.graph_label_group.add(new_t_label)-- def show_surface(self):- axes = self.axes- graph = self.graph- t_min = 0- t_max = 10-- axes_copy = axes.deepcopy()- self.original_axes = self.axes-- # Set rod final state- final_graph = self.get_graph(t_max)- curr_graph = self.graph- self.graph = final_graph- final_rod = self.rod.copy()- final_rod.set_opacity(1)- self.color_rod_by_graph(final_rod)- self.graph = curr_graph-- # Time axis- t_axis = NumberLine(- x_min=t_min,- x_max=t_max,- )- origin = axes.c2p(0, 0)- t_axis.shift(origin - t_axis.n2p(0))- t_axis.add_numbers(- *range(1, t_max + 1),- direction=UP,- )- time_label = TextMobject("Time")- time_label.scale(1.5)- time_label.next_to(t_axis, UP)- t_axis.time_label = time_label- t_axis.add(time_label)- # t_axis.rotate(90 * DEGREES, LEFT, about_point=origin)- t_axis.rotate(90 * DEGREES, UP, about_point=origin)-- # New parts of graph- step = self.graph_slice_step- graph_slices = VGroup(*[- self.get_graph(time=t).shift(- t * IN- )- for t in np.arange(0, t_max + step, step)- ])- graph_slices.set_stroke(width=1)- graph_slices.set_shade_in_3d(True)-- # Input plane- x_axis = self.axes.x_axis- y = axes.c2p(0, 0)[1]- surface_config = {- "u_min": self.graph_x_min,- "u_max": self.graph_x_max,- "v_min": t_min,- "v_max": t_max,- "resolution": self.surface_resolution,- }- input_plane = ParametricSurface(- lambda x, t: np.array([- x_axis.n2p(x)[0],- y,- t_axis.n2p(t)[2],- ]),- **surface_config,- )- input_plane.set_style(- fill_opacity=0.5,- fill_color=BLUE_B,- stroke_width=0.5,- stroke_color=WHITE,- )-- # Surface- y_axis = axes.y_axis- surface = ParametricSurface(- lambda x, t: np.array([- x_axis.n2p(x)[0],- y_axis.n2p(self.temp_func(x, t))[1],- t_axis.n2p(t)[2],- ]),- **surface_config,- )- surface.set_style(- fill_opacity=0.1,- fill_color=LIGHT_GREY,- stroke_width=0.5,- stroke_color=WHITE,- stroke_opacity=0.5,- )-- # Rotate everything on screen and move camera- # in such a way that it looks the same- curr_group = Group(*self.get_mobjects())- curr_group.clear_updaters()- self.set_camera_orientation(- phi=90 * DEGREES,- )- mobs = [- curr_group,- graph_slices,- t_axis,- input_plane,- surface,- ]- for mob in mobs:- self.orient_mobject_for_3d(mob)-- # Clean current mobjects- self.x_label.set_stroke(BLACK, 2, background=True)- self.x_label[-1][0].fade(1)-- self.move_camera(- phi=80 * DEGREES,- theta=-85 * DEGREES,- added_anims=[- Write(input_plane),- Write(t_axis),- FadeOut(self.graph_label_group),- self.rod.set_opacity, 1,- ]- )- self.begin_ambient_camera_rotation()- self.add(*graph_slices, *self.get_mobjects())- self.play(- FadeIn(surface),- LaggedStart(*[- TransformFromCopy(graph, graph_slice)- for graph_slice in graph_slices- ], lag_ratio=0.02)- )- self.wait(4)-- # Show slices- self.axes = axes_copy # So get_graph works...- slicing_plane = Rectangle(- stroke_width=0,- fill_color=WHITE,- fill_opacity=0.2,- )- slicing_plane.set_shade_in_3d(True)- slicing_plane.replace(- Line(axes_copy.c2p(0, 0), axes_copy.c2p(10, 100)),- stretch=True- )- self.orient_mobject_for_3d(slicing_plane)-- def get_time_slice(t):- new_slice = self.get_graph(t)- new_slice.set_shade_in_3d(True)- self.orient_mobject_for_3d(new_slice)- new_slice.shift(t * UP)- return new_slice-- graph.set_shade_in_3d(True)- t_tracker = ValueTracker(0)- graph.add_updater(lambda g: g.become(- get_time_slice(t_tracker.get_value())- ))-- self.orient_mobject_for_3d(final_rod)- final_rod.shift(10 * UP)- kw = {"run_time": 10, "rate_func": linear}- self.rod.save_state()- self.play(- ApplyMethod(t_tracker.set_value, 10, **kw),- Transform(self.rod, final_rod, **kw),- ApplyMethod(slicing_plane.shift, 10 * UP, **kw),- )- self.wait()-- self.set_variables_as_attrs(- t_axis,- input_plane,- surface,- graph_slices,- slicing_plane,- t_tracker,- )-- #- def get_graph(self, time=0):- graph = self.axes.get_graph(- lambda x: self.temp_func(x, time),- x_min=self.graph_x_min,- x_max=self.graph_x_max,- step_size=self.step_size,- )- graph.time = time- graph.color_using_background_image("VerticalTempGradient")- return graph-- def get_graph_time_change_animation(self, graph, new_time, **kwargs):- old_time = graph.time- graph.time = new_time- config = {- "run_time": abs(new_time - old_time),- "rate_func": linear,- }- config.update(kwargs)-- return UpdateFromAlphaFunc(- graph,- lambda g, a: g.become(- self.get_graph(interpolate(- old_time, new_time, a- ))- ),- **config- )-- def orient_mobject_for_3d(self, mob):- mob.rotate(- 90 * DEGREES,- axis=RIGHT,- about_point=ORIGIN- )- return mob---class ContrastXChangesToTChanges(TalkThrough1DHeatGraph):- CONFIG = {- # "surface_resolution": 5,- # "graph_slice_step": 1,- }-- def construct(self):- self.catchup_with_last_scene()- self.emphasize_dimensions_of_input_space()- self.reset_time_to_zero()-- self.show_changes_with_x()- self.show_changes_with_t()-- def catchup_with_last_scene(self):- self.force_skipping()-- self.add_axes()- self.add_graph()- self.add_rod()-- self.rod_word = Point()- self.show_x_axis()- self.show_surface()-- self.revert_to_original_skipping_status()-- def emphasize_dimensions_of_input_space(self):- plane = self.input_plane- plane_copy = plane.copy()- plane_copy.set_color(BLUE_E)- plane_copy.shift(SMALL_BUFF * 0.5 * OUT)-- plane_copy1 = plane_copy.copy()- plane_copy1.stretch(0.01, 1, about_edge=DOWN)- plane_copy0 = plane_copy1.copy()- plane_copy0.stretch(0, 0, about_edge=LEFT)-- words = TextMobject("2d input\\\\space")- words.scale(2)- words.move_to(plane.get_center() + SMALL_BUFF * OUT)-- self.play(- Write(words),- self.camera.phi_tracker.set_value, 60 * DEGREES,- self.camera.theta_tracker.set_value, -90 * DEGREES,- run_time=1- )- self.play(- ReplacementTransform(plane_copy0, plane_copy1)- )- self.play(- ReplacementTransform(plane_copy1, plane_copy)- )- self.wait(2)- self.play(FadeOut(plane_copy))-- self.input_plane_words = words-- def reset_time_to_zero(self):- self.play(- self.t_tracker.set_value, 0,- VFadeOut(self.slicing_plane),- Restore(self.rod),- )-- def show_changes_with_x(self):- alpha_tracker = ValueTracker(0)- line = always_redraw(- lambda: self.get_tangent_line(- self.graph, alpha_tracker.get_value(),- )- )-- self.stop_ambient_camera_rotation()- self.play(- ShowCreation(line),- FadeOut(self.input_plane_words),- self.camera.phi_tracker.set_value, 80 * DEGREES,- self.camera.theta_tracker.set_value, -90 * DEGREES,- )- self.play(- alpha_tracker.set_value, 0.425,- run_time=5,- rate_func=bezier([0, 0, 1, 1]),- )-- # Show dx and dT- p0 = line.point_from_proportion(0.3)- p2 = line.point_from_proportion(0.7)- p1 = np.array([p2[0], *p0[1:]])- dx_line = DashedLine(p0, p1)- dT_line = DashedLine(p1, p2)- dx = TexMobject("dx")- dT = TexMobject("dT")- VGroup(dx, dT).scale(0.7)- VGroup(dx, dT).rotate(90 * DEGREES, RIGHT)- dx.next_to(dx_line, IN, SMALL_BUFF)- dT.next_to(dT_line, RIGHT, SMALL_BUFF)-- self.play(- ShowCreation(dx_line),- FadeInFrom(dx, LEFT)- )- self.wait()- self.play(- ShowCreation(dT_line),- FadeInFrom(dT, IN)- )- self.wait()- self.play(*map(FadeOut, [- line, dx_line, dT_line, dx, dT,- ]))-- def show_changes_with_t(self):- slices = self.graph_slices- slice_alpha = 0.075- graph = VMobject()- graph.set_points_smoothly([- gs.point_from_proportion(slice_alpha)- for gs in slices- ])- graph.color_using_background_image("VerticalTempGradient")- graph.set_shade_in_3d(True)-- alpha_tracker = ValueTracker(0)- line = always_redraw(- lambda: self.get_tangent_line(- graph, alpha_tracker.get_value(),- )- )-- plane = Square()- plane.set_stroke(width=0)- plane.set_fill(WHITE, 0.1)- plane.set_shade_in_3d(True)- plane.rotate(90 * DEGREES, RIGHT)- plane.rotate(90 * DEGREES, OUT)- plane.set_height(10)- plane.set_depth(8, stretch=True)- plane.move_to(self.t_axis.n2p(0), IN + DOWN)- plane.shift(RIGHT)-- self.play(- self.camera.theta_tracker.set_value, -20 * DEGREES,- self.camera.frame_center.shift, 4 * LEFT,- )-- self.play(- ShowCreation(- graph.copy(),- remover=True- ),- FadeInFrom(plane, 6 * DOWN, run_time=2),- VFadeIn(line),- ApplyMethod(- alpha_tracker.set_value, 1,- run_time=8,- ),- )- self.add(graph)-- self.begin_ambient_camera_rotation(-0.02)- self.camera.frame_center.add_updater(- lambda m, dt: m.shift(0.05 * dt * RIGHT)- )-- self.play(- FadeOut(line),- FadeOut(plane),- )- self.wait(30) # Let rotate-- self.t_graph = graph-- #- def get_tangent_line(self, graph, alpha, d_alpha=0.001, length=2):- if alpha < 1 - d_alpha:- a1 = alpha- a2 = alpha + d_alpha- else:- a1 = alpha - d_alpha- a2 = alpha-- p1 = graph.point_from_proportion(a1)- p2 = graph.point_from_proportion(a2)- line = Line(p1, p2, color=WHITE)- line.scale(- length / line.get_length()- )- line.move_to(p1)- return line---class TransitionToTempVsTime(ContrastXChangesToTChanges):- CONFIG = {- # "surface_resolution": 5,- # "graph_slice_step": 1,- }-- def construct(self):- self.catchup_with_last_scene()-- axes = self.original_axes- t_axis = self.t_axis- y_axis = axes.y_axis- x_axis = axes.x_axis-- for mob in self.get_mobjects():- mob.clear_updaters()- self.stop_ambient_camera_rotation()- self.move_camera(- phi=90 * DEGREES,- theta=0 * DEGREES,- added_anims=[- Rotate(- y_axis, 90 * DEGREES,- axis=OUT,- about_point=y_axis.n2p(0),- ),- FadeOut(VGroup(- self.graph_slices,- self.surface,- self.slicing_plane,- self.rod,- self.graph,- self.x_numbers,- self.x_axis_label,- self.t_graph,- )),- self.camera.frame_center.move_to, 5 * LEFT,- ]- )- self.play(- VGroup(x_axis, self.input_plane).stretch,- 0, 0, {"about_point": y_axis.n2p(0)},- )- self.play(- t_axis.time_label.scale, 1 / 1.5,- t_axis.time_label.next_to, t_axis, IN, MED_LARGE_BUFF,- t_axis.numbers.shift, 0.7 * IN,- )- self.wait()-- def catchup_with_last_scene(self):- self.force_skipping()-- self.add_axes()- self.add_graph()- self.add_rod()-- self.rod_word = Point()- self.show_x_axis()- self.show_surface()-- self.emphasize_dimensions_of_input_space()- self.reset_time_to_zero()-- self.show_changes_with_x()- self.show_changes_with_t()-- self.revert_to_original_skipping_status()---class ShowDelTermsAsTinyNudges(TransitionToTempVsTime):- CONFIG = {- # "surface_resolution": 5,- # "graph_slice_step": 1,- "tangent_line_length": 4,- }-- def construct(self):- self.catchup_with_last_scene()- self.stop_camera()- self.show_del_t()- self.show_del_x()-- def stop_camera(self):- self.stop_ambient_camera_rotation()- for mob in self.get_mobjects():- mob.clear_updaters()-- def show_del_x(self):- x_tracker = ValueTracker(3)- dx_tracker = ValueTracker(0.5)-- line_group = self.get_line_group(- self.graph,- x_tracker,- dx_tracker,- corner_index=0,- )- dx_line, dT_line, tan_line = line_group-- del_x = TexMobject("\\partial x")- del_x.set_color(GREEN)- del_x.line = dx_line- del_x.direction = OUT- del_T = TexMobject("\\partial T")- del_T.line = dT_line- del_T.direction = RIGHT- syms = VGroup(del_T, del_x)- for sym in syms:- sym.add_updater(lambda m: m.set_width(- dx_line.get_length()- ))- sym.rect = SurroundingRectangle(sym)- group = VGroup(sym, sym.rect)- group.rotate(90 * DEGREES, RIGHT)-- for sym in syms:- sym.add_updater(lambda m: m.next_to(- m.line, m.direction, SMALL_BUFF,- ))- sym.rect.move_to(sym)-- self.move_camera(- phi=80 * DEGREES,- theta=-90 * DEGREES,- added_anims=[- self.camera.frame_center.move_to, ORIGIN,- ],- )- for sym in reversed(syms):- self.play(- FadeInFrom(sym, -sym.direction),- ShowCreation(- sym.line.copy(),- remover=True- ),- )- self.add(sym.line)- self.play(ShowCreation(tan_line))- for sym in syms:- self.play(- ShowCreationThenDestruction(sym.rect)- )- self.wait()- self.wait()- self.add(line_group)- self.play(- dx_tracker.set_value, 0.01,- run_time=5,- )- self.play(- FadeOut(syms),- FadeOut(line_group),- )-- def show_del_t(self):- # Largely copy pasted from above.- # Reconsolidate if any of this will actually- # be used later.- t_tracker = ValueTracker(1)- dt_tracker = ValueTracker(1)-- line_group = self.get_line_group(- self.t_graph, t_tracker, dt_tracker,- corner_index=1,- )- dt_line, dT_line, tan_line = line_group-- del_t = TexMobject("\\partial t")- del_t.set_color(YELLOW)- del_t.line = dt_line- del_t.direction = OUT- del_T = TexMobject("\\partial T")- del_T.line = dT_line- del_T.direction = UP- syms = VGroup(del_T, del_t)- for sym in syms:- sym.rect = SurroundingRectangle(sym)- group = VGroup(sym, sym.rect)- group.rotate(90 * DEGREES, RIGHT)- group.rotate(90 * DEGREES, OUT)- sym.add_updater(lambda m: m.set_height(- 0.8 * dT_line.get_length()- ))-- del_t.add_updater(lambda m: m.set_height(- min(0.5, m.line.get_length())- ))- del_T.add_updater(lambda m: m.set_depth(- min(0.5, m.line.get_length())- ))- for sym in syms:- sym.add_updater(lambda m: m.next_to(- m.line, m.direction, SMALL_BUFF,- ))- sym.rect.move_to(sym)-- self.move_camera(- phi=80 * DEGREES,- theta=-10 * DEGREES,- added_anims=[- self.camera.frame_center.move_to, 5 * LEFT,- ],- )- for sym in reversed(syms):- self.play(- FadeInFrom(sym, -sym.direction),- ShowCreation(- sym.line.copy(),- remover=True- ),- )- self.add(sym.line)- self.play(ShowCreation(tan_line))- for sym in syms:- self.play(- ShowCreationThenDestruction(sym.rect)- )- self.wait()- self.wait()- self.add(line_group)- self.play(- dt_tracker.set_value, 0.01,- run_time=5,- )- self.play(- FadeOut(syms),- FadeOut(line_group),- )-- #- def get_line_group(self, graph, input_tracker, nudge_tracker, corner_index):- get_x = input_tracker.get_value- get_dx = nudge_tracker.get_value-- def get_graph_point(x):- return graph.point_from_proportion(- inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- x,- )- )-- def get_corner(p1, p2):- result = np.array(p1)- result[corner_index] = p2[corner_index]- return result-- line_group = VGroup(- Line(color=WHITE),- Line(color=RED),- Line(color=WHITE, stroke_width=2),- )-- def update_line_group(group):- dxl, dTl, tl = group- p0 = get_graph_point(get_x())- p2 = get_graph_point(get_x() + get_dx())- p1 = get_corner(p0, p2)-- dxl.set_points_as_corners([p0, p1])- dTl.set_points_as_corners([p1, p2])- tl.set_points_as_corners([p0, p2])- tl.scale(- self.tangent_line_length / tl.get_length()- )- line_group.add_updater(update_line_group)- return line_group---class ShowCurvatureToRateOfChangeIntuition(ShowEvolvingTempGraphWithArrows):- CONFIG = {- "freq_amplitude_pairs": [- (1, 0.7),- (2, 1),- (3, 0.5),- (4, 0.3),- (5, 0.3),- (7, 0.2),- ],- "arrow_xs": [0.7, 3.8, 4.6, 5.4, 6.2, 9.3],- "arrow_scale_factor": 0.2,- "max_magnitude": 1.0,- "wait_time": 20,- }-- def let_play(self):- arrows = self.arrows- curves = VGroup(*[- self.get_mini_curve(- inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- x,- )- )- for x in self.arrow_xs- ])- curves.set_stroke(WHITE, 5)-- curve_words = VGroup()- for curve, arrow in zip(curves, arrows):- word = TextMobject("curve")- word.scale(0.7)- word.next_to(curve, arrow.get_vector()[1] * DOWN, SMALL_BUFF)- curve_words.add(word)-- self.remove(arrows)-- self.play(- ShowCreation(curves),- LaggedStartMap(FadeIn, curve_words),- self.y_label.set_fill, {"opacity": 0},- )- self.wait()- self.add(*arrows, curves)- self.play(LaggedStartMap(GrowArrow, arrows))- self.wait()-- self.play(FadeOut(VGroup(curves, curve_words)))- self.add(arrows)- super().let_play()-- def get_mini_curve(self, alpha, d_alpha=0.02):- result = VMobject()- result.pointwise_become_partial(- self.graph,- alpha - d_alpha,- alpha + d_alpha,- )- return result---class DiscreteSetup(ShowEvolvingTempGraphWithArrows):- CONFIG = {- "step_size": 1,- "rod_piece_size_ratio": 1 / 3,- "dashed_line_stroke_opacity": 1.0,- "dot_radius": DEFAULT_DOT_RADIUS,- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- (5, 0.3),- (7, 0.2),- (21, 0.1),- # (41, 0.05),- ],- }-- def construct(self):- self.add_axes()- self.add_graph()- self.discretize()- self.let_time_pass()- self.show_nieghbor_rule()- self.focus_on_three_points()- self.show_difference_formula()- self.gut_check_new_interpretation()- self.write_second_difference()- self.emphasize_final_expression()-- def add_axes(self):- super().add_axes()- self.axes.shift(MED_SMALL_BUFF * LEFT)-- def add_graph(self):- points = self.get_points(time=0)- graph = VMobject()- graph.set_points_smoothly(points)- graph.color_using_background_image("VerticalTempGradient")-- self.add(graph)-- self.graph = graph- self.points = points-- def discretize(self):- axes = self.axes- x_axis = axes.x_axis- graph = self.graph-- piecewise_graph = CurvesAsSubmobjects(graph)- dots = self.get_dots()- v_lines = VGroup(*map(self.get_v_line, dots))-- rod_pieces = VGroup()- for x in self.get_sample_inputs():- piece = Line(LEFT, RIGHT)- piece.set_width(- self.step_size * self.rod_piece_size_ratio- )- piece.move_to(axes.c2p(x, 0))- piece.set_color(- self.rod_point_to_color(piece.get_center())- )- rod_pieces.add(piece)-- word = TextMobject("Discrete version")- word.scale(1.5)- word.next_to(x_axis, UP)- word.set_stroke(BLACK, 3, background=True)-- self.remove(graph)- self.play(- ReplacementTransform(- piecewise_graph, dots,- ),- Write(word, run_time=1)- )- self.add(v_lines, word)- self.play(- x_axis.fade, 0.8,- TransformFromCopy(- x_axis.tick_marks[1:],- rod_pieces,- ),- LaggedStartMap(ShowCreation, v_lines)- )- self.play(FadeOut(word))- self.wait()-- self.rod_pieces = rod_pieces- self.dots = dots- self.v_lines = v_lines-- def let_time_pass(self):- dots = self.dots-- t_tracker = ValueTracker(0)- t_tracker.add_updater(lambda m, dt: m.increment_value(dt))- self.add(t_tracker)-- self.add_clock()- self.time_label.next_to(self.clock, DOWN)- self.time_label.add_updater(- lambda m: m.set_value(t_tracker.get_value())- )- dots.add_updater(lambda d: d.become(- self.get_dots(t_tracker.get_value())- ))- run_time = 5- self.play(- ClockPassesTime(- self.clock,- run_time=run_time,- hours_passed=run_time,- ),- )- t_tracker.clear_updaters()- t_tracker.set_value(run_time)- self.wait()- self.play(- t_tracker.set_value, 0,- FadeOut(self.clock),- FadeOut(self.time_label),- )- self.remove(t_tracker)- dots.clear_updaters()-- def show_nieghbor_rule(self):- dots = self.dots- rod_pieces = self.rod_pieces- index = self.index = 2-- p1, p2, p3 = rod_pieces[index:index + 3]- d1, d2, d3 = dots[index:index + 3]- point_label = TextMobject("Point")- neighbors_label = TextMobject("Neighbors")- words = VGroup(point_label, neighbors_label)- for word in words:- word.scale(0.7)- word.add_background_rectangle()-- point_label.next_to(p2, DOWN)- neighbors_label.next_to(p2, UP, buff=1)- bottom = neighbors_label.get_bottom()- kw = {- "buff": 0.1,- "stroke_width": 2,- "tip_length": 0.15- }- arrows = VGroup(- Arrow(bottom, p1.get_center(), **kw),- Arrow(bottom, p3.get_center(), **kw),- )- arrows.set_color(WHITE)-- dot = Dot()- dot.set_fill(GREY, opacity=0.2)- dot.replace(p2)- dot.scale(3)-- self.play(- dot.scale, 0,- dot.set_opacity, 0,- FadeInFrom(point_label, DOWN)- )- self.play(- FadeInFrom(neighbors_label, DOWN),- *map(GrowArrow, arrows)- )- self.wait()-- # Let d2 change- self.play(- d1.set_y, 3,- d3.set_y, 3,- )-- def get_v():- return 0.25 * np.sum([- d1.get_y(),- -2 * d2.get_y(),- + d3.get_y(),- ])- v_vect_fader = ValueTracker(0)- v_vect = always_redraw(- lambda: Vector(- get_v() * UP,- color=temperature_to_color(- get_v(), -2, 2,- ),- ).shift(d2.get_center()).set_opacity(- v_vect_fader.get_value(),- )- )- d2.add_updater(- lambda d, dt: d.shift(- get_v() * dt * UP,- )- )-- self.add(v_vect)- self.play(v_vect_fader.set_value, 1)- self.wait(3)- self.play(- d1.set_y, 0,- d3.set_y, 0,- )- self.wait(4)- self.play(FadeOut(VGroup(- point_label,- neighbors_label,- arrows- )))-- self.v_vect = v_vect- self.example_pieces = VGroup(p1, p2, p3)- self.example_dots = VGroup(d1, d2, d3)-- def focus_on_three_points(self):- dots = self.example_dots- d1, d2, d3 = dots- pieces = self.example_pieces- y_axis = self.axes.y_axis-- x_labels, T_labels = [- VGroup(*[- TexMobject("{}_{}".format(s, i))- for i in [1, 2, 3]- ]).scale(0.8)- for s in ("x", "T")- ]- for xl, piece in zip(x_labels, pieces):- xl.next_to(piece, DOWN)- xl.add_background_rectangle()- for Tl, dot in zip(T_labels, dots):- Tl.dot = dot- Tl.add_updater(lambda m: m.next_to(- m.dot, RIGHT, SMALL_BUFF- ))- Tl.add_background_rectangle()- T1, T2, T3 = T_labels-- d2.movement_updater = d2.get_updaters()[0]- dots.clear_updaters()- self.remove(self.v_vect)-- self.play(- ShowCreationThenFadeAround(pieces),- FadeOut(self.dots[:self.index]),- FadeOut(self.v_lines[:self.index]),- FadeOut(self.rod_pieces[:self.index]),- FadeOut(self.dots[self.index + 3:]),- FadeOut(self.v_lines[self.index + 3:]),- FadeOut(self.rod_pieces[self.index + 3:]),- )- self.play(LaggedStartMap(- FadeInFrom, x_labels,- lambda m: (m, LEFT),- lag_ratio=0.3,- run_time=2,- ))- self.play(- d3.set_y, 1,- d2.set_y, 0.25,- d1.set_y, 0,- )- self.wait()- self.play(LaggedStart(*[- TransformFromCopy(xl, Tl)- for xl, Tl in zip(x_labels, T_labels)- ], lag_ratio=0.3, run_time=2))- self.wait()-- # Show lines- h_lines = VGroup(*map(self.get_h_line, dots))- hl1, hl2, hl3 = h_lines-- average_pointer = ArrowTip(- start_angle=0,- length=0.2,- )- average_pointer.set_color(YELLOW)- average_pointer.stretch(0.25, 1)- average_pointer.add_updater(- lambda m: m.move_to(- 0.5 * (hl1.get_start() + hl3.get_start()),- RIGHT- )- )- average_arrows = always_redraw(lambda: VGroup(*[- Arrow(- hl.get_start(),- average_pointer.get_right(),- color=WHITE,- buff=0.0,- )- for hl in [hl1, hl3]- ]))- average_label = TexMobject(- "{T_1", "+", "T_3", "\\over", "2}"- )- average_label.scale(0.5)- average_label.add_updater(lambda m: m.next_to(- average_pointer, LEFT, SMALL_BUFF- ))-- average_rect = SurroundingRectangle(average_label)- average_rect.add_updater(- lambda m: m.move_to(average_label)- )- average_words = TextMobject("Neighbor\\\\average")- average_words.match_width(average_rect)- average_words.match_color(average_rect)- average_words.add_updater(- lambda m: m.next_to(average_rect, UP, SMALL_BUFF)- )-- mini_T1 = average_label.get_part_by_tex("T_1")- mini_T3 = average_label.get_part_by_tex("T_3")- for mini, line in (mini_T1, hl1), (mini_T3, hl3):- mini.save_state()- mini.next_to(line, LEFT, SMALL_BUFF)-- self.add(hl1, hl3, T_labels)- y_axis.remove(y_axis.numbers)- self.play(- GrowFromPoint(hl1, hl1.get_end()),- GrowFromPoint(hl3, hl3.get_end()),- TransformFromCopy(- T1, mini_T1,- ),- TransformFromCopy(- T3, mini_T3,- ),- FadeOut(y_axis.numbers),- y_axis.set_stroke, {"width": 1},- )- self.play(- FadeIn(average_pointer),- Restore(mini_T1),- Restore(mini_T3),- FadeIn(average_label[1]),- FadeIn(average_label[3:]),- *map(GrowArrow, average_arrows)- )- self.add(average_arrows, average_label)- self.play(- ShowCreation(average_rect),- FadeIn(average_words),- )- self.play(- GrowFromPoint(hl2, hl2.get_end())- )- self.wait()-- # Show formula- formula = TexMobject(- "\\left(",- "{T_1", "+", "T_3", "\\over", "2}",- "-", "T_2",- "\\right)"- )- formula.to_corner(UR, buff=MED_LARGE_BUFF)- formula.shift(1.7 * LEFT)- brace = Brace(formula, DOWN)- diff_value = DecimalNumber(include_sign=True)- diff_value.add_updater(lambda m: m.set_value(- y_axis.p2n(average_pointer.get_right()) -- y_axis.p2n(d2.get_center())- ))- diff_value.next_to(brace, DOWN)-- self.play(- ReplacementTransform(- average_label.deepcopy(),- formula[1:1 + len(average_label)]- ),- TransformFromCopy(T2, formula[-2]),- FadeIn(formula[-3]),- FadeIn(formula[-1]),- FadeIn(formula[0]),- GrowFromCenter(brace),- FadeIn(diff_value)- )- self.wait()-- # Changes- self.play(FadeIn(self.v_vect))- d2.add_updater(d2.movement_updater)- self.wait(5)-- self.play(- d3.set_y, 3,- d1.set_y, 2.5,- d2.set_y, -2,- )- self.wait(5)- self.play(- d3.set_y, 1,- d1.set_y, -1,- )- self.wait(8)-- # Show derivative- lhs = TexMobject(- "{dT_2", "\\over", "dt}", "=", "\\alpha"- )- dt = lhs.get_part_by_tex("dt")- alpha = lhs.get_part_by_tex("\\alpha")- lhs.next_to(formula, LEFT, SMALL_BUFF)-- self.play(Write(lhs))- self.play(ShowCreationThenFadeAround(dt))- self.wait()- self.play(ShowCreationThenFadeAround(alpha))- self.wait()- self.play(- FadeOut(brace),- FadeOut(diff_value),- )-- self.lhs = lhs- self.rhs = formula-- def show_difference_formula(self):- lhs = self.lhs- rhs = self.rhs- d1, d2, d3 = self.example_dots-- new_rhs = TexMobject(- "=",- "{\\alpha", "\\over", "2}",- "\\left(",- "(", "T_3", "-", "T_2", ")",- "-",- "(", "T_2", "-", "T_1", ")",- "\\right)"- )- big_parens = VGroup(- new_rhs.get_part_by_tex("\\left("),- new_rhs.get_part_by_tex("\\right)"),- )- for paren in big_parens:- paren.scale(2)- new_rhs.next_to(rhs, DOWN)- new_rhs.align_to(lhs.get_part_by_tex("="), LEFT)-- def p2p_anim(mob1, mob2, tex, index=0):- return TransformFromCopy(- mob1.get_parts_by_tex(tex)[index],- mob2.get_parts_by_tex(tex)[index],- )-- self.play(- p2p_anim(lhs, new_rhs, "="),- p2p_anim(rhs, new_rhs, "\\left("),- p2p_anim(rhs, new_rhs, "\\right)"),- p2p_anim(lhs, new_rhs, "\\alpha"),- p2p_anim(rhs, new_rhs, "\\over"),- p2p_anim(rhs, new_rhs, "2"),- )- self.play(- p2p_anim(rhs, new_rhs, "T_3"),- p2p_anim(rhs, new_rhs, "-"),- p2p_anim(rhs, new_rhs, "T_2"),- FadeIn(new_rhs.get_parts_by_tex("(")[1]),- FadeIn(new_rhs.get_parts_by_tex(")")[0]),- )- self.play(- p2p_anim(rhs, new_rhs, "T_2", -1),- p2p_anim(rhs, new_rhs, "-", -1),- p2p_anim(rhs, new_rhs, "T_1"),- FadeIn(new_rhs.get_parts_by_tex("-")[1]),- FadeIn(new_rhs.get_parts_by_tex("(")[2]),- FadeIn(new_rhs.get_parts_by_tex(")")[1]),- )- self.wait()-- self.rhs2 = new_rhs-- # Show deltas- T1_index = new_rhs.index_of_part_by_tex("T_1")- T3_index = new_rhs.index_of_part_by_tex("T_3")- diff1 = new_rhs[T1_index - 2:T1_index + 1]- diff2 = new_rhs[T3_index:T3_index + 3]- brace1 = Brace(diff1, DOWN, buff=SMALL_BUFF)- brace2 = Brace(diff2, DOWN, buff=SMALL_BUFF)- delta_T1 = TexMobject("\\Delta T_1")- delta_T1.next_to(brace1, DOWN, SMALL_BUFF)- delta_T2 = TexMobject("\\Delta T_2")- delta_T2.next_to(brace2, DOWN, SMALL_BUFF)- minus = TexMobject("-")- minus.move_to(Line(- delta_T1.get_right(),- delta_T2.get_left(),- ))- braces = VGroup(brace1, brace2)- deltas = VGroup(delta_T1, delta_T2)-- kw = {- "direction": LEFT,- "buff": SMALL_BUFF,- "min_num_quads": 2,- }- lil_brace1 = always_redraw(lambda: Brace(- Line(d1.get_left(), d2.get_left()), **kw- ))- lil_brace2 = always_redraw(lambda: Brace(- Line(d2.get_left(), d3.get_left()), **kw- ))- lil_braces = VGroup(lil_brace1, lil_brace2)- lil_delta_T1 = delta_T1.copy()- lil_delta_T2 = delta_T2.copy()- lil_deltas = VGroup(lil_delta_T1, lil_delta_T2)- for brace, delta in zip(lil_braces, lil_deltas):- delta.brace = brace- delta.add_updater(lambda d: d.next_to(- d.brace, LEFT, SMALL_BUFF,- ))-- delta_T1.set_color(BLUE)- lil_delta_T1.set_color(BLUE)- delta_T2.set_color(RED)- lil_delta_T2.set_color(RED)-- double_difference_brace = Brace(deltas, DOWN)- double_difference_words = TextMobject(- "Difference of differences"- )- double_difference_words.next_to(- double_difference_brace, DOWN- )-- self.play(- GrowFromCenter(brace1),- GrowFromCenter(lil_brace1),- FadeIn(delta_T1),- FadeIn(lil_delta_T1),- )- self.wait()- self.play(- GrowFromCenter(brace2),- GrowFromCenter(lil_brace2),- FadeIn(delta_T2),- FadeIn(lil_delta_T2),- )- self.wait()- self.play(- Write(minus),- GrowFromCenter(double_difference_brace),- Write(double_difference_words),- )- self.wait()-- self.braces = braces- self.deltas = deltas- self.delta_minus = minus- self.lil_braces = lil_braces- self.lil_deltas = lil_deltas- self.double_difference_brace = double_difference_brace- self.double_difference_words = double_difference_words-- def gut_check_new_interpretation(self):- lil_deltas = self.lil_deltas- d1, d2, d3 = self.example_dots-- self.play(ShowCreationThenFadeAround(lil_deltas[0]))- self.play(ShowCreationThenFadeAround(lil_deltas[1]))- self.wait()- self.play(- d2.shift, MED_SMALL_BUFF * UP,- rate_func=there_and_back,- )- self.wait()- self.play(- d3.set_y, 3,- d1.set_y, -0.5,- )- self.wait(5)- self.play(- d3.set_y, 1.5,- d1.set_y, -2,- )- self.wait(5)-- def write_second_difference(self):- dd_word = self.double_difference_words-- delta_delta = TexMobject("\\Delta \\Delta T_1")- delta_delta.set_color(MAROON_B)-- delta_delta.move_to(dd_word, UP)-- second_difference_word = TextMobject(- "``Second difference''"- )- second_difference_word.next_to(delta_delta, DOWN)-- self.play(- FadeOutAndShift(dd_word, UP),- FadeInFrom(delta_delta, UP),- )- self.wait()- self.play(- Write(second_difference_word),- )- self.wait()-- # Random play- d1, d2, d3 = self.example_dots- self.play(- d3.set_y, 3,- d1.set_y, -0.5,- )- self.wait(5)- self.play(- d3.set_y, 1.5,- d1.set_y, -2,- )- self.wait(5)-- self.delta_delta = delta_delta- self.second_difference_word = second_difference_word-- def emphasize_final_expression(self):- lhs = self.lhs- rhs = self.rhs- rhs2 = self.rhs2- old_dd = self.delta_delta- dd = old_dd.copy()- old_ao2 = rhs2[1:4]- ao2 = old_ao2.copy()-- new_lhs = lhs[:-1]- full_rhs = VGroup(- lhs[-1],- lhs[-2].copy(),- rhs,- rhs2,- self.braces,- self.deltas,- self.delta_minus,- self.double_difference_brace,- old_dd,- self.second_difference_word,- )- new_rhs = VGroup(ao2, dd)- new_rhs.arrange(RIGHT, buff=SMALL_BUFF)- new_rhs.next_to(new_lhs, RIGHT)-- self.play(- full_rhs.to_edge, DOWN, {"buff": LARGE_BUFF},- )- self.play(- TransformFromCopy(old_ao2, ao2),- TransformFromCopy(old_dd, dd),- )- self.play(- ShowCreationThenFadeAround(- VGroup(new_lhs, new_rhs)- )- )- self.wait()-- #- def get_sample_inputs(self):- return np.arange(- self.graph_x_min,- self.graph_x_max + self.step_size,- self.step_size,- )-- def get_points(self, time=0):- return [- self.axes.c2p(x, self.temp_func(x, t=time))- for x in self.get_sample_inputs()- ]-- def get_dots(self, time=0):- points = self.get_points(time)- dots = VGroup(*[- Dot(- point,- radius=self.dot_radius- )- for point in points- ])- dots.color_using_background_image("VerticalTempGradient")- return dots-- def get_dot_dashed_line(self, dot, index, color=False):- direction = np.zeros(3)- direction[index] = -1-- def get_line():- p1 = dot.get_edge_center(direction)- p0 = np.array(p1)- p0[index] = self.axes.c2p(0, 0)[index]- result = DashedLine(- p0, p1,- stroke_width=2,- color=WHITE,- stroke_opacity=self.dashed_line_stroke_opacity,- )- if color:- result.color_using_background_image(- "VerticalTempGradient"- )- return result- return always_redraw(get_line)-- def get_h_line(self, dot):- return self.get_dot_dashed_line(dot, 0, True)-- def get_v_line(self, dot):- return self.get_dot_dashed_line(dot, 1)---class ShowFinitelyManyX(DiscreteSetup):- def construct(self):- self.setup_axes()- axes = self.axes- axes.fade(1)- points = [- axes.c2p(x, 0)- for x in self.get_sample_inputs()[1:]- ]- x_labels = VGroup(*[- TexMobject("x_{}".format(i)).next_to(- p, DOWN- )- for i, p in enumerate(points)- ])-- self.play(LaggedStartMap(- FadeInFromLarge, x_labels- ))- self.play(LaggedStartMap(FadeOut, x_labels))- self.wait()---class DiscreteGraphStillImage1(DiscreteSetup):- CONFIG = {- "step_size": 1,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.discretize()---class DiscreteGraphStillImageFourth(DiscreteGraphStillImage1):- CONFIG = {- "step_size": 0.25,- }---class DiscreteGraphStillImageTenth(DiscreteGraphStillImage1):- CONFIG = {- "step_size": 0.1,- "dashed_line_stroke_opacity": 0.25,- "dot_radius": 0.04,- }---class DiscreteGraphStillImageHundredth(DiscreteGraphStillImage1):- CONFIG = {- "step_size": 0.01,- "dashed_line_stroke_opacity": 0.1,- "dot_radius": 0.01,- }---class TransitionToContinuousCase(DiscreteSetup):- CONFIG = {- "step_size": 0.1,- "tangent_line_length": 3,- "wait_time": 30,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.show_temperature_difference()- self.show_second_derivative()- self.show_curvature_examples()- self.show_time_changes()-- def add_graph(self):- self.setup_graph()- self.play(- ShowCreation(- self.graph,- run_time=3,- )- )- self.wait()-- def show_temperature_difference(self):- x_tracker = ValueTracker(2)- dx_tracker = ValueTracker(1)-- line_group = self.get_line_group(- x_tracker,- dx_tracker,- )- dx_line, dT_line, tan_line, dx_sym, dT_sym = line_group- tan_line.set_stroke(width=0)-- brace = Brace(dx_line, UP)- fixed_distance = TextMobject("Fixed\\\\distance")- fixed_distance.scale(0.7)- fixed_distance.next_to(brace, UP)- delta_T = TexMobject("\\Delta T")- delta_T.move_to(dT_sym, LEFT)-- self.play(- ShowCreation(VGroup(dx_line, dT_line)),- FadeInFrom(delta_T, LEFT)- )- self.play(- GrowFromCenter(brace),- FadeInFromDown(fixed_distance),- )- self.wait()- self.play(- FadeOut(delta_T, UP),- FadeIn(dT_sym, DOWN),- FadeOut(brace, UP),- FadeOut(fixed_distance, UP),- FadeIn(dx_sym, DOWN),- )- self.add(line_group)- self.play(- dx_tracker.set_value, 0.01,- run_time=5- )- self.wait()- self.play(- dx_tracker.set_value, 0.3,- )-- # Show rate of change- to_zero = TexMobject("\\rightarrow 0")- to_zero.match_height(dT_sym)- to_zero.next_to(dT_sym, buff=SMALL_BUFF)-- ratio = TexMobject(- "{\\partial T", "\\over", "\\partial x}"- )- ratio[0].match_style(dT_sym)- ratio.to_edge(UP)-- self.play(ShowCreationThenFadeAround(- dT_sym,- surrounding_rectangle_config={- "buff": 0.05,- "stroke_width": 1,- }- ))- self.play(GrowFromPoint(to_zero, dT_sym.get_right()))- self.wait()- self.play(- TransformFromCopy(- dT_sym,- ratio.get_part_by_tex("\\partial T")- ),- TransformFromCopy(- dx_sym,- ratio.get_part_by_tex("\\partial x")- ),- Write(ratio.get_part_by_tex("\\over"))- )- self.play(- ShowCreation(- tan_line.copy().set_stroke(width=2),- remover=True- ),- FadeOut(to_zero),- )- tan_line.set_stroke(width=2)- self.wait()-- # Look at neighbors- x0 = x_tracker.get_value()- dx = dx_tracker.get_value()- v_line, lv_line, rv_line = v_lines = VGroup(*[- self.get_v_line(x)- for x in [x0, x0 - dx, x0 + dx]- ])- v_lines[1:].set_color(BLUE)-- self.play(ShowCreation(v_line))- self.play(- TransformFromCopy(v_line, lv_line),- TransformFromCopy(v_line, rv_line),- )- self.wait()- self.play(- FadeOut(v_lines[1:]),- ApplyMethod(- dx_tracker.set_value, 0.01,- run_time=2- ),- )-- self.line_group = line_group- self.deriv = ratio- self.x_tracker = x_tracker- self.dx_tracker = dx_tracker- self.v_line = v_line-- def show_second_derivative(self):- x_tracker = self.x_tracker- deriv = self.deriv- v_line = self.v_line-- deriv_of_deriv = TexMobject(- "{\\partial",- "\\left(",- "{\\partial T", "\\over", "\\partial x}",- "\\right)",- "\\over",- "\\partial x}"- )- deriv_of_deriv.set_color_by_tex("\\partial T", RED)-- deriv_of_deriv.to_edge(UP)- dT_index = deriv_of_deriv.index_of_part_by_tex("\\partial T")- inner_deriv = deriv_of_deriv[dT_index:dT_index + 3]-- self.play(- ReplacementTransform(deriv, inner_deriv),- Write(VGroup(*filter(- lambda m: m not in inner_deriv,- deriv_of_deriv,- )))- )- v_line.add_updater(lambda m: m.become(- self.get_v_line(x_tracker.get_value())- ))- for change in [-0.1, 0.1]:- self.play(- x_tracker.increment_value, change,- run_time=3- )-- # Write second deriv- second_deriv = TexMobject(- "{\\partial^2 T", "\\over", "\\partial x^2}"- )- second_deriv[0].set_color(RED)- eq = TexMobject("=")- eq.next_to(deriv_of_deriv, RIGHT)- second_deriv.next_to(eq, RIGHT)- second_deriv.align_to(deriv_of_deriv, DOWN)- eq.match_y(second_deriv.get_part_by_tex("\\over"))-- self.play(Write(eq))- self.play(- TransformFromCopy(- deriv_of_deriv.get_parts_by_tex("\\partial")[:2],- second_deriv.get_parts_by_tex("\\partial^2 T"),- ),- )- self.play(- Write(second_deriv.get_part_by_tex("\\over")),- TransformFromCopy(- deriv_of_deriv.get_parts_by_tex("\\partial x"),- second_deriv.get_parts_by_tex("\\partial x"),- ),- )- self.wait()-- def show_curvature_examples(self):- x_tracker = self.x_tracker- v_line = self.v_line- line_group = self.line_group-- x_tracker.set_value(3.6)- self.wait()- self.play(- x_tracker.set_value, 3.8,- run_time=4,- )- self.wait()- x_tracker.set_value(6.2)- self.wait()- self.play(- x_tracker.set_value, 6.4,- run_time=4,- )- self.wait()-- #- dx = 0.2- neighbor_lines = always_redraw(lambda: VGroup(*[- self.get_v_line(- x_tracker.get_value() + u * dx,- line_class=Line,- )- for u in [-1, 1]- ]))- neighbor_lines.set_color(BLUE)-- self.play(FadeOut(line_group))- self.play(*[- TransformFromCopy(v_line, nl)- for nl in neighbor_lines- ])- self.add(neighbor_lines)- self.play(- x_tracker.set_value, 5,- run_time=5,- rate_func=lambda t: smooth(t, 3)- )- v_line.clear_updaters()- self.play(- FadeOut(v_line),- FadeOut(neighbor_lines),- )- self.wait()-- def show_time_changes(self):- self.setup_clock()- graph = self.graph-- time_label = self.time_label- clock = self.clock- time_label.next_to(clock, DOWN)-- graph.add_updater(self.update_graph)- time_label.add_updater(- lambda d, dt: d.increment_value(dt)- )-- self.add(time_label)- self.add_arrows()- self.play(- ClockPassesTime(- clock,- run_time=self.wait_time,- hours_passed=self.wait_time,- ),- )-- #- def get_v_line(self, x, line_class=DashedLine, stroke_width=2):- axes = self.axes- graph = self.graph- line = line_class(- axes.c2p(x, 0),- graph.point_from_proportion(- inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- x,- )- ),- stroke_width=stroke_width,- )- return line-- def get_line_group(self,- x_tracker,- dx_tracker,- dx_tex="\\partial x",- dT_tex="\\partial T",- max_sym_width=0.5,- ):- graph = self.graph- get_x = x_tracker.get_value- get_dx = dx_tracker.get_value-- dx_line = Line(color=WHITE)- dT_line = Line(color=RED)- tan_line = Line(color=WHITE)- lines = VGroup(dx_line, dT_line, tan_line)- lines.set_stroke(width=2)- dx_sym = TexMobject(dx_tex)- dT_sym = TexMobject(dT_tex)- dT_sym.match_color(dT_line)- syms = VGroup(dx_sym, dT_sym)-- group = VGroup(*lines, *syms)-- def update_group(group):- dxl, dTl, tanl, dxs, dTs = group- x = get_x()- dx = get_dx()- p0, p2 = [- graph.point_from_proportion(- inverse_interpolate(- self.graph_x_min,- self.graph_x_max,- x- )- )- for x in [x, x + dx]- ]- p1 = np.array([p2[0], *p0[1:]])- dxl.put_start_and_end_on(p0, p1)- dTl.put_start_and_end_on(p1, p2)- tanl.put_start_and_end_on(p0, p2)- tanl.scale(- self.tangent_line_length /- tanl.get_length()- )- dxs.match_width(dxl)- dTs.set_height(0.7 * dTl.get_height())- for sym in dxs, dTs:- if sym.get_width() > max_sym_width:- sym.set_width(max_sym_width)- dxs.next_to(- dxl, -dTl.get_vector(), SMALL_BUFF,- )- dTs.next_to(- dTl, dxl.get_vector(), SMALL_BUFF,- )-- group.add_updater(update_group)- return group---class ShowManyVLines(TransitionToContinuousCase):- CONFIG = {- "wait_time": 20,- "max_denom": 10,- "x_step": 0.025,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_v_lines()- self.show_time_changes()-- def add_arrows(self):- pass-- def add_v_lines(self):- axes = self.axes-- v_lines = always_redraw(lambda: VGroup(*[- self.get_v_line(- x,- line_class=Line,- stroke_width=0.5,- )- for x in np.arange(0, 10, self.x_step)- ]))- group = VGroup(*v_lines)-- x_pointer = ArrowTip(start_angle=PI / 2)- x_pointer.set_color(WHITE)- x_pointer.next_to(axes.c2p(0, 0), DOWN, buff=0)- x_eq = VGroup(- TexMobject("x="),- DecimalNumber(0)- )- x_eq.add_updater(- lambda m: m.arrange(RIGHT, buff=SMALL_BUFF)- )- x_eq.add_updater(- lambda m: m[1].set_value(axes.x_axis.p2n(x_pointer.get_top()))- )- x_eq.add_updater(lambda m: m.next_to(- x_pointer, DOWN, SMALL_BUFF,- submobject_to_align=x_eq[0]- ))-- self.add(x_pointer, x_eq)- self.play(- Write(- group,- remover=True,- lag_ratio=self.x_step / 2,- run_time=6,- ),- ApplyMethod(- x_pointer.next_to,- axes.c2p(10, 0),- DOWN, {"buff": 0},- rate_func=linear,- run_time=5,- ),- )- self.add(v_lines)- x_eq.clear_updaters()- self.play(- FadeOut(x_eq),- FadeOut(x_pointer),- )---class ShowNewtonsLawGraph(Scene):- CONFIG = {- "k": 0.2,- "initial_water_temp": 80,- "room_temp": 20,- "delta_T_color": YELLOW,- }-- def construct(self):- self.setup_axes()- self.show_temperatures()- self.show_graph()- self.show_equation()- self.talk_through_examples()-- def setup_axes(self):- axes = Axes(- x_min=0,- x_max=10,- y_min=0,- y_max=100,- y_axis_config={- "unit_size": 0.06,- "tick_frequency": 10,- },- center_point=5 * LEFT + 2.5 * DOWN- )- x_axis = axes.x_axis- y_axis = axes.y_axis- y_axis.add_numbers(*range(20, 100, 20))- x_axis.add_numbers(*range(1, 11))-- x_axis.label = TextMobject("Time")- x_axis.label.next_to(x_axis, DOWN, MED_SMALL_BUFF)-- y_axis.label = TexMobject("\\text{Temperature}")- y_axis.label.next_to(y_axis, RIGHT, buff=SMALL_BUFF)- y_axis.label.align_to(axes, UP)- for axis in [x_axis, y_axis]:- axis.add(axis.label)-- self.add(axes)- self.axes = axes-- def show_temperatures(self):- axes = self.axes-- water_dot = Dot()- water_dot.color_using_background_image("VerticalTempGradient")- water_dot.move_to(axes.c2p(0, self.initial_water_temp))- room_line = DashedLine(- axes.c2p(0, self.room_temp),- axes.c2p(10, self.room_temp),- )- room_line.set_color(BLUE)- room_line.color_using_background_image("VerticalTempGradient")-- water_arrow = Vector(LEFT, color=WHITE)- water_arrow.next_to(water_dot, RIGHT, SMALL_BUFF)- water_words = TextMobject(- "Initial water\\\\temperature"- )- water_words.scale(0.7)- water_words.next_to(water_arrow, RIGHT)-- room_words = TextMobject("Room temperature")- room_words.scale(0.7)- room_words.next_to(room_line, DOWN, SMALL_BUFF)-- self.play(- FadeInFrom(water_dot, RIGHT),- GrowArrow(water_arrow),- Write(water_words),- run_time=1,- )- self.play(ShowCreation(room_line))- self.play(FadeInFromDown(room_words))- self.wait()-- self.set_variables_as_attrs(- water_dot,- water_arrow,- water_words,- room_line,- room_words,- )-- def show_graph(self):- axes = self.axes- water_dot = self.water_dot-- k = self.k- rt = self.room_temp- t0 = self.initial_water_temp- graph = axes.get_graph(- lambda t: rt + (t0 - rt) * np.exp(-k * t)- )- graph.color_using_background_image("VerticalTempGradient")-- def get_x():- return axes.x_axis.p2n(water_dot.get_center())-- brace_line = always_redraw(lambda: Line(- axes.c2p(get_x(), rt),- water_dot.get_center(),- stroke_width=0,- ))- brace = always_redraw(- lambda: Brace(- brace_line, RIGHT, buff=SMALL_BUFF- )- )-- delta_T = TexMobject("\\Delta T")- delta_T.set_color(self.delta_T_color)- delta_T.add_updater(lambda m: m.next_to(- brace, RIGHT, SMALL_BUFF- ))-- self.add(brace_line)- self.play(- GrowFromCenter(brace),- Write(delta_T),- )- self.play(- ShowCreation(graph),- UpdateFromFunc(- water_dot,- lambda m: m.move_to(graph.get_end())- ),- run_time=10,- rate_func=linear,- )- self.wait()-- self.graph = graph- self.brace = brace- self.delta_T = delta_T-- def show_equation(self):- delta_T = self.delta_T-- equation = TexMobject(- "{d ({\\Delta T}) \\over dt} = -k \\cdot {\\Delta T}",- tex_to_color_map={- "{\\Delta T}": self.delta_T_color,- "-k": WHITE,- "=": WHITE,- }- )- equation.to_corner(UR)- equation.shift(LEFT)-- delta_T_parts = equation.get_parts_by_tex("\\Delta T")- eq_i = equation.index_of_part_by_tex("=")- deriv = equation[:eq_i]- prop_to = equation.get_part_by_tex("-k")- parts = VGroup(deriv, prop_to, delta_T_parts[1])-- words = TextMobject(- "Rate of change",- "is proportional to",- "itself",- )- words.scale(0.7)- words.next_to(equation, DOWN)- colors = [BLUE, WHITE, YELLOW]- for part, word, color in zip(parts, words, colors):- part.word = word- word.set_color(color)- word.save_state()- words[0].next_to(parts[0], DOWN)-- self.play(- TransformFromCopy(- VGroup(delta_T),- delta_T_parts,- ),- Write(VGroup(*filter(- lambda p: p not in delta_T_parts,- equation- )))- )-- rects = VGroup()- for part in parts:- rect = SurroundingRectangle(- part,- color=part.word.get_color(),- buff=SMALL_BUFF,- stroke_width=2,- )- anims = [- ShowCreation(rect),- FadeIn(part.word),- ]- if part is parts[1]:- anims.append(Restore(words[0]))- self.play(*anims)- rects.add(rect)-- self.play(FadeOut(rects, lag_ratio=0.2))-- self.equation = equation- self.equation_words = words-- def talk_through_examples(self):- dot = self.water_dot- graph = self.graph-- self.play(- MoveAlongPath(- dot, graph,- rate_func=lambda t: smooth(1 - t),- run_time=2,- )- )-- #- def get_slope_line(self, graph, x):- passdiff --git a/active_projects/ode/part2/pi_scenes.py b/active_projects/ode/part2/pi_scenes.pydeleted file mode 100644index c044996b1..000000000--- a/active_projects/ode/part2/pi_scenes.py+++ /dev/null@@ -1,142 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part2.wordy_scenes import WriteHeatEquationTemplate---class ReactionsToInitialHeatEquation(PiCreatureScene):- def construct(self):- randy = self.pi_creature- randy.set_color(BLUE_C)- randy.center()-- point = VectorizedPoint().next_to(randy, UL, LARGE_BUFF)- randy.add_updater(lambda r: r.look_at(point))-- self.play(randy.change, "horrified")- self.wait()- self.play(randy.change, "pondering")- self.wait()- self.play(- randy.change, "confused",- point.next_to, randy, UR, LARGE_BUFF,- )- self.wait(2)- self.play(- point.shift, 2 * DOWN,- randy.change, "horrified"- )- self.wait(4)---class ContrastPDEToODE(TeacherStudentsScene):- CONFIG = {- "random_seed": 2,- }-- def construct(self):- student = self.students[2]- pde, ode = words = VGroup(*[- TextMobject(- text + "\\\\",- "Differential\\\\",- "Equation"- )- for text in ("Partial", "Ordinary")- ])- pde[0].set_color(YELLOW)- ode[0].set_color(BLUE)- for word in words:- word.arrange(DOWN, aligned_edge=LEFT)-- words.arrange(RIGHT, buff=LARGE_BUFF)- words.next_to(student.get_corner(UR), UP, MED_LARGE_BUFF)- words.shift(UR)- lt = TexMobject("<")- lt.scale(1.5)- lt.move_to(Line(pde.get_right(), ode.get_left()))-- for pi in self.pi_creatures:- pi.add_updater(lambda p: p.look_at(pde))-- self.play(- FadeInFromDown(VGroup(words, lt)),- student.change, "raise_right_hand",- )- self.play(- self.get_student_changes("pondering", "pondering", "hooray"),- self.teacher.change, "happy"- )- self.wait(3)- self.play(- Swap(ode, pde),- self.teacher.change, "raise_right_hand",- self.get_student_changes(- "erm", "sassy", "confused"- )- )- self.look_at(words)- self.change_student_modes(- "thinking", "thinking", "tease",- )- self.wait(3)---class AskAboutWhereEquationComesFrom(TeacherStudentsScene, WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d1_equation()- equation.move_to(self.hold_up_spot, DOWN)-- self.play(- FadeInFromDown(equation),- self.teacher.change, "raise_right_hand"- )- self.student_says(- "Um...why?",- target_mode="sassy",- student_index=2,- bubble_kwargs={"direction": RIGHT},- )- self.change_student_modes(- "confused", "confused", "sassy",- )- self.wait()- self.play(- self.teacher.change, "pondering",- )- self.wait(2)---class AskWhyRewriteIt(TeacherStudentsScene):- def construct(self):- self.student_says(- "Why?", student_index=1,- bubble_kwargs={"height": 2, "width": 2},- )- self.students[1].bubble = None- self.teacher_says(- "One step closer\\\\to derivatives"- )- self.change_student_modes(- "thinking", "thinking", "thinking",- look_at_arg=4 * LEFT + 2 * UP- )- self.wait(2)---class ReferenceKhanVideo(TeacherStudentsScene):- def construct(self):- khan_logo = ImageMobject("KhanLogo")- khan_logo.set_height(1)- khan_logo.next_to(self.teacher, UP, buff=2)- khan_logo.shift(2 * LEFT)-- self.play(- self.teacher.change, "raise_right_hand",- )- self.change_student_modes(- "thinking", "pondering", "thinking",- look_at_arg=self.screen- )- self.wait()- self.play(FadeInFromDown(khan_logo))- self.look_at(self.screen)- self.wait(15)diff --git a/active_projects/ode/part2/shared_constructs.py b/active_projects/ode/part2/shared_constructs.pydeleted file mode 100644index 9418145ed..000000000--- a/active_projects/ode/part2/shared_constructs.py+++ /dev/null@@ -1,35 +0,0 @@-from manimlib.imports import *--TIME_COLOR = YELLOW-X_COLOR = GREEN---def get_heat_equation():- pass---def temperature_to_color(temp, min_temp=-1, max_temp=1):- colors = [BLUE, TEAL, GREEN, YELLOW, "#ff0000"]-- alpha = inverse_interpolate(min_temp, max_temp, temp)- index, sub_alpha = integer_interpolate(- 0, len(colors) - 1, alpha- )- return interpolate_color(- colors[index], colors[index + 1], sub_alpha- )---def two_d_temp_func(x, y, t):- return np.sum([- c * np.sin(f * var) * np.exp(-(f**2) * t)- for c, f, var in [- (0.2, 1, x),- (0.3, 3, x),- (0.02, 5, x),- (0.01, 7, x),- (0.5, 2, y),- (0.1, 10, y),- (0.01, 20, y),- ]- ])diff --git a/active_projects/ode/part2/staging.py b/active_projects/ode/part2/staging.pydeleted file mode 100644index 7450c8232..000000000--- a/active_projects/ode/part2/staging.py+++ /dev/null@@ -1,794 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part1.staging import TourOfDifferentialEquations---class PartTwoOfTour(TourOfDifferentialEquations):- CONFIG = {- "zoomed_thumbnail_index": 1,- }-- def construct(self):- self.add_title()- self.show_thumbnails()- self.zoom_in_to_one_thumbnail()-- def zoom_in_to_one_thumbnail(self):- frame = self.camera_frame- thumbnails = self.thumbnails-- ode = TextMobject("Ordinary\\\\", "Differential Equation")- pde = TextMobject("Partial\\\\", "Differential Equation")- for word, thumbnail, vect in zip([ode, pde], thumbnails, [DOWN, UP]):- word.match_width(thumbnail)- word.next_to(thumbnail, vect)- ode[0].set_color(BLUE)- pde[0].set_color(YELLOW)-- self.add(ode)-- frame.save_state()- self.play(- frame.replace,- thumbnails[0],- run_time=1,- )- self.play(- Restore(frame, run_time=3),- )- self.play(- TransformFromCopy(ode, pde),- )- self.play(- ApplyMethod(- frame.replace, thumbnails[1],- path_arc=(-30 * DEGREES),- run_time=3- ),- )- self.wait()---class BrownianMotion(Scene):- CONFIG = {- "wait_time": 60,- "L": 3, # Box in [-L, L] x [-L, L]- "n_particles": 100,- "m1": 1,- "m2": 100,- "r1": 0.05,- "r2": 0.5,- "max_v": 5,- "random_seed": 2,- }-- def construct(self):- self.add_title()- self.add_particles()- self.wait(self.wait_time)-- def add_title(self):- square = Square(side_length=2 * self.L)- title = TextMobject("Brownian motion")- title.scale(1.5)- title.next_to(square, UP)-- self.add(square)- self.add(title)-- def add_particles(self):- m1 = self.m1- m2 = self.m2- r1 = self.r1- r2 = self.r2- L = self.L- max_v = self.max_v- n_particles = self.n_particles-- lil_particles = VGroup(*[- self.get_particle(m1, r1, L, max_v)- for k in range(n_particles)- ])- big_particle = self.get_particle(m2, r2, L=r2, max_v=0)- big_particle.set_fill(YELLOW, 1)-- for p in lil_particles:- if self.are_colliding(p, big_particle):- lil_particles.remove(p)- all_particles = VGroup(big_particle, *lil_particles)- all_particles.add_updater(self.update_particles)-- path = self.get_traced_path(big_particle)-- self.add(all_particles)- self.add(path)-- self.particles = all_particles- self.big_particle = big_particle- self.path = path-- def get_particle(self, m, r, L, max_v):- dot = Dot(radius=r)- dot.set_fill(WHITE, 0.7)- dot.mass = m- dot.radius = r- dot.center = op.add(- np.random.uniform(-L + r, L - r) * RIGHT,- np.random.uniform(-L + r, L - r) * UP- )- dot.move_to(dot.center)- dot.velocity = rotate_vector(- np.random.uniform(0, max_v) * RIGHT,- np.random.uniform(0, TAU),- )- return dot-- def are_colliding(self, p1, p2):- d = get_norm(p1.get_center() - p2.get_center())- return (d < p1.radius + p2.radius)-- def get_traced_path(self, particle):- path = VMobject()- path.set_stroke(BLUE, 3)- path.start_new_path(particle.get_center())-- buff = 0.02-- def update_path(path):- new_point = particle.get_center()- if get_norm(new_point - path.get_last_point()) > buff:- path.add_line_to(new_point)-- path.add_updater(update_path)- return path-- def update_particles(self, particles, dt):- for p1 in particles:- p1.center += p1.velocity * dt-- # Check particle collisions- buff = 0.01- for p2 in particles:- if p1 is p2:- continue- v = p2.center - p1.center- dist = get_norm(v)- r_sum = p1.radius + p2.radius- diff = dist - r_sum- if diff < 0:- unit_v = v / dist- p1.center += (diff - buff) * unit_v / 2- p2.center += -(diff - buff) * unit_v / 2- u1 = p1.velocity- u2 = p2.velocity- m1 = p1.mass- m2 = p2.mass- v1 = (- (m2 * (u2 - u1) + m1 * u1 + m2 * u2) /- (m1 + m2)- )- v2 = (- (m1 * (u1 - u2) + m1 * u1 + m2 * u2) /- (m1 + m2)- )- p1.velocity = v1- p2.velocity = v2-- # Check edge collisions- r1 = p1.radius- c1 = p1.center- for i in [0, 1]:- if abs(c1[i]) + r1 > self.L:- c1[i] = np.sign(c1[i]) * (self.L - r1)- p1.velocity[i] *= -1 * op.mul(- np.sign(p1.velocity[i]),- np.sign(c1[i])- )-- for p in particles:- p.move_to(p.center)- return particles---class AltBrownianMotion(BrownianMotion):- CONFIG = {- "wait_time": 20,- "n_particles": 100,- "m2": 10,- }---class BlackScholes(AltBrownianMotion):- def construct(self):- # For some reason I'm amused by the thought- # Of this graph perfectly matching the Brownian- # Motion y-coordiante- self.add_title()- self.add_particles()- self.particles.set_opacity(0)- self.remove(self.path)- self.add_graph()- self.wait(self.wait_time)-- def add_title(self):- title = TextMobject("Black-Sholes equations")- title.scale(1.5)- title.next_to(2 * UP, UP)-- equation = TexMobject(- "{\\partial V \\over \\partial t}", "+",- "\\frac{1}{2} \\sigma^2 S^2",- "{\\partial^2 V \\over \\partial S^2}", "+",- "rS", "{\\partial V \\over \\partial S}",- "-rV", "=", "0",- )- equation.scale(0.8)- equation.next_to(title, DOWN)-- self.add(title)- self.add(equation)- self.title = title- self.equation = equation-- def add_graph(self):- axes = Axes(- x_min=-1,- x_max=20,- y_min=0,- y_max=10,- number_line_config={- "unit_size": 0.5,- },- )- axes.set_height(4)- axes.move_to(DOWN)-- def get_graph_point():- return axes.c2p(- self.get_time(),- 5 + 2 * self.big_particle.get_center()[1]- )-- graph = VMobject()- graph.match_style(self.path)- graph.start_new_path(get_graph_point())- graph.add_updater(- lambda g: g.add_line_to(get_graph_point())- )-- self.add(axes)- self.add(graph)---class ContrastChapters1And2(Scene):- def construct(self):- c1_frame, c2_frame = frames = VGroup(*[- ScreenRectangle(height=3.5)- for x in range(2)- ])- frames.arrange(RIGHT, buff=LARGE_BUFF)-- c1_title, c2_title = titles = VGroup(- TextMobject("Chapter 1"),- TextMobject("Chapter 2"),- )- titles.scale(1.5)-- ode, pde = des = VGroup(- TextMobject(- "Ordinary",- "Differential Equations\\\\",- "ODEs",- ),- TextMobject(- "Partial",- "Differential Equations\\\\",- "PDEs",- ),- )- ode[0].set_color(BLUE)- pde[0].set_color(YELLOW)- for de in des:- de[-1][0].match_color(de[0])- de[-1].scale(1.5, about_point=de.get_top())-- for title, frame, de in zip(titles, frames, des):- title.next_to(frame, UP)- de.match_width(frame)- de.next_to(frame, DOWN)-- lt = TexMobject("<")- lt.move_to(Line(ode.get_right(), pde.get_left()))- lt.scale(2, about_edge=UP)-- c1_words = TextMobject(- "They're", "really\\\\", "{}",- "freaking", "hard\\\\",- "to", "solve\\\\",- )- c1_words.set_height(0.5 * c1_frame.get_height())- c1_words.move_to(c1_frame)-- c2_words = TextMobject(- "They're", "really", "\\emph{really}\\\\",- "freaking", "hard\\\\",- "to", "solve\\\\",- )- c2_words.set_color_by_tex("\\emph", YELLOW)- c2_words.move_to(c2_frame)- edit_shift = MED_LARGE_BUFF * RIGHT- c2_edits = VGroup(- TextMobject("sometimes").next_to(- c2_words[1:3], UP,- aligned_edge=LEFT,- ),- Line(- c2_words[1].get_left(),- c2_words[2].get_right(),- stroke_width=8,- ),- TextMobject("not too").next_to(- c2_words[3], LEFT,- ),- Line(- c2_words[3].get_left(),- c2_words[3].get_right(),- stroke_width=8,- ),- )- c2_edits.set_color(RED)- c2_edits[2:].shift(edit_shift)-- self.add(titles)- self.add(frames)- self.add(des)-- self.wait()- self.play(LaggedStartMap(- FadeInFromDown, c1_words,- lag_ratio=0.1,- ))- self.wait()- # self.play(FadeIn(ode))- self.play(- # TransformFromCopy(ode, pde),- TransformFromCopy(c1_words, c2_words),- Write(lt)- )- self.wait()- self.play(- Write(c2_edits[:2], run_time=1),- )- self.play(- c2_words[3:5].shift, edit_shift,- Write(c2_edits[2:]),- run_time=1,- )- self.wait()---class ShowCubeFormation(ThreeDScene):- CONFIG = {- "camera_config": {- "shading_factor": 1.0,- },- "color": False,- }-- def construct(self):- light_source = self.camera.light_source- light_source.move_to(np.array([-6, -3, 6]))-- cube = Cube(- side_length=4,- fill_color=GREY,- stroke_color=WHITE,- stroke_width=0.5,- )- cube.set_fill(opacity=1)- if self.color:- # cube[0].set_color(BLUE)- # cube[1].set_color(RED)- # for face in cube[2:]:- # face.set_color([BLUE, RED])- cube.color_using_background_image("VerticalTempGradient")-- # light_source.next_to(cube, np.array([1, -1, 1]), buff=2)-- cube_3d = cube.copy()- cube_2d = cube_3d.copy().stretch(0, 2)- cube_1d = cube_2d.copy().stretch(0, 1)- cube_0d = cube_1d.copy().stretch(0, 0)-- cube.become(cube_0d)-- self.set_camera_orientation(- phi=70 * DEGREES,- theta=-145 * DEGREES,- )- self.begin_ambient_camera_rotation(rate=0.05)-- for target in [cube_1d, cube_2d, cube_3d]:- self.play(- Transform(cube, target, run_time=1.5)- )- self.wait(8)---class ShowCubeFormationWithColor(ShowCubeFormation):- CONFIG = {- "color": True,- }---class ShowRect(Scene):- CONFIG = {- "height": 1,- "width": 3,- }-- def construct(self):- rect = Rectangle(- height=self.height,- width=self.width,- )- rect.set_color(YELLOW)- self.play(ShowCreationThenFadeOut(rect))---class ShowSquare(ShowRect):- CONFIG = {- "height": 1,- "width": 1,- }---class ShowHLine(Scene):- def construct(self):- line = Line(LEFT, RIGHT)- line.set_color(BLUE)- self.play(ShowCreationThenFadeOut(line))---class ShowCross(Scene):- def construct(self):- cross = Cross(Square())- cross.set_width(3)- cross.set_height(1, stretch=True)- self.play(ShowCreation(cross))---class TwoBodyEquations(Scene):- def construct(self):- kw = {- "tex_to_color_map": {- "x_1": LIGHT_GREY,- "y_1": LIGHT_GREY,- "x_2": BLUE,- "y_2": BLUE,- "=": WHITE,- }- }- equations = VGroup(- TexMobject(- "{d^2 x_1 \\over dt^2}",- "=",- "{x_2 - x_1 \\over m_1 \\left(",- "(x_2 - x_1)^2 + (y_2 - y_1)^2",- "\\right)^{3/2}",- **kw- ),- TexMobject(- "{d^2 y_1 \\over dt^2}",- "=",- "{y_2 - y_1 \\over m_1 \\left(",- "(x_2 - x_1)^2 + (y_2 - y_1)^2",- "\\right)^{3/2}",- **kw- ),- TexMobject(- "{d^2 x_2 \\over dt^2}",- "=",- "{x_1 - x_2 \\over m_2 \\left(",- "(x_2 - x_1)^2 + (y_2 - y_1)^2",- "\\right)^{3/2}",- **kw- ),- TexMobject(- "{d^2 y_2 \\over dt^2}",- "=",- "{y_1 - y_2 \\over m_2 \\left(",- "(x_2 - x_1)^2 + (y_2 - y_1)^2",- "\\right)^{3/2}",- **kw- ),- )-- equations.arrange(DOWN, buff=LARGE_BUFF)- equations.set_height(6)- equations.to_edge(LEFT)-- variables = VGroup()- lhss = VGroup()- rhss = VGroup()- for equation in equations:- variable = equation[1]- lhs = equation[:4]- rhs = equation[4:]- variables.add(variable)- lhss.add(lhs)- rhss.add(rhs)- lhss_copy = lhss.copy()-- for variable, lhs in zip(variables, lhss):- variable.save_state()- variable.match_height(lhs)- variable.scale(0.7)- variable.move_to(lhs, LEFT)-- self.play(LaggedStart(*[- FadeInFrom(v, RIGHT)- for v in variables- ]))- self.wait()- self.play(- LaggedStartMap(Restore, variables),- FadeIn(- lhss_copy,- remover=True,- lag_ratio=0.1,- run_time=2,- )- )- self.add(lhss)- self.wait()- self.play(LaggedStartMap(- FadeIn, rhss- ))- self.wait()- self.play(- LaggedStart(*[- ShowCreationThenFadeAround(lhs[:3])- for lhs in lhss- ])- )- self.wait()- self.play(- LaggedStartMap(- ShowCreationThenFadeAround,- rhss,- )- )- self.wait()---class LaplacianIntuition(SpecialThreeDScene):- CONFIG = {- "three_d_axes_config": {- "x_min": -5,- "x_max": 5,- "y_min": -5,- "y_max": 5,- },- "surface_resolution": 32,- }-- def construct(self):- axes = self.get_axes()- axes.scale(0.5, about_point=ORIGIN)- self.set_camera_to_default_position()- self.begin_ambient_camera_rotation()-- def func(x, y):- return np.array([- x, y,- 2.7 + 0.5 * (np.sin(x) + np.cos(y)) -- 0.025 * (x**2 + y**2)- ])-- surface_config = {- "u_min": -5,- "u_max": 5,- "v_min": -5,- "v_max": 5,- "resolution": self.surface_resolution,- }- # plane = ParametricSurface(- # lambda u, v: np.array([u, v, 0]),- # **surface_config- # )- # plane.set_stroke(WHITE, width=0.1)- # plane.set_fill(WHITE, opacity=0.1)- plane = Square(- side_length=10,- stroke_width=0,- fill_color=WHITE,- fill_opacity=0.1,- )- plane.center()- plane.set_shade_in_3d(True)-- surface = ParametricSurface(- func, **surface_config- )- surface.set_stroke(BLUE, width=0.1)- surface.set_fill(BLUE, opacity=0.25)-- self.add(axes, plane, surface)-- point = VectorizedPoint(np.array([2, -2, 0]))- dot = Dot()- dot.set_color(GREEN)- dot.add_updater(lambda d: d.move_to(point))- line = always_redraw(lambda: DashedLine(- point.get_location(),- func(*point.get_location()[:2]),- background_image_file="VerticalTempGradient",- ))-- circle = Circle(radius=0.25)- circle.set_color(YELLOW)- circle.insert_n_curves(20)- circle.add_updater(lambda m: m.move_to(point))- circle.set_shade_in_3d(True)- surface_circle = always_redraw(- lambda: circle.copy().apply_function(- lambda p: func(*p[:2])- ).shift(- 0.02 * IN- ).color_using_background_image("VerticalTempGradient")- )-- self.play(FadeInFromLarge(dot))- self.play(ShowCreation(line))- self.play(TransformFromCopy(dot, circle))- self.play(- Transform(- circle.copy(),- surface_circle.copy().clear_updaters(),- remover=True,- )- )- self.add(surface_circle)-- self.wait()- for vect in [4 * LEFT, DOWN, 4 * RIGHT, UP]:- self.play(- point.shift, vect,- run_time=3,- )---class StrogatzMention(PiCreatureScene):- def construct(self):- self.show_book()- self.show_motives()- self.show_pages()-- def show_book(self):- morty = self.pi_creature- book = ImageMobject("InfinitePowers")- book.set_height(5)- book.to_edge(LEFT)-- steve = ImageMobject("Strogatz_by_bricks")- steve.set_height(5)- steve.to_edge(LEFT)-- name = TextMobject("Steven Strogatz")- name.match_width(steve)- name.next_to(steve, DOWN)-- self.think(- "Hmm...many good\\\\lessons here...",- run_time=1- )- self.wait()- self.play(FadeInFromDown(steve))- self.wait()- self.play(- FadeInFrom(book, DOWN),- steve.shift, 4 * RIGHT,- RemovePiCreatureBubble(- morty, target_mode="thinking"- )- )- self.wait(3)- self.play(- FadeOut(steve),- FadeOut(morty),- )-- self.book = book-- def show_motives(self):- motives = VGroup(- TextMobject("1) Scratch and itch"),- TextMobject("2) Make people love math"),- )- motives.scale(1.5)- motives.arrange(- DOWN, LARGE_BUFF,- aligned_edge=LEFT,- )- motives.move_to(- Line(- self.book.get_right(),- FRAME_WIDTH * RIGHT / 2- )- )- motives.to_edge(UP)-- for motive in motives:- self.play(FadeInFromDown(motive))- self.wait(2)- self.play(FadeOut(motives))-- def show_pages(self):- book = self.book- pages = Group(*[- ImageMobject("IP_Sample_Page{}".format(i))- for i in range(1, 4)- ])- for page in pages:- page.match_height(book)- page.next_to(book, RIGHT)-- last_page = VectorizedPoint()- for page in pages:- self.play(- FadeOut(last_page),- FadeIn(page)- )- self.wait()- last_page = page-- self.play(FadeOut(last_page))-- def create_pi_creature(self):- return Mortimer().to_corner(DR)---class Thumbnail(Scene):- def construct(self):- image = ImageMobject("HeatSurfaceExampleFlipped")- image.set_height(6.5)- image.to_edge(DOWN, buff=-SMALL_BUFF)- self.add(image)-- equation = TexMobject(- "{\\partial {T} \\over \\partial {t}}", "=",- "\\alpha", "\\nabla^2 {T}",- tex_to_color_map={- "{t}": YELLOW,- "{T}": RED,- }- )- equation.scale(2)- equation.to_edge(UP)-- self.add(equation)-- Group(equation, image).shift(1.5 * RIGHT)-- question = TextMobject("What is\\\\this?")- question.scale(2.5)- question.to_edge(LEFT)- arrow = Arrow(- question.get_top(),- equation.get_left(),- buff=0.5,- path_arc=-90 * DEGREES,- )- arrow.set_stroke(width=5)-- self.add(question, arrow)---class ShowNewton(Scene):- def construct(self):- pass---class ShowCupOfWater(Scene):- def construct(self):- passdiff --git a/active_projects/ode/part2/wordy_scenes.py b/active_projects/ode/part2/wordy_scenes.pydeleted file mode 100644index 861474ae4..000000000--- a/active_projects/ode/part2/wordy_scenes.py+++ /dev/null@@ -1,785 +0,0 @@-from manimlib.imports import *---class WriteHeatEquationTemplate(Scene):- CONFIG = {- "tex_mobject_config": {- "tex_to_color_map": {- "{T}": WHITE,- "{t}": YELLOW,- "{x}": GREEN,- "{y}": RED,- "{z}": BLUE,- "\\partial": WHITE,- "2": WHITE,- },- },- }-- def get_d1_equation(self):- return TexMobject(- "{\\partial {T} \\over \\partial {t}}({x}, {t})", "=",- "\\alpha \\cdot",- "{\\partial^2 {T} \\over \\partial {x}^2} ({x}, {t})",- **self.tex_mobject_config- )-- def get_d1_equation_without_inputs(self):- return TexMobject(- "{\\partial {T} \\over \\partial {t}}", "=",- "\\alpha \\cdot",- "{\\partial^2 {T} \\over \\partial {x}^2}",- **self.tex_mobject_config- )-- def get_d3_equation(self):- return TexMobject(- "{\\partial {T} \\over \\partial {t}}", "=",- "\\alpha \\left(",- "{\\partial^2 {T} \\over \\partial {x}^2} + ",- "{\\partial^2 {T} \\over \\partial {y}^2} + ",- "{\\partial^2 {T} \\over \\partial {z}^2}",- "\\right)",- **self.tex_mobject_config- )-- def get_general_equation(self):- return TexMobject(- "{\\partial {T} \\over \\partial {t}}", "=",- "\\alpha", "\\nabla^2 {T}",- **self.tex_mobject_config,- )-- def get_d3_equation_with_inputs(self):- return TexMobject(- "{\\partial {T} \\over \\partial {t}}",- "({x}, {y}, {z}, {t})", "=",- "\\alpha \\left(",- "{\\partial^2 {T} \\over \\partial {x}^2}",- "({x}, {y}, {z}, {t}) + ",- "{\\partial^2 {T} \\over \\partial {y}^2}",- "({x}, {y}, {z}, {t}) + ",- "{\\partial^2 {T} \\over \\partial {z}^2}",- "({x}, {y}, {z}, {t})",- "\\right)",- **self.tex_mobject_config- )-- def get_d1_words(self):- return TextMobject("Heat equation\\\\", "(1 dimension)")-- def get_d3_words(self):- return TextMobject("Heat equation\\\\", "(3 dimensions)")-- def get_d1_group(self):- group = VGroup(- self.get_d1_words(),- self.get_d1_equation(),- )- group.arrange(DOWN, buff=MED_LARGE_BUFF)- return group-- def get_d3_group(self):- group = VGroup(- self.get_d3_words(),- self.get_d3_equation(),- )- group.arrange(DOWN, buff=MED_LARGE_BUFF)- return group---class HeatEquationIntroTitle(WriteHeatEquationTemplate):- def construct(self):- scale_factor = 1.25- title = TextMobject("The Heat Equation")- title.scale(scale_factor)- title.to_edge(UP)-- equation = self.get_general_equation()- equation.scale(scale_factor)- equation.next_to(title, DOWN, MED_LARGE_BUFF)- equation.set_color_by_tex("{T}", RED)-- self.play(- FadeInFrom(title, DOWN),- FadeInFrom(equation, UP),- )- self.wait()---class BringTogether(Scene):- def construct(self):- arrows = VGroup(Vector(2 * RIGHT), Vector(2 * LEFT))- arrows.arrange(RIGHT, buff=2)- words = TextMobject("Bring together")[0]- words.next_to(arrows, DOWN)- words.save_state()- words.space_out_submobjects(1.2)-- self.play(- VFadeIn(words),- Restore(words),- arrows.arrange, RIGHT, {"buff": SMALL_BUFF},- VFadeIn(arrows),- )- self.play(FadeOut(words), FadeOut(arrows))---class FourierSeriesIntro(WriteHeatEquationTemplate):- def construct(self):- title_scale_value = 1.5-- title = TextMobject(- "Fourier ", "Series",- )- title.scale(title_scale_value)- title.to_edge(UP)- title.generate_target()-- details_coming = TextMobject("Details coming...")- details_coming.next_to(title.get_corner(DR), DOWN)- details_coming.set_color(LIGHT_GREY)-- # physics = TextMobject("Physics")- heat = TextMobject("Heat")- heat.scale(title_scale_value)- physics = self.get_general_equation()- physics.set_color_by_tex("{T}", RED)- arrow1 = Arrow(LEFT, RIGHT)- arrow2 = Arrow(LEFT, RIGHT)- group = VGroup(- heat, arrow1, physics, arrow2, title.target- )- group.arrange(RIGHT)- # physics.align_to(title.target, UP)- group.to_edge(UP)-- rot_square = Square()- rot_square.fade(1)- rot_square.add_updater(lambda m, dt: m.rotate(dt))-- def update_heat_colors(heat):- colors = [YELLOW, RED]- vertices = rot_square.get_vertices()- letters = heat.family_members_with_points()- for letter, vertex in zip(letters, vertices):- alpha = (normalize(vertex)[0] + 1) / 2- i, sa = integer_interpolate(0, len(colors) - 1, alpha)- letter.set_color(interpolate_color(- colors[i], colors[i + 1], alpha,- ))- heat.add_updater(update_heat_colors)-- image = ImageMobject("Joseph Fourier")- image.set_height(5)- image.next_to(title, DOWN, LARGE_BUFF)- image.to_edge(LEFT)- name = TextMobject("Joseph", "Fourier")- name.next_to(image, DOWN)-- bubble = ThoughtBubble(- height=2,- width=2.5,- direction=RIGHT,- )- bubble.set_fill(opacity=0)- bubble.set_stroke(WHITE)- bubble.set_stroke(BLACK, 5, background=True)- bubble.shift(heat.get_center() - bubble.get_bubble_center())- bubble[:-1].shift(LEFT + 0.2 * DOWN)- bubble[:-1].rotate(-20 * DEGREES)- for mob in bubble[:-1]:- mob.rotate(20 * DEGREES)-- # self.play(FadeInFromDown(title))- self.add(title)- self.play(- FadeInFromDown(image),- TransformFromCopy(- title.get_part_by_tex("Fourier"),- name.get_part_by_tex("Fourier"),- path_arc=90 * DEGREES,- ),- FadeIn(name.get_part_by_tex("Joseph")),- )- self.play(Write(details_coming, run_time=1))- self.play(LaggedStartMap(FadeOut, details_coming[0], run_time=1))- self.wait()- self.add(rot_square)- self.play(- FadeInFrom(physics, RIGHT),- GrowArrow(arrow2),- FadeInFrom(heat, RIGHT),- GrowArrow(arrow1),- MoveToTarget(title),- )- self.play(ShowCreation(bubble))- self.wait(10)---class CompareODEToPDE(Scene):- def construct(self):- pass---class TodaysTargetWrapper(Scene):- def construct(self):- pass---class TwoGraphTypeTitles(Scene):- def construct(self):- left_title = TextMobject(- "Represent time\\\\with actual time"- )- left_title.shift(FRAME_WIDTH * LEFT / 4)- right_title = TextMobject(- "Represent time\\\\with an axis"- )- right_title.shift(FRAME_WIDTH * RIGHT / 4)-- titles = VGroup(left_title, right_title)- for title in titles:- title.scale(1.25)- title.to_edge(UP)-- self.play(FadeInFromDown(right_title))- self.wait()- self.play(FadeInFromDown(left_title))- self.wait()---class ShowPartialDerivativeSymbols(Scene):- def construct(self):- t2c = {- "{x}": GREEN,- "{t}": YELLOW,- }- d_derivs, del_derivs = VGroup(*[- VGroup(*[- TexMobject(- "{" + sym, "T", "\\over", sym, var + "}",- "(", "{x}", ",", "{t}", ")",- ).set_color_by_tex_to_color_map(t2c)- for var in ("{x}", "{t}")- ])- for sym in ("d", "\\partial")- ])- dTdx, dTdt = d_derivs- delTdelx, delTdelx = del_derivs- dels = VGroup(*it.chain(*[- del_deriv.get_parts_by_tex("\\partial")- for del_deriv in del_derivs- ]))-- dTdx.to_edge(UP)- self.play(FadeInFrom(dTdx, DOWN))- self.wait()- self.play(ShowCreationThenFadeAround(dTdx[3:5]))- self.play(ShowCreationThenFadeAround(dTdx[:2]))- self.wait()-- dTdt.move_to(dTdx)- self.play(- dTdx.next_to, dTdt, RIGHT, {"buff": 1.5},- dTdx.set_opacity, 0.5,- FadeInFromDown(dTdt)- )- self.wait()-- for m1, m2 in zip(d_derivs, del_derivs):- m2.move_to(m1)-- pd_words = TextMobject("Partial derivatives")- pd_words.next_to(del_derivs, DOWN, MED_LARGE_BUFF)-- self.play(- Write(pd_words),- dTdx.set_opacity, 1,- run_time=1,- )- self.wait()- self.play(- ReplacementTransform(d_derivs, del_derivs)- )- self.play(- LaggedStartMap(- ShowCreationThenFadeAround,- dels,- surrounding_rectangle_config={- "color": BLUE,- "buff": 0.5 * SMALL_BUFF,- "stroke_width": 2,- }- )- )- self.wait()-- num_words = VGroup(*[- TextMobject(- "Change in $T$\\\\caused by {}",- "$\\partial$", "${}$".format(var),- arg_separator="",- ).set_color_by_tex_to_color_map(t2c)- for var in ("{x}", "{t}")- ])- num_words.scale(0.8)- for word, deriv in zip(num_words, del_derivs):- num = deriv[:2]- word.move_to(num, UP)- word.to_edge(UP, buff=MED_SMALL_BUFF)- deriv.rect = SurroundingRectangle(- num,- buff=SMALL_BUFF,- stroke_width=2,- color=word[-1].get_color(),- )- deriv.rect.mob = num- deriv.rect.add_updater(lambda r: r.move_to(r.mob))-- self.play(- Write(num_words[1]),- VGroup(del_derivs, pd_words).shift, DOWN,- ShowCreation(del_derivs[1].rect),- )- self.play(- Write(num_words[0]),- ShowCreation(del_derivs[0].rect),- )- self.wait()---class WriteHeatEquation(WriteHeatEquationTemplate):- def construct(self):- title = TextMobject("The Heat Equation")- title.to_edge(UP)-- equation = self.get_d1_equation()- equation.next_to(title, DOWN)-- eq_i = equation.index_of_part_by_tex("=")- dt_part = equation[:eq_i]- dx_part = equation[eq_i + 3:]- dt_rect = SurroundingRectangle(dt_part)- dt_rect.set_stroke(YELLOW, 2)- dx_rect = SurroundingRectangle(dx_part)- dx_rect.set_stroke(GREEN, 2)-- two_outlines = equation.get_parts_by_tex("2").copy()- two_outlines.set_stroke(YELLOW, 2)- two_outlines.set_fill(opacity=0)-- to_be_explained = TextMobject(- "To be explained shortly..."- )- to_be_explained.scale(0.7)- to_be_explained.next_to(equation, RIGHT, MED_LARGE_BUFF)- to_be_explained.fade(1)-- pde = TextMobject("Partial Differential Equation")- pde.move_to(title)-- del_outlines = equation.get_parts_by_tex("\\partial").copy()- del_outlines.set_stroke(YELLOW, 2)- del_outlines.set_fill(opacity=0)-- self.play(- FadeInFrom(title, 0.5 * DOWN),- FadeInFrom(equation, 0.5 * UP),- )- self.wait()- self.play(ShowCreation(dt_rect))- self.wait()- self.play(TransformFromCopy(dt_rect, dx_rect))- self.play(ShowCreationThenDestruction(two_outlines))- self.wait()- self.play(Write(to_be_explained, run_time=1))- self.wait(2)- self.play(- ShowCreationThenDestruction(- del_outlines,- lag_ratio=0.1,- )- )- self.play(- FadeOutAndShift(title, UP),- FadeInFrom(pde, DOWN),- FadeOut(dt_rect),- FadeOut(dx_rect),- )- self.wait()---class Show3DEquation(WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d3_equation_with_inputs()- equation.set_width(FRAME_WIDTH - 1)- inputs = VGroup(*it.chain(*[- equation.get_parts_by_tex(s)- for s in ["{x}", "{y}", "{z}", "{t}"]- ]))- inputs.sort()- equation.to_edge(UP)-- self.add(equation)- self.play(LaggedStartMap(- ShowCreationThenFadeAround, inputs,- surrounding_rectangle_config={- "buff": 0.05,- "stroke_width": 2,- }- ))- self.wait()---class Show1DAnd3DEquations(WriteHeatEquationTemplate):- def construct(self):- d1_group = self.get_d1_group()- d3_group = self.get_d3_group()- d1_words, d1_equation = d1_group- d3_words, d3_equation = d3_group-- groups = VGroup(d1_group, d3_group)- for group in groups:- group.arrange(DOWN, buff=MED_LARGE_BUFF)- groups.arrange(RIGHT, buff=1.5)- groups.to_edge(UP)-- d3_rhs = d3_equation[9:-2]- d3_brace = Brace(d3_rhs, DOWN)- nabla_words = TextMobject("Sometimes written as")- nabla_words.match_width(d3_brace)- nabla_words.next_to(d3_brace, DOWN)- nabla_exp = TexMobject(- "\\nabla^2 {T}",- **self.tex_mobject_config,- )- nabla_exp.next_to(nabla_words, DOWN)- # nabla_group = VGroup(nabla_words, nabla_exp)-- d1_group.save_state()- d1_group.center().to_edge(UP)-- self.play(- Write(d1_words),- FadeInFrom(d1_equation, UP),- run_time=1,- )- self.wait(2)- self.play(- Restore(d1_group),- FadeInFrom(d3_group, LEFT)- )- self.wait()- self.play(- GrowFromCenter(d3_brace),- Write(nabla_words),- TransformFromCopy(d3_rhs, nabla_exp),- run_time=1,- )- self.wait()---class D1EquationNoInputs(WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d1_equation_without_inputs()- equation.to_edge(UP)- # i1 = equation.index_of_part_by_tex("\\partial")- # i2 = equation.index_of_part_by_tex("\\cdot")- # equation[i1:i1 + 2].set_color(RED)- # equation[i2 + 1:i2 + 6].set_color(RED)- equation.set_color_by_tex("{T}", RED)- self.add(equation)---class AltHeatRHS(Scene):- def construct(self):- formula = TexMobject(- "{\\alpha \\over 2}", "\\Big(",- "T({x} - 1, {t}) + T({x} + 1, {t})"- "\\Big)",- tex_to_color_map={- "{x}": GREEN,- "{t}": YELLOW,- }- )- self.add(formula)---class CompareInputsOfGeneralCaseTo1D(WriteHeatEquation):- def construct(self):- three_d_expr, one_d_expr = [- TexMobject(- "{T}(" + inputs + ", {t})",- **self.tex_mobject_config,- )- for inputs in ["{x}, {y}, {z}", "{x}"]- ]- for expr in three_d_expr, one_d_expr:- expr.scale(2)- expr.to_edge(UP)-- x, y, z = [- three_d_expr.get_part_by_tex(letter)- for letter in ["x", "y", "z"]- ]-- self.play(FadeInFromDown(three_d_expr))- self.play(LaggedStartMap(- ShowCreationThenFadeAround,- VGroup(x, y, z)- ))- self.wait()- low = 3- high = -3- self.play(- ReplacementTransform(three_d_expr[:low], one_d_expr[:low]),- ReplacementTransform(three_d_expr[high:], one_d_expr[high:]),- three_d_expr[low:high].scale, 0,- )- self.wait()---class ShowLaplacian(WriteHeatEquation):- def construct(self):- equation = self.get_d3_equation()- equation.to_edge(UP, buff=MED_SMALL_BUFF)-- parts = VGroup()- plusses = VGroup()- for char in "xyz":- index = equation.index_of_part_by_tex(- "{" + char + "}"- )- part = equation[index - 6:index + 3]- rect = SurroundingRectangle(part)- rect.match_color(equation[index])- parts.add(part)- part.rect = rect- if char in "yz":- plus = equation[index - 8]- part.plus = plus- plusses.add(plus)-- lp = equation.get_part_by_tex("(")- rp = equation.get_part_by_tex(")")-- for part in parts:- part.rp = rp.copy()- part.rp.next_to(part, RIGHT, SMALL_BUFF)- part.rp.align_to(lp, UP)- rp.become(parts[0].rp)-- # Show new second derivatives- self.add(*equation)- self.remove(*plusses, *parts[1], *parts[2])- for part in parts[1:]:- self.play(- rp.become, part.rp,- FadeInFrom(part, LEFT),- Write(part.plus),- ShowCreation(part.rect),- )- self.play(- FadeOut(part.rect),- )- self.wait()-- # Show laplacian- brace = Brace(parts, DOWN)- laplacian = TexMobject("\\nabla^2", "T")- laplacian.next_to(brace, DOWN)- laplacian_name = TextMobject(- "``Laplacian''"- )- laplacian_name.next_to(laplacian, DOWN)-- T_parts = VGroup(*[part[3] for part in parts])- non_T_parts = VGroup(*[- VGroup(*part[:3], *part[4:])- for part in parts- ])-- self.play(GrowFromCenter(brace))- self.play(Write(laplacian_name))- self.play(- TransformFromCopy(non_T_parts, laplacian[0])- )- self.play(- TransformFromCopy(T_parts, laplacian[1])- )- self.wait(3)---class AskAboutActuallySolving(WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d1_equation()- equation.center()-- q1 = TextMobject("Solve for T?")- q1.next_to(equation, UP, LARGE_BUFF)- q2 = TextMobject("What does it \\emph{mean} to solve this?")- q2.next_to(equation, UP, LARGE_BUFF)- formula = TexMobject(- "T({x}, {t}) = \\sin\\big(a{x}\\big) e^{-\\alpha \\cdot a^2 {t}}",- tex_to_color_map={- "{x}": GREEN,- "{t}": YELLOW,- }- )- formula.next_to(equation, DOWN, LARGE_BUFF)- q3 = TextMobject("Is this it?")- arrow = Vector(LEFT, color=WHITE)- arrow.next_to(formula, RIGHT)- q3.next_to(arrow, RIGHT)-- self.add(equation)- self.play(FadeInFromDown(q1))- self.wait()- self.play(- FadeInFromDown(q2),- q1.shift, 1.5 * UP,- )- self.play(FadeInFrom(formula, UP))- self.play(- GrowArrow(arrow),- FadeInFrom(q3, LEFT)- )- self.wait()---class PDEPatreonEndscreen(PatreonEndScreen):- CONFIG = {- "specific_patrons": [- "Juan Benet",- "Vassili Philippov",- "Burt Humburg",- "Matt Russell",- "Scott Gray",- "soekul",- "Tihan Seale",- "Richard Barthel",- "Ali Yahya",- "dave nicponski",- "Evan Phillips",- "Graham",- "Joseph Kelly",- "Kaustuv DeBiswas",- "LambdaLabs",- "Lukas Biewald",- "Mike Coleman",- "Peter Mcinerney",- "Quantopian",- "Roy Larson",- "Scott Walter, Ph.D.",- "Yana Chernobilsky",- "Yu Jun",- "Jordan Scales",- "D. Sivakumar",- "Lukas -krtek.net- Novy",- "John Shaughnessy",- "Britt Selvitelle",- "David Gow",- "J",- "Jonathan Wilson",- "Joseph John Cox",- "Magnus Dahlström",- "Randy C. Will",- "Ryan Atallah",- "Luc Ritchie",- "1stViewMaths",- "Adrian Robinson",- "Alexis Olson",- "Andreas Benjamin Brössel",- "Andrew Busey",- "Ankalagon",- "Antoine Bruguier",- "Antonio Juarez",- "Arjun Chakroborty",- "Art Ianuzzi",- "Awoo",- "Bernd Sing",- "Boris Veselinovich",- "Brian Staroselsky",- "Chad Hurst",- "Charles Southerland",- "Chris Connett",- "Christian Kaiser",- "Clark Gaebel",- "Cooper Jones",- "Danger Dai",- "Dave B",- "Dave Kester",- "David B. Hill",- "David Clark",- "DeathByShrimp",- "Delton Ding",- "eaglle",- "emptymachine",- "Eric Younge",- "Eryq Ouithaqueue",- "Federico Lebron",- "Giovanni Filippi",- "Hal Hildebrand",- "Hitoshi Yamauchi",- "Isaac Jeffrey Lee",- "j eduardo perez",- "Jacob Magnuson",- "Jameel Syed",- "Jason Hise",- "Jeff Linse",- "Jeff Straathof",- "John Griffith",- "John Haley",- "John V Wertheim",- "Jonathan Eppele",- "Kai-Siang Ang",- "Kanan Gill",- "L0j1k",- "Lee Beck",- "Lee Redden",- "Linh Tran",- "Ludwig Schubert",- "Magister Mugit",- "Mark B Bahu",- "Mark Heising",- "Martin Price",- "Mathias Jansson",- "Matt Langford",- "Matt Roveto",- "Matthew Bouchard",- "Matthew Cocke",- "Michael Faust",- "Michael Hardel",- "Mirik Gogri",- "Mustafa Mahdi",- "Márton Vaitkus",- "Nero Li",- "Nikita Lesnikov",- "Omar Zrien",- "Owen Campbell-Moore",- "Peter Ehrnstrom",- "RedAgent14",- "rehmi post",- "Richard Burgmann",- "Richard Comish",- "Ripta Pasay",- "Rish Kundalia",- "Robert Teed",- "Roobie",- "Ryan Williams",- "Sachit Nagpal",- "Solara570",- "Stevie Metke",- "Tal Einav",- "Ted Suzman",- "Thomas Tarler",- "Tom Fleming",- "Valeriy Skobelev",- "Xavier Bernard",- "Yavor Ivanov",- "Yaw Etse",- "YinYangBalance.Asia",- "Zach Cardwell",- ],- }diff --git a/active_projects/ode/part3/discrete_case.py b/active_projects/ode/part3/discrete_case.pydeleted file mode 100644index 2c8ae08c0..000000000--- a/active_projects/ode/part3/discrete_case.py+++ /dev/null@@ -1,303 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part2.heat_equation import *---class ShowNewRuleAtDiscreteBoundary(DiscreteSetup):- CONFIG = {- "axes_config": {- "x_min": 0,- "stroke_width": 1,- "x_axis_config": {- "include_tip": False,- },- },- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- ],- "v_line_class": DashedLine,- "v_line_config": {-- },- "step_size": 1,- "wait_time": 15,- "alpha": 0.25,- }-- def construct(self):- self.add_axes()- self.set_points()- self.show_boundary_point_influenced_by_neighbor()- self.add_clock()- self.let_evolve()-- def set_points(self):- axes = self.axes- for mob in axes.family_members_with_points():- if isinstance(mob, Line):- mob.set_stroke(width=1)-- step_size = self.step_size- xs = np.arange(- axes.x_min,- axes.x_max + step_size,- step_size- )-- dots = self.dots = self.get_dots(axes, xs)- self.v_lines = self.get_v_lines(dots)- self.rod_pieces = self.get_rod_pieces(dots)-- # rod_pieces-- self.add(self.dots)- self.add(self.v_lines)- self.add(self.rod_pieces)-- def show_boundary_point_influenced_by_neighbor(self):- dots = self.dots- ld = dots[0]- ld_in = dots[1]- rd = dots[-1]- rd_in = dots[-2]- v_len = 0.75- l_arrow = Vector(v_len * LEFT)- l_arrow.move_to(ld.get_left(), RIGHT)- r_arrow = Vector(v_len * RIGHT)- r_arrow.move_to(rd.get_right(), LEFT)- arrows = VGroup(l_arrow, r_arrow)- q_marks = VGroup(*[- TexMobject("?").scale(1.5).next_to(- arrow, arrow.get_vector()- )- for arrow in arrows- ])-- arrows.set_color(YELLOW)- q_marks.set_color(YELLOW)-- blocking_rects = VGroup(*[- BackgroundRectangle(VGroup(- *dots[i:-i],- *self.rod_pieces[i:-i]- ))- for i in [1, 2]- ])- for rect in blocking_rects:- rect.stretch(1.1, dim=1, about_edge=UP)-- self.play(FadeIn(blocking_rects[0]))- self.play(- LaggedStartMap(ShowCreation, arrows),- LaggedStart(*[- FadeInFrom(q_mark, -arrow.get_vector())- for q_mark, arrow in zip(q_marks, arrows)- ]),- run_time=1.5- )- self.wait()-- # Point to inward neighbor- new_arrows = VGroup(*[- Arrow(- d1.get_center(),- VGroup(d1, d2).get_center(),- buff=0,- ).match_style(l_arrow)- for d1, d2 in [(ld, ld_in), (rd, rd_in)]- ])- new_arrows.match_style(arrows)-- l_brace = Brace(VGroup(ld, ld_in), DOWN)- r_brace = Brace(VGroup(rd, rd_in), DOWN)- braces = VGroup(l_brace, r_brace)- for brace in braces:- brace.align_to(- self.axes.x_axis.get_center(), UP- )- brace.shift(SMALL_BUFF * DOWN)- brace.add(brace.get_tex("\\Delta x"))-- self.play(- ReplacementTransform(arrows, new_arrows),- FadeOut(q_marks),- ReplacementTransform(*blocking_rects)- )- self.wait()- self.play(FadeInFrom(braces, UP))- self.wait()- self.play(- FadeOut(new_arrows),- FadeOut(blocking_rects[1]),- FadeOut(braces),- )-- def add_clock(self):- super().add_clock()- self.time_label.add_updater(- lambda d, dt: d.increment_value(dt)- )- VGroup(- self.clock,- self.time_label- ).shift(2 * LEFT)-- def let_evolve(self):- dots = self.dots- dots.add_updater(self.update_dots)-- wait_time = self.wait_time- self.play(- ClockPassesTime(- self.clock,- run_time=wait_time,- hours_passed=wait_time,- ),- )-- #-- def get_dots(self, axes, xs):- dots = VGroup(*[- Dot(axes.c2p(x, self.temp_func(x, 0)))- for x in xs- ])-- max_width = 0.8 * self.step_size- for dot in dots:- dot.add_updater(self.update_dot_color)- if dot.get_width() > max_width:- dot.set_width(max_width)-- return dots-- def get_v_lines(self, dots):- return always_redraw(lambda: VGroup(*[- self.get_v_line(dot)- for dot in dots- ]))-- def get_v_line(self, dot):- x_axis = self.axes.x_axis- bottom = dot.get_bottom()- x = x_axis.p2n(bottom)- proj_point = x_axis.n2p(x)- return self.v_line_class(- proj_point, bottom,- **self.v_line_config,- )-- def get_rod_pieces(self, dots):- axis = self.axes.x_axis- factor = 1 - np.exp(-(0.8 / self.step_size)**2)- width = factor * self.step_size-- pieces = VGroup()- for dot in dots:- piece = Line(ORIGIN, width * RIGHT)- piece.set_stroke(width=5)- piece.move_to(dot)- piece.set_y(axis.get_center()[1])- piece.dot = dot- piece.add_updater(- lambda p: p.match_color(p.dot)- )- pieces.add(piece)- return pieces-- def update_dot_color(self, dot):- y = self.axes.y_axis.p2n(dot.get_center())- dot.set_color(self.y_to_color(y))-- def update_dots(self, dots, dt):- for ds in zip(dots, dots[1:], dots[2:]):- points = [d.get_center() for d in ds]- x0, x1, x2 = [p[0] for p in points]- dx = x1 - x0- y0, y1, y2 = [p[1] for p in points]-- self.update_dot(- dot=ds[1],- dt=dt,- mean_diff=0.5 * (y2 - 2 * y1 + y0) / dx- )- if ds[0] is dots[0]:- self.update_dot(- dot=ds[0],- dt=dt,- mean_diff=(y1 - y0) / dx- )- elif ds[-1] is dots[-1]:- self.update_dot(- dot=ds[-1],- dt=dt,- mean_diff=(y1 - y2) / dx- )-- def update_dot(self, dot, dt, mean_diff):- dot.shift(mean_diff * self.alpha * dt * UP)---class DiscreteEvolutionPoint25(ShowNewRuleAtDiscreteBoundary):- CONFIG = {- "step_size": 0.25,- "alpha": 0.5,- "wait_time": 30,- }-- def construct(self):- self.add_axes()- self.set_points()- self.add_clock()- self.let_evolve()---class DiscreteEvolutionPoint1(DiscreteEvolutionPoint25):- CONFIG = {- "step_size": 0.1,- "v_line_config": {- "stroke_width": 1,- },- "wait_time": 30,- }---class FlatEdgesForDiscreteEvolution(DiscreteEvolutionPoint1):- CONFIG = {- "wait_time": 20,- "step_size": 0.1,- }-- def let_evolve(self):- lines = VGroup(*[- Line(LEFT, RIGHT)- for x in range(2)- ])- lines.set_width(1.5)- lines.set_stroke(WHITE, 5, opacity=0.5)- lines.add_updater(self.update_lines)-- turn_animation_into_updater(- ShowCreation(lines, run_time=2)- )- self.add(lines)-- super().let_evolve()-- def update_lines(self, lines):- dots = self.dots- for line, dot in zip(lines, [dots[0], dots[-1]]):- line.move_to(dot)---class FlatEdgesForDiscreteEvolutionTinySteps(FlatEdgesForDiscreteEvolution):- CONFIG = {- "step_size": 0.025,- "wait_time": 10,- "v_line_class": Line,- "v_line_config": {- "stroke_opacity": 0.5,- }- }diff --git a/active_projects/ode/part3/pi_creature_scenes.py b/active_projects/ode/part3/pi_creature_scenes.pydeleted file mode 100644index 61b8f7c09..000000000--- a/active_projects/ode/part3/pi_creature_scenes.py+++ /dev/null@@ -1,175 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part2.wordy_scenes 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)---class InFouriersShoes(PiCreatureScene, WriteHeatEquationTemplate):- def construct(self):- randy = self.pi_creature- fourier = ImageMobject("Joseph Fourier")- fourier.set_height(4)- fourier.next_to(randy, RIGHT, LARGE_BUFF)- fourier.align_to(randy, DOWN)-- equation = self.get_d1_equation()- equation.next_to(fourier, UP, MED_LARGE_BUFF)-- decades = list(range(1740, 2040, 20))- time_line = NumberLine(- x_min=decades[0],- x_max=decades[-1],- tick_frequency=1,- tick_size=0.05,- longer_tick_multiple=4,- unit_size=0.2,- numbers_with_elongated_ticks=decades,- numbers_to_show=decades,- decimal_number_config={- "group_with_commas": False,- },- stroke_width=2,- )- time_line.add_numbers()- time_line.move_to(ORIGIN, RIGHT)- time_line.to_edge(UP)- triangle = ArrowTip(start_angle=-90 * DEGREES)- triangle.set_height(0.25)- triangle.move_to(time_line.n2p(2019), DOWN)- triangle.set_color(WHITE)-- self.play(FadeInFrom(fourier, 2 * LEFT))- self.play(randy.change, "pondering")- self.wait()- self.play(- DrawBorderThenFill(triangle, run_time=1),- FadeInFromDown(equation),- FadeIn(time_line),- )- self.play(- Animation(triangle),- ApplyMethod(- time_line.shift,- time_line.n2p(2019) - time_line.n2p(1822),- run_time=5- ),- )- self.wait()---class SineCurveIsUnrealistic(TeacherStudentsScene):- def construct(self):- self.student_says(- "But that would\\\\never happen!",- student_index=1,- bubble_kwargs={- "direction": RIGHT,- "height": 3,- "width": 4,- },- target_mode="angry"- )- self.change_student_modes(- "guilty", "angry", "hesitant",- added_anims=[- self.teacher.change, "tease"- ]- )- self.wait(3)- self.play(- RemovePiCreatureBubble(self.students[1]),- self.teacher.change, "raise_right_hand"- )- self.change_all_student_modes(- "pondering",- look_at_arg=3 * UP,- )- self.wait(5)---class IfOnly(TeacherStudentsScene):- def construct(self):- self.teacher_says(- "If only!",- target_mode="angry"- )- self.change_all_student_modes(- "confused",- look_at_arg=self.screen- )- self.wait(3)---class SoWeGotNowhere(TeacherStudentsScene):- def construct(self):- self.student_says(- "So we've gotten\\\\nowhere!",- target_mode="angry",- added_anims=[- self.teacher.change, "guilty"- ]- )- self.change_all_student_modes("angry")- self.wait()- text = TexMobject(- "&\\text{Actually,}\\\\",- "&\\sin\\left({x}\\right)"- "e^{-\\alpha {t}}\\\\",- "&\\text{isn't far off.}",- tex_to_color_map={- "{x}": GREEN,- "{t}": YELLOW,- }- )- text.scale(0.8)- self.teacher_says(- text,- content_introduction_class=FadeIn,- bubble_kwargs={- "width": 4,- "height": 3.5,- }- )- self.change_all_student_modes(- "pondering",- look_at_arg=self.screen- )- self.wait(3)diff --git a/active_projects/ode/part3/staging.py b/active_projects/ode/part3/staging.pydeleted file mode 100644index e7cc4871a..000000000--- a/active_projects/ode/part3/staging.py+++ /dev/null@@ -1,1230 +0,0 @@-from manimlib.imports import *--from active_projects.ode.part2.fourier_series import FourierOfTrebleClef---class FourierNameIntro(Scene):- def construct(self):- self.show_two_titles()- self.transition_to_image()- self.show_paper()-- def show_two_titles(self):- lt = TextMobject("Fourier", "Series")- rt = TextMobject("Fourier", "Transform")- lt_variants = VGroup(- TextMobject("Complex", "Fourier Series"),- TextMobject("Discrete", "Fourier Series"),- )- rt_variants = VGroup(- TextMobject("Discrete", "Fourier Transform"),- TextMobject("Fast", "Fourier Transform"),- TextMobject("Quantum", "Fourier Transform"),- )-- titles = VGroup(lt, rt)- titles.scale(1.5)- for title, vect in (lt, LEFT), (rt, RIGHT):- title.move_to(vect * FRAME_WIDTH / 4)- title.to_edge(UP)-- for title, variants in (lt, lt_variants), (rt, rt_variants):- title.save_state()- title.target = title.copy()- title.target.scale(1 / 1.5, about_edge=RIGHT)- for variant in variants:- variant.move_to(title.target, UR)- variant[0].set_color(YELLOW)-- v_line = Line(UP, DOWN)- v_line.set_height(FRAME_HEIGHT)- v_line.set_stroke(WHITE, 2)-- self.play(- FadeInFrom(lt, RIGHT),- ShowCreation(v_line)- )- self.play(- FadeInFrom(rt, LEFT),- )- # Edit in images of circle animations- # and clips from FT video-- # for title, variants in (rt, rt_variants), (lt, lt_variants):- for title, variants in [(rt, rt_variants)]:- # Maybe do it for left variant, maybe not...- self.play(- MoveToTarget(title),- FadeInFrom(variants[0][0], LEFT)- )- for v1, v2 in zip(variants, variants[1:]):- self.play(- FadeOutAndShift(v1[0], UP),- FadeInFrom(v2[0], DOWN),- run_time=0.5,- )- self.wait(0.5)- self.play(- Restore(title),- FadeOut(variants[-1][0])- )- self.wait()-- self.titles = titles- self.v_line = v_line-- def transition_to_image(self):- titles = self.titles- v_line = self.v_line-- image = ImageMobject("Joseph Fourier")- image.set_height(5)- image.to_edge(LEFT)-- frame = Rectangle()- frame.replace(image, stretch=True)-- name = TextMobject("Joseph", "Fourier")- fourier_part = name.get_part_by_tex("Fourier")- fourier_part.set_color(YELLOW)- F_sym = fourier_part[0]- name.match_width(image)- name.next_to(image, DOWN)-- self.play(- ReplacementTransform(v_line, frame),- FadeIn(image),- FadeIn(name[0]),- *[- ReplacementTransform(- title[0].deepcopy(),- name[1]- )- for title in titles- ],- titles.scale, 0.65,- titles.arrange, DOWN,- titles.next_to, image, UP,- )- self.wait()-- big_F = F_sym.copy()- big_F.set_fill(opacity=0)- big_F.set_stroke(WHITE, 2)- big_F.set_height(3)- big_F.move_to(midpoint(- image.get_right(),- RIGHT_SIDE,- ))- big_F.shift(DOWN)- equivalence = VGroup(- fourier_part.copy().scale(1.25),- TexMobject("\\Leftrightarrow").scale(1.5),- TextMobject("Break down into\\\\pure frequencies"),- )- equivalence.arrange(RIGHT)- equivalence.move_to(big_F)- equivalence.to_edge(UP)-- self.play(- FadeIn(big_F),- TransformFromCopy(fourier_part, equivalence[0]),- Write(equivalence[1:]),- )- self.wait(3)- self.play(FadeOut(VGroup(big_F, equivalence)))-- self.image = image- self.name = name-- def show_paper(self):- image = self.image- paper = ImageMobject("Fourier paper")- paper.match_height(image)- paper.next_to(image, RIGHT, MED_LARGE_BUFF)-- date = TexMobject("1822")- date.next_to(paper, DOWN)- date_rect = SurroundingRectangle(date)- date_rect.scale(0.3)- date_rect.set_color(RED)- date_rect.shift(1.37 * UP + 0.08 * LEFT)- date_arrow = Arrow(- date_rect.get_bottom(),- date.get_top(),- buff=SMALL_BUFF,- color=date_rect.get_color(),- )-- heat_rect = SurroundingRectangle(- TextMobject("CHALEUR")- )- heat_rect.set_color(RED)- heat_rect.scale(0.6)- heat_rect.move_to(- paper.get_top() +- 1.22 * DOWN + 0.37 * RIGHT- )- heat_word = TextMobject("Heat")- heat_word.scale(1.5)- heat_word.next_to(paper, UP)- heat_word.shift(paper.get_width() * RIGHT)- heat_arrow = Arrow(- heat_rect.get_top(),- heat_word.get_left(),- buff=0.1,- path_arc=-60 * DEGREES,- color=heat_rect.get_color(),- )-- self.play(FadeInFrom(paper, LEFT))- self.play(- ShowCreation(date_rect),- )- self.play(- GrowFromPoint(date, date_arrow.get_start()),- ShowCreation(date_arrow),- )- self.wait(3)-- # Insert animation of circles/sine waves- # approximating a square wave-- self.play(- ShowCreation(heat_rect),- )- self.play(- GrowFromPoint(heat_word, heat_arrow.get_start()),- ShowCreation(heat_arrow),- )- self.wait(3)---class ManyCousinsOfFourierThings(Scene):- def construct(self):- series_variants = VGroup(- TextMobject("Complex", "Fourier Series"),- TextMobject("Discrete", "Fourier Series"),- )- transform_variants = VGroup(- TextMobject("Discrete", "Fourier Transform"),- TextMobject("Fast", "Fourier Transform"),- TextMobject("Quantum", "Fourier Transform"),- )- groups = VGroup(series_variants, transform_variants)- for group, vect in zip(groups, [LEFT, RIGHT]):- group.scale(0.7)- group.arrange(DOWN, aligned_edge=LEFT)- group.move_to(- vect * FRAME_WIDTH / 4- )- group.set_color(YELLOW)-- self.play(*[- LaggedStartMap(FadeIn, group)- for group in groups- ])- self.play(*[- LaggedStartMap(FadeOut, group)- for group in groups- ])---class FourierSeriesIllustraiton(Scene):- CONFIG = {- "n_range": range(1, 31, 2),- "axes_config": {- "number_line_config": {- "include_tip": False,- },- "x_axis_config": {- "tick_frequency": 1 / 4,- "unit_size": 4,- },- "x_min": 0,- "x_max": 1,- "y_min": -1,- "y_max": 1,- }- }-- def construct(self):- n_range = self.n_range-- axes1 = Axes(**self.axes_config)- axes1.x_axis.add_numbers(- 0.5, 1,- number_config={"num_decimal_places": 1}- )- axes2 = axes1.copy()- target_func_graph = self.get_target_func_graph(axes2)- axes2.add(target_func_graph)-- arrow = Arrow(LEFT, RIGHT, color=WHITE)- group = VGroup(axes1, arrow, axes2)- group.arrange(RIGHT, buff=LARGE_BUFF)- group.shift(2 * UP)- group.shift_onto_screen()-- sine_graphs = VGroup(*[- axes1.get_graph(self.generate_nth_func(n))- for n in n_range- ])- sine_graphs.set_stroke(width=3)- sine_graphs.set_color_by_gradient(- BLUE, GREEN, RED, YELLOW, PINK,- BLUE, GREEN, RED, YELLOW, PINK,- )-- partial_sums = VGroup(*[- 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 = self.get_sum_tex()- sum_tex.next_to(axes1, DOWN, LARGE_BUFF)- sum_tex.shift(RIGHT)- eq = TexMobject("=")- 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(- 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(piece)- for piece in self.get_sum_tex_pieces(sum_tex)- ],- it.cycle([None])- )-- self.add(axes1, arrow, axes2)- 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)- for sine_graph, partial_sum, rect in zip(sine_graphs, partial_sums, rects):- anims1 = [- ShowCreation(sine_graph)- ]- partial_sum.set_stroke(BLACK, 4, background=True)- anims2 = [- curr_partial_sum.set_stroke,- {"width": 1, "opacity": 0.5},- curr_partial_sum.set_stroke,- {"width": 0, "background": True},- ReplacementTransform(- sine_graph, partial_sum,- remover=True- ),- ]- if rect:- rect.match_style(sine_graph)- anims1.append(ShowCreation(rect))- anims2.append(FadeOut(rect))- self.play(*anims1)- 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),- "axes_config": {- "y_axis_config": {- "unit_size": 2,- "tick_frequency": 0.25,- "numbers_with_elongated_ticks": [-1, 1],- }- }- }-- 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 = {- "height": 3,- "n_circles": 200,- "run_time": 10,- "arrow_config": {- "tip_length": 0.1,- "stroke_width": 2,- }- }-- def get_shape(self):- path = VMobject()- shape = TextMobject("F")- for sp in shape.family_members_with_points():- path.append_points(sp.points)- return path---class ExponentialDecay(PiCreatureScene):- def construct(self):- k = 0.2- mk_tex = "-0.2"- mk_tex_color = GREEN- t2c = {mk_tex: mk_tex_color}-- # Pi creature- randy = self.pi_creature- randy.flip()- randy.set_height(2.5)- randy.move_to(3 * RIGHT)- randy.to_edge(DOWN)- bubble = ThoughtBubble(- direction=LEFT,- height=3.5,- width=3,- )- bubble.pin_to(randy)- bubble.set_fill(DARKER_GREY)- exp = TexMobject(- "Ce^{", mk_tex, "t}",- tex_to_color_map=t2c,- )- exp.move_to(bubble.get_bubble_center())-- # Setup axes- axes = Axes(- x_min=0,- x_max=13,- y_min=-4,- y_max=4,- )- axes.set_stroke(width=2)- axes.set_color(LIGHT_GREY)- axes.scale(0.9)- axes.to_edge(LEFT, buff=LARGE_BUFF)- axes.x_axis.add_numbers()- axes.y_axis.add_numbers()- axes.y_axis.add_numbers(0)- axes.x_axis.add(- TextMobject("Time").next_to(- axes.x_axis.get_end(), DR,- )- )- axes.y_axis.add(- TexMobject("f").next_to(- axes.y_axis.get_corner(UR), RIGHT,- ).set_color(YELLOW)- )- axes.x_axis.set_opacity(0)-- # Value trackers- y_tracker = ValueTracker(3)- x_tracker = ValueTracker(0)- dydt_tracker = ValueTracker()- dxdt_tracker = ValueTracker(0)- self.add(- y_tracker, x_tracker,- dydt_tracker, dxdt_tracker,- )-- get_y = y_tracker.get_value- get_x = x_tracker.get_value- get_dydt = dydt_tracker.get_value- get_dxdt = dxdt_tracker.get_value-- dydt_tracker.add_updater(lambda m: m.set_value(- - k * get_y()- ))- y_tracker.add_updater(lambda m, dt: m.increment_value(- dt * get_dydt()- ))- x_tracker.add_updater(lambda m, dt: m.increment_value(- dt * get_dxdt()- ))-- # Tip/decimal- tip = ArrowTip(color=YELLOW)- tip.set_width(0.25)- tip.add_updater(lambda m: m.move_to(- axes.c2p(get_x(), get_y()), LEFT- ))- decimal = DecimalNumber()- decimal.add_updater(lambda d: d.set_value(get_y()))- decimal.add_updater(lambda d: d.next_to(- tip, RIGHT,- SMALL_BUFF,- ))-- # Rate of change arrow- arrow = Vector(- DOWN, color=RED,- max_stroke_width_to_length_ratio=50,- max_tip_length_to_length_ratio=0.2,- )- arrow.set_stroke(width=4)- arrow.add_updater(lambda m: m.scale(- 2.5 * abs(get_dydt()) / m.get_length()- ))- arrow.add_updater(lambda m: m.move_to(- tip.get_left(), UP- ))-- # Graph- graph = TracedPath(tip.get_left)-- # Equation- ode = TexMobject(- "{d{f} \\over dt}(t)",- "=", mk_tex, "\\cdot {f}(t)",- tex_to_color_map={- "{f}": YELLOW,- "=": WHITE,- mk_tex: mk_tex_color- }- )- ode.to_edge(UP)- dfdt = ode[:3]- ft = ode[-2:]-- self.add(axes)- self.add(tip)- self.add(decimal)- self.add(arrow)- self.add(randy)- self.add(ode)-- # Show rate of change dependent on itself- rect = SurroundingRectangle(dfdt)- self.play(ShowCreation(rect))- self.wait()- self.play(- Transform(- rect,- SurroundingRectangle(ft)- )- )- self.wait(3)-- # Show graph over time- self.play(- DrawBorderThenFill(bubble),- Write(exp),- FadeOut(rect),- randy.change, "thinking",- )- axes.x_axis.set_opacity(1)- self.play(- y_tracker.set_value, 3,- ShowCreation(axes.x_axis),- )- dxdt_tracker.set_value(1)- self.add(graph)- randy.add_updater(lambda r: r.look_at(tip))- self.wait(4)-- # Show derivative of exponential- eq = TexMobject("=")- eq.next_to(ode.get_part_by_tex("="), DOWN, LARGE_BUFF)- exp.generate_target()- exp.target.next_to(eq, LEFT)- d_dt = TexMobject("{d \\over dt}")- d_dt.next_to(exp.target, LEFT)- const = TexMobject(mk_tex)- const.set_color(mk_tex_color)- dot = TexMobject("\\cdot")- const.next_to(eq, RIGHT)- dot.next_to(const, RIGHT, 2 * SMALL_BUFF)- exp_copy = exp.copy()- exp_copy.next_to(dot, RIGHT, 2 * SMALL_BUFF)- VGroup(const, dot, eq).align_to(exp_copy, DOWN)-- self.play(- MoveToTarget(exp),- FadeOut(bubble),- FadeIn(d_dt),- FadeIn(eq),- )- self.wait(2)- self.play(- ApplyMethod(- exp[1].copy().replace,- const[0],- )- )- self.wait()- rect = SurroundingRectangle(exp)- rect.set_stroke(BLUE, 2)- self.play(FadeIn(rect))- self.play(- Write(dot),- TransformFromCopy(exp, exp_copy),- rect.move_to, exp_copy- )- self.play(FadeOut(rect))- self.wait(5)---class InvestmentGrowth(Scene):- CONFIG = {- "output_tex": "{M}",- "output_color": GREEN,- "initial_value": 1,- "initial_value_tex": "{M_0}",- "k": 0.05,- "k_tex": "0.05",- "total_time": 43,- "time_rate": 3,- }-- def construct(self):- # Axes- axes = Axes(- x_min=0,- x_max=self.total_time,- y_min=0,- y_max=6,- x_axis_config={- "unit_size": 0.3,- "tick_size": 0.05,- "numbers_with_elongated_ticks": range(- 0, self.total_time, 5- )- }- )- axes.to_corner(DL, buff=LARGE_BUFF)-- time_label = TextMobject("Time")- time_label.next_to(- axes.x_axis.get_right(),- UP, MED_LARGE_BUFF- )- time_label.shift_onto_screen()- axes.x_axis.add(time_label)- money_label = TexMobject(self.output_tex)- money_label.set_color(self.output_color)- money_label.next_to(- axes.y_axis.get_top(),- UP,- )- axes.y_axis.add(money_label)-- # Graph- graph = axes.get_graph(- lambda x: self.initial_value * np.exp(self.k * x)- )- graph.set_color(self.output_color)- full_graph = graph.copy()- time_tracker = self.get_time_tracker()- graph.add_updater(lambda m: m.pointwise_become_partial(- full_graph, 0,- np.clip(- time_tracker.get_value() / self.total_time,- 0, 1,- )- ))-- # Equation- tex_kwargs = {- "tex_to_color_map": {- self.output_tex: self.output_color,- self.initial_value_tex: BLUE,- }- }- ode = TexMobject(- "{d",- "\\over dt}",- self.output_tex,- "(t)",- "=", self.k_tex,- "\\cdot", self.output_tex, "(t)",- **tex_kwargs- )- ode.to_edge(UP)- exp = TexMobject(- self.output_tex,- "(t) =", self.initial_value_tex,- "e^{", self.k_tex, "t}",- **tex_kwargs- )- exp.next_to(ode, DOWN, LARGE_BUFF)-- M0_part = exp.get_part_by_tex(self.initial_value_tex)- exp_part = exp[-3:]- M0_label = M0_part.copy()- M0_label.next_to(- axes.c2p(0, self.initial_value),- LEFT- )- M0_part.set_opacity(0)- exp_part.save_state()- exp_part.align_to(M0_part, LEFT)-- self.add(axes)- self.add(graph)- self.add(time_tracker)-- self.play(FadeInFromDown(ode))- self.wait(6)- self.play(FadeInFrom(exp, UP))- self.wait(2)- self.play(- Restore(exp_part),- M0_part.set_opacity, 1,- )- self.play(TransformFromCopy(- M0_part, M0_label- ))- self.wait(5)-- def get_time_tracker(self):- time_tracker = ValueTracker(0)- time_tracker.add_updater(- lambda m, dt: m.increment_value(- self.time_rate * dt- )- )- return time_tracker---class GrowingPileOfMoney(InvestmentGrowth):- CONFIG = {- "total_time": 60- }-- def construct(self):- initial_count = 5- k = self.k- total_time = self.total_time-- time_tracker = self.get_time_tracker()-- final_count = initial_count * np.exp(k * total_time)- dollar_signs = VGroup(*[- TexMobject("\\$")- for x in range(int(final_count))- ])- dollar_signs.set_color(GREEN)- for ds in dollar_signs:- ds.shift(- 3 * np.random.random(3)- )- dollar_signs.center()- dollar_signs.sort(get_norm)- dollar_signs.set_stroke(BLACK, 3, background=True)-- def update_dollar_signs(group):- t = time_tracker.get_value()- count = initial_count * np.exp(k * t)- alpha = count / final_count- n, sa = integer_interpolate(0, len(dollar_signs), alpha)- group.set_opacity(1)- group[n:].set_opacity(0)- group[n].set_opacity(sa)-- dollar_signs.add_updater(update_dollar_signs)-- self.add(time_tracker)- self.add(dollar_signs)- self.wait(20)---class CarbonDecayCurve(InvestmentGrowth):- CONFIG = {- "output_tex": "{^{14}C}",- "output_color": GOLD,- "initial_value": 4,- "initial_value_tex": "{^{14}C_0}",- "k": -0.1,- "k_tex": "-k",- "time_rate": 6,- }---class CarbonDecayingInMammoth(Scene):- def construct(self):- mammoth = SVGMobject("Mammoth")- mammoth.set_color(- interpolate_color(GREY_BROWN, WHITE, 0.25)- )- mammoth.set_height(4)- body = mammoth[9]-- atoms = VGroup(*[- self.get_atom(body)- for n in range(600)- ])-- p_decay = 0.2-- def update_atoms(group, dt):- for atom in group:- if np.random.random() < dt * p_decay:- group.remove(atom)- return group- atoms.add_updater(update_atoms)-- self.add(mammoth)- self.add(atoms)- self.wait(20)-- def get_atom(self, body):- atom = Dot(color=GOLD)- atom.set_height(0.05)-- dl = body.get_corner(DL)- ur = body.get_corner(UR)-- wn = 0- while wn == 0:- point = np.array([- interpolate(dl[0], ur[0], np.random.random()),- interpolate(dl[1], ur[1], np.random.random()),- 0- ])- wn = get_winding_number([- body.point_from_proportion(a) - point- for a in np.linspace(0, 1, 300)- ])- wn = int(np.round(wn))-- atom.move_to(point)- return atom---class BoundaryConditionInterlude(Scene):- def construct(self):- background = FullScreenFadeRectangle(- fill_color=DARK_GREY- )- storyline = self.get_main_storyline()- storyline.generate_target()- v_shift = 2 * DOWN- storyline.target.shift(v_shift)- im_to_im = storyline[1].get_center() - storyline[0].get_center()-- bc_image = self.get_labeled_image(- "Boundary\\\\conditions",- "boundary_condition_thumbnail"- )- bc_image.next_to(storyline[1], UP)- new_arrow0 = Arrow(- storyline.arrows[0].get_start() + v_shift,- bc_image.get_left() + SMALL_BUFF * LEFT,- path_arc=-90 * DEGREES,- buff=0,- )- new_mid_arrow = Arrow(- bc_image.get_bottom(),- storyline[1].get_top() + v_shift,- buff=SMALL_BUFF,- path_arc=60 * DEGREES,- )-- # BC detour- self.add(background)- self.add(storyline[0])- for im1, im2, arrow in zip(storyline, storyline[1:], storyline.arrows):- self.add(im2, im1)- self.play(- FadeInFrom(im2, -im_to_im),- ShowCreation(arrow),- )- self.wait()- self.play(- GrowFromCenter(bc_image),- MoveToTarget(storyline),- Transform(- storyline.arrows[0],- new_arrow0,- ),- MaintainPositionRelativeTo(- storyline.arrows[1],- storyline,- ),- )- self.play(ShowCreation(new_mid_arrow))- self.wait()-- # From BC to next step- rect1 = bc_image[2].copy()- rect2 = storyline[1][2].copy()- rect3 = storyline[2][2].copy()- for rect in rect1, rect2, rect3:- rect.set_stroke(YELLOW, 3)-- self.play(FadeIn(rect1))- kw = {"path_arc": 60 * DEGREES}- self.play(- LaggedStart(- Transform(rect1, rect2, **kw),- # TransformFromCopy(rect1, rect3, **kw),- lag_ratio=0.4,- )- )- self.play(- FadeOut(rect1),- # FadeOut(rect3),- )-- # Reorganize images- im1, im3, im4 = storyline- im2 = bc_image- l_group = Group(im1, im2)- r_group = Group(im3, im4)- for group in l_group, r_group:- group.generate_target()- group.target.arrange(DOWN, buff=LARGE_BUFF)- group.target.center()-- l_group.target.to_edge(LEFT)- r_group.target.move_to(- FRAME_WIDTH * RIGHT / 4- )- brace = Brace(r_group.target, LEFT)- nv_text = brace.get_text("Next\\\\video")- nv_text.scale(1.5, about_edge=RIGHT)- nv_text.set_color(YELLOW)- brace.set_color(YELLOW)-- arrows = VGroup(- storyline.arrows,- new_mid_arrow,- )-- self.play(- LaggedStart(- MoveToTarget(l_group),- MoveToTarget(r_group),- lag_ratio=0.3,- ),- FadeOut(arrows),- )- self.play(- GrowFromCenter(brace),- FadeInFrom(nv_text, RIGHT)- )- self.wait()-- def get_main_storyline(self):- images = Group(- self.get_sine_curve_image(),- self.get_linearity_image(),- self.get_fourier_series_image(),- )- for image in images:- image.set_height(3)- images.arrange(RIGHT, buff=1)- images.set_width(FRAME_WIDTH - 1)-- arrows = VGroup()- for im1, im2 in zip(images, images[1:]):- arrow = Arrow(- im1.get_top(),- im2.get_top(),- color=WHITE,- buff=MED_SMALL_BUFF,- path_arc=-120 * DEGREES,- rectangular_stem_width=0.025,- )- arrow.scale(0.7, about_edge=DOWN)- arrows.add(arrow)- images.arrows = arrows-- return images-- def get_sine_curve_image(self):- return self.get_labeled_image(- "Sine curves",- "sine_curve_temp_graph",- )-- def get_linearity_image(self):- return self.get_labeled_image(- "Linearity",- "linearity_thumbnail",- )-- def get_fourier_series_image(self):- return self.get_labeled_image(- "Fourier series",- "fourier_series_thumbnail",- )-- def get_labeled_image(self, text, image_file):- rect = ScreenRectangle(height=2)- border = rect.copy()- rect.set_fill(BLACK, 1)- rect.set_stroke(WHITE, 0)- border.set_stroke(WHITE, 2)-- text_mob = TextMobject(text)- text_mob.set_stroke(BLACK, 5, background=True)- text_mob.next_to(rect.get_top(), DOWN, SMALL_BUFF)-- image = ImageMobject(image_file)- image.replace(rect, dim_to_match=1)- image.scale(0.8, about_edge=DOWN)-- return Group(rect, image, border, text_mob)---class GiantCross(Scene):- def construct(self):- rect = FullScreenFadeRectangle()- cross = Cross(rect)- cross.set_stroke(RED, 25)-- words = TextMobject("This wouldn't\\\\happen!")- words.scale(2)- words.set_color(RED)- words.to_edge(UP)-- self.play(- FadeInFromDown(words),- ShowCreation(cross),- )- self.wait()---class EndScreen(PatreonEndScreen):- CONFIG = {- "specific_patrons": [- "1stViewMaths",- "Adrian Robinson",- "Alexis Olson",- "Andreas Benjamin Brössel",- "Andrew Busey",- "Ankalagon",- "Antoine Bruguier",- "Antonio Juarez",- "Arjun Chakroborty",- "Art Ianuzzi",- "Awoo",- "Ayan Doss",- "AZsorcerer",- "Barry Fam",- "Bernd Sing",- "Boris Veselinovich",- "Brian Staroselsky",- "Charles Southerland",- "Chris Connett",- "Christian Kaiser",- "Clark Gaebel",- "Cooper Jones",- "Danger Dai",- "Daniel Pang",- "Dave B",- "Dave Kester",- "David B. Hill",- "David Clark",- "Delton Ding",- "eaglle",- "Empirasign",- "emptymachine",- "Eric Younge",- "Eryq Ouithaqueue",- "Federico Lebron",- "Fernando Via Canel",- "Giovanni Filippi",- "Hal Hildebrand",- "Hitoshi Yamauchi",- "Isaac Jeffrey Lee",- "j eduardo perez",- "Jacob Hartmann",- "Jacob Magnuson",- "Jameel Syed",- "Jason Hise",- "Jeff Linse",- "Jeff Straathof",- "John C. Vesey",- "John Griffith",- "John Haley",- "John V Wertheim",- "Jonathan Eppele",- "Kai-Siang Ang",- "Kanan Gill",- "Kartik\\\\Cating-Subramanian",- "L0j1k",- "Lee Redden",- "Linh Tran",- "Ludwig Schubert",- "Magister Mugit",- "Mark B Bahu",- "Martin Price",- "Mathias Jansson",- "Matt Langford",- "Matt Roveto",- "Matthew Bouchard",- "Matthew Cocke",- "Michael Faust",- "Michael Hardel",- "Mirik Gogri",- "Mustafa Mahdi",- "Márton Vaitkus",- "Nero Li",- "Nikita Lesnikov",- "Omar Zrien",- "Owen Campbell-Moore",- "Patrick",- "Peter Ehrnstrom",- "RedAgent14",- "rehmi post",- "Richard Comish",- "Ripta Pasay",- "Rish Kundalia",- "Robert Teed",- "Roobie",- "Ryan Williams",- "Sebastian Garcia",- "Solara570",- "Stephan Arlinghaus",- "Steven Siddals",- "Stevie Metke",- "Tal Einav",- "Ted Suzman",- "Thomas Tarler",- "Tianyu Ge",- "Tom Fleming",- "Valeriy Skobelev",- "Xuanji Li",- "Yavor Ivanov",- "YinYangBalance.Asia",- "Zach Cardwell",- "Luc Ritchie",- "Britt Selvitelle",- "David Gow",- "J",- "Jonathan Wilson",- "Joseph John Cox",- "Magnus Dahlström",- "Randy C. Will",- "Ryan Atallah",- "Lukas -krtek.net- Novy",- "Jordan Scales",- "Ali Yahya",- "Arthur Zey",- "Atul S",- "dave nicponski",- "Evan Phillips",- "Joseph Kelly",- "Kaustuv DeBiswas",- "Lambda AI Hardware",- "Lukas Biewald",- "Mark Heising",- "Mike Coleman",- "Nicholas Cahill",- "Peter Mcinerney",- "Quantopian",- "Roy Larson",- "Scott Walter, Ph.D.",- "Yana Chernobilsky",- "Yu Jun",- "D. Sivakumar",- "Richard Barthel",- "Burt Humburg",- "Matt Russell",- "Scott Gray",- "soekul",- "Tihan Seale",- "Juan Benet",- "Vassili Philippov",- "Kurt Dicus",- ],- }diff --git a/active_projects/ode/part3/temperature_graphs.py b/active_projects/ode/part3/temperature_graphs.pydeleted file mode 100644index 2ed445b5a..000000000--- a/active_projects/ode/part3/temperature_graphs.py+++ /dev/null@@ -1,2830 +0,0 @@-from scipy import integrate--from manimlib.imports import *-from active_projects.ode.part2.heat_equation import *---class TemperatureGraphScene(SpecialThreeDScene):- CONFIG = {- "axes_config": {- "x_min": 0,- "x_max": TAU,- "y_min": 0,- "y_max": 10,- "z_min": -3,- "z_max": 3,- "x_axis_config": {- "tick_frequency": TAU / 8,- "include_tip": False,- },- "num_axis_pieces": 1,- },- "default_graph_style": {- "stroke_width": 2,- "stroke_color": WHITE,- "background_image_file": "VerticalTempGradient",- },- "default_surface_config": {- "fill_opacity": 0.1,- "checkerboard_colors": [LIGHT_GREY],- "stroke_width": 0.5,- "stroke_color": WHITE,- "stroke_opacity": 0.5,- },- "temp_text": "Temperature",- }-- def get_three_d_axes(self, include_labels=True, include_numbers=False, **kwargs):- config = dict(self.axes_config)- config.update(kwargs)- axes = ThreeDAxes(**config)- axes.set_stroke(width=2)-- if include_numbers:- self.add_axes_numbers(axes)-- if include_labels:- self.add_axes_labels(axes)-- # Adjust axis orientation- axes.x_axis.rotate(- 90 * DEGREES, RIGHT,- about_point=axes.c2p(0, 0, 0),- )- axes.y_axis.rotate(- 90 * DEGREES, UP,- about_point=axes.c2p(0, 0, 0),- )-- # Add xy-plane- input_plane = self.get_surface(- axes, lambda x, t: 0- )- input_plane.set_style(- fill_opacity=0.5,- fill_color=BLUE_B,- stroke_width=0.5,- stroke_color=WHITE,- )-- axes.input_plane = input_plane-- return axes-- def add_axes_numbers(self, axes):- x_axis = axes.x_axis- y_axis = axes.y_axis- tex_vals = [- ("\\pi \\over 2", TAU / 4),- ("\\pi", TAU / 2),- ("3\\pi \\over 2", 3 * TAU / 4),- ("2\\pi", TAU)- ]- x_labels = VGroup()- for tex, val in tex_vals:- label = TexMobject(tex)- label.scale(0.5)- label.next_to(x_axis.n2p(val), DOWN)- x_labels.add(label)- x_axis.add(x_labels)- x_axis.numbers = x_labels-- y_axis.add_numbers()- for number in y_axis.numbers:- number.rotate(90 * DEGREES)- return axes-- def add_axes_labels(self, axes):- x_label = TexMobject("x")- x_label.next_to(axes.x_axis.get_end(), RIGHT)- axes.x_axis.label = x_label-- t_label = TextMobject("Time")- t_label.rotate(90 * DEGREES, OUT)- t_label.next_to(axes.y_axis.get_end(), UP)- axes.y_axis.label = t_label-- temp_label = TextMobject(self.temp_text)- temp_label.rotate(90 * DEGREES, RIGHT)- temp_label.next_to(axes.z_axis.get_zenith(), RIGHT)- axes.z_axis.label = temp_label- for axis in axes:- axis.add(axis.label)- return axes-- def get_time_slice_graph(self, axes, func, t, **kwargs):- config = dict()- config.update(self.default_graph_style)- config.update({- "t_min": axes.x_min,- "t_max": axes.x_max,- })- config.update(kwargs)- return ParametricFunction(- lambda x: axes.c2p(- x, t, func(x, t)- ),- **config,- )-- def get_initial_state_graph(self, axes, func, **kwargs):- return self.get_time_slice_graph(- axes,- lambda x, t: func(x),- t=0,- **kwargs- )-- def get_surface(self, axes, func, **kwargs):- config = {- "u_min": axes.x_min,- "u_max": axes.x_max,- "v_min": axes.y_min,- "v_max": axes.y_max,- "resolution": (- (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,- (axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,- ),- }- config.update(self.default_surface_config)- config.update(kwargs)- return ParametricSurface(- lambda x, t: axes.c2p(- x, t, func(x, t)- ),- **config- )-- def orient_three_d_mobject(self, mobject,- phi=85 * DEGREES,- theta=-80 * DEGREES):- mobject.rotate(-90 * DEGREES - theta, OUT)- mobject.rotate(phi, LEFT)- return mobject-- def get_rod_length(self):- return self.axes_config["x_max"]-- def get_const_time_plane(self, axes):- t_tracker = ValueTracker(0)- plane = Polygon(- *[- axes.c2p(x, 0, z)- for x, z in [- (axes.x_min, axes.z_min),- (axes.x_max, axes.z_min),- (axes.x_max, axes.z_max),- (axes.x_min, axes.z_max),- ]- ],- stroke_width=0,- fill_color=WHITE,- fill_opacity=0.2- )- plane.add_updater(lambda m: m.move_to(- axes.c2p(- axes.x_min,- t_tracker.get_value(),- axes.z_min,- ),- IN + LEFT,- ))- plane.t_tracker = t_tracker- return plane---class SimpleCosExpGraph(TemperatureGraphScene):- def construct(self):- axes = self.get_three_d_axes()- cos_graph = self.get_cos_graph(axes)- cos_exp_surface = self.get_cos_exp_surface(axes)-- self.set_camera_orientation(- phi=80 * DEGREES,- theta=-80 * DEGREES,- )- self.camera.frame_center.shift(3 * RIGHT)- self.begin_ambient_camera_rotation(rate=0.01)-- self.add(axes)- self.play(ShowCreation(cos_graph))- self.play(UpdateFromAlphaFunc(- cos_exp_surface,- lambda m, a: m.become(- self.get_cos_exp_surface(axes, v_max=a * 10)- ),- run_time=3- ))-- 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 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_cos_graph(self, axes, **config):- return self.get_initial_state_graph(- axes,- lambda x: self.cos_exp(x, 0),- **config- )-- def get_cos_exp_surface(self, axes, **config):- return self.get_surface(- axes,- lambda x, t: self.cos_exp(x, t),- **config- )---class AddMultipleSolutions(SimpleCosExpGraph):- CONFIG = {- "axes_config": {- "x_axis_config": {- "unit_size": 0.7,- },- }- }-- def construct(self):- axes1, axes2, axes3 = all_axes = VGroup(*[- self.get_three_d_axes(- include_labels=False,- )- for x in range(3)- ])- all_axes.scale(0.5)- self.orient_three_d_mobject(all_axes)-- As = [1.5, 1.5]- 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]]),- (axes3, As, omegas, ks),- ]-- for axes, As, omegas, ks in quads:- graph = self.get_initial_state_graph(- axes,- lambda x: np.sum([- 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.cos_exp(x, t, A, omega, k)- for A, omega, k in zip(As, omegas, ks)- ])- )- surface.sort(lambda p: -p[2])-- axes.add(surface, graph)- axes.graph = graph- axes.surface = surface-- self.set_camera_orientation(distance=100)- plus = TexMobject("+").scale(2)- equals = TexMobject("=").scale(2)- group = VGroup(- axes1, plus, axes2, equals, axes3,- )- group.arrange(RIGHT, buff=SMALL_BUFF)-- for axes in all_axes:- checkmark = TexMobject("\\checkmark")- checkmark.set_color(GREEN)- checkmark.scale(2)- checkmark.next_to(axes, UP)- checkmark.shift(0.7 * DOWN)- axes.checkmark = checkmark-- self.add(axes1, axes2)- self.play(- LaggedStart(- Write(axes1.surface),- Write(axes2.surface),- ),- LaggedStart(- FadeInFrom(axes1.checkmark, DOWN),- FadeInFrom(axes2.checkmark, DOWN),- ),- lag_ratio=0.2,- run_time=1,- )- self.wait()- self.play(Write(plus))- self.play(- Transform(- axes1.copy().set_fill(opacity=0),- axes3- ),- Transform(- axes2.copy().set_fill(opacity=0),- axes3- ),- FadeInFrom(equals, LEFT)- )- self.play(- FadeInFrom(axes3.checkmark, DOWN),- )- self.wait()---class BreakDownAFunction(SimpleCosExpGraph):- CONFIG = {- "axes_config": {- "z_axis_config": {- "unit_size": 0.75,- "include_tip": False,- },- "z_min": -2,- "y_max": 20,- },- "n_low_axes": 4,- "k": 0.2,- }-- 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,- )- top_graph.set_stroke(width=4)-- 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(),- low_axes_group,- fourier_terms- )- ])- k = self.k- 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(),- low_axes_group,- fourier_terms- )- ])- 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(),- fourier_terms- )- ])- )-- 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_SMALL_BUFF- )- for axes in low_axes_group- ])- dots = TexMobject("\\cdots")- dots.next_to(plusses, RIGHT, MED_SMALL_BUFF)-- arrow = Arrow(- dots.get_right(),- top_graph.get_end() + 1.4 * DOWN + 1.7 * RIGHT,- path_arc=90 * 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.point_from_proportion(0.3)- )-- 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),- FadeInFrom(low_words, UP),- LaggedStartMap(FadeInFromDown, [*plusses, dots]),- *[- TransformFromCopy(top_graph, low_graph)- for low_graph in low_graphs- ],- )- 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 = [- ApplyMethod(- top_axes.y_axis.set_opacity, 1,- ),- ]- 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().set_fill(opacity=0),- 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_checkmark, top_checkmark.copy())- for low_checkmark in low_checkmarks- ])- self.wait()-- #- def initial_func(self, x):- # return 3 * np.exp(-(x - PI)**2)-- x1 = TAU / 4 - 1- x2 = TAU / 4 + 1- x3 = 3 * TAU / 4 - 1.6- x4 = 3 * TAU / 4 + 0.3-- T0 = -2- T1 = 2- T2 = 1-- if x < x1:- return T0- elif x < x2:- alpha = inverse_interpolate(x1, x2, x)- return bezier([T0, T0, T1, T1])(alpha)- elif x < x3:- return T1- elif x < x4:- alpha = inverse_interpolate(x3, x4, x)- return bezier([T1, T1, T2, T2])(alpha)- else:- return T2-- def get_initial_func_discontinuities(self):- # return [TAU / 4, 3 * TAU / 4]- return []-- def get_fourier_cosine_terms(self, func, n_terms=40):- 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---class OceanOfPossibilities(TemperatureGraphScene):- CONFIG = {- "axes_config": {- "z_min": 0,- "z_max": 4,- },- "k": 0.2,- "default_surface_config": {- # "resolution": (32, 20),- # "resolution": (8, 5),- }- }-- def construct(self):- self.setup_camera()- self.setup_axes()- self.setup_surface()- self.show_solution()- self.reference_boundary_conditions()- self.reference_initial_condition()- self.ambiently_change_solution()-- def setup_camera(self):- self.set_camera_orientation(- phi=80 * DEGREES,- theta=-80 * DEGREES,- )- self.begin_ambient_camera_rotation(rate=0.01)-- def setup_axes(self):- axes = self.get_three_d_axes(include_numbers=True)- axes.add(axes.input_plane)- axes.scale(0.8)- axes.center()- axes.shift(OUT + RIGHT)-- self.add(axes)- self.axes = axes-- def setup_surface(self):- axes = self.axes- k = self.k-- # Parameters for surface function- initial_As = [2] + [- 0.8 * random.choice([-1, 1]) / n- for n in range(1, 20)- ]- A_trackers = Group(*[- ValueTracker(A)- for A in initial_As- ])-- def get_As():- return [At.get_value() for At in A_trackers]-- omegas = [n / 2 for n in range(0, 10)]-- def func(x, t):- return np.sum([- np.prod([- A * np.cos(omega * x),- np.exp(-k * omega**2 * t)- ])- for A, omega in zip(get_As(), omegas)- ])-- # Surface and graph- surface = always_redraw(- lambda: self.get_surface(axes, func)- )- t_tracker = ValueTracker(0)- graph = always_redraw(- lambda: self.get_time_slice_graph(- axes, func, t_tracker.get_value(),- )- )-- surface.suspend_updating()- graph.suspend_updating()-- self.surface_func = func- self.surface = surface- self.graph = graph- self.t_tracker = t_tracker- self.A_trackers = A_trackers- self.omegas = omegas-- def show_solution(self):- axes = self.axes- surface = self.surface- graph = self.graph- t_tracker = self.t_tracker- get_t = t_tracker.get_value-- opacity_tracker = ValueTracker(0)- plane = always_redraw(lambda: Polygon(- *[- axes.c2p(x, get_t(), T)- for x, T in [- (0, 0), (TAU, 0), (TAU, 4), (0, 4)- ]- ],- stroke_width=0,- fill_color=WHITE,- fill_opacity=opacity_tracker.get_value(),- ))-- self.add(surface, plane, graph)- graph.resume_updating()- self.play(- opacity_tracker.set_value, 0.2,- ApplyMethod(- t_tracker.set_value, 1,- rate_func=linear- ),- run_time=1- )- self.play(- ApplyMethod(- t_tracker.set_value, 10,- rate_func=linear,- run_time=9- )- )- self.wait()-- self.plane = plane-- def reference_boundary_conditions(self):- axes = self.axes- t_numbers = axes.y_axis.numbers-- lines = VGroup(*[- Line(- axes.c2p(x, 0, 0),- axes.c2p(x, axes.y_max, 0),- stroke_width=3,- stroke_color=MAROON_B,- )- for x in [0, axes.x_max]- ])- surface_boundary_lines = always_redraw(lambda: VGroup(*[- ParametricFunction(- lambda t: axes.c2p(- x, t,- self.surface_func(x, t)- ),- t_max=axes.y_max- ).match_style(self.graph)- for x in [0, axes.x_max]- ]))- # surface_boundary_lines.suspend_updating()- words = VGroup()- for line in lines:- word = TextMobject("Boundary")- word.set_stroke(BLACK, 3, background=True)- word.scale(1.5)- word.match_color(line)- word.rotate(90 * DEGREES, RIGHT)- word.rotate(90 * DEGREES, OUT)- word.next_to(line, OUT, SMALL_BUFF)- words.add(word)-- self.stop_ambient_camera_rotation()- self.move_camera(- theta=-45 * DEGREES,- added_anims=[- LaggedStartMap(ShowCreation, lines),- LaggedStartMap(- FadeInFrom, words,- lambda m: (m, IN)- ),- FadeOut(t_numbers),- ]- )- self.play(- LaggedStart(*[- TransformFromCopy(l1, l2)- for l1, l2 in zip(lines, surface_boundary_lines)- ])- )- self.add(surface_boundary_lines)- self.wait()- self.move_camera(- theta=-70 * DEGREES,- )-- self.surface_boundary_lines = surface_boundary_lines-- def reference_initial_condition(self):- plane = self.plane- t_tracker = self.t_tracker-- self.play(- t_tracker.set_value, 0,- run_time=2- )- plane.clear_updaters()- self.play(FadeOut(plane))-- def ambiently_change_solution(self):- A_trackers = self.A_trackers-- def generate_A_updater(A, rate):- def update(m, dt):- m.total_time += dt- m.set_value(- 2 * A * np.sin(rate * m.total_time + PI / 6)- )- return update-- rates = [0, 0.2] + [- 0.5 + 0.5 * np.random.random()- for x in range(len(A_trackers) - 2)- ]-- for tracker, rate in zip(A_trackers, rates):- tracker.total_time = 0- tracker.add_updater(generate_A_updater(- tracker.get_value(),- rate- ))-- self.add(*A_trackers)- self.surface_boundary_lines.resume_updating()- self.surface.resume_updating()- self.graph.resume_updating()- self.begin_ambient_camera_rotation(rate=0.01)- self.wait(30)---class AnalyzeSineCurve(TemperatureGraphScene):- CONFIG = {- "origin_point": 3 * LEFT,- "axes_config": {- "z_min": -1.5,- "z_max": 1.5,- "z_axis_config": {- "unit_size": 2,- "tick_frequency": 0.5,- }- },- "tex_to_color_map": {- "{x}": GREEN,- "T": YELLOW,- "=": WHITE,- "0": WHITE,- "\\Delta t": WHITE,- "\\sin": WHITE,- "{t}": PINK,- }- }-- def construct(self):- self.setup_axes()- self.ask_about_sine_curve()- self.show_sine_wave_on_axes()- self.reference_curvature()- self.show_derivatives()- self.show_curvature_matching_height()- self.show_time_step_scalings()- self.smooth_evolution()-- def setup_axes(self):- axes = self.get_three_d_axes()- axes.rotate(90 * DEGREES, LEFT)- axes.shift(self.origin_point - axes.c2p(0, 0, 0))- y_axis = axes.y_axis- y_axis.fade(1)- z_axis = axes.z_axis- z_axis.label.next_to(z_axis.get_end(), UP, SMALL_BUFF)-- self.add_axes_numbers(axes)- y_axis.remove(y_axis.numbers)- axes.z_axis.add_numbers(- *range(-1, 2),- direction=LEFT,- )-- self.axes = axes-- def ask_about_sine_curve(self):- curve = FunctionGraph(- lambda t: np.sin(t),- x_min=0,- x_max=TAU,- )- curve.move_to(DR)- curve.set_width(5)- curve.set_color(YELLOW)- question = TextMobject("What's so special?")- question.scale(1.5)- question.to_edge(UP)- question.shift(2 * LEFT)- arrow = Arrow(- question.get_bottom(),- curve.point_from_proportion(0.25)- )-- self.play(- ShowCreation(curve),- Write(question, run_time=1),- GrowArrow(arrow),- )- self.wait()-- self.quick_sine_curve = curve- self.question_group = VGroup(question, arrow)-- def show_sine_wave_on_axes(self):- axes = self.axes- graph = self.get_initial_state_graph(- axes, lambda x: np.sin(x)- )- graph.set_stroke(width=4)- graph_label = TexMobject(- "T({x}, 0) = \\sin\\left({x}\\right)",- tex_to_color_map=self.tex_to_color_map,- )- graph_label.next_to(- graph.point_from_proportion(0.25), UR,- buff=SMALL_BUFF,- )-- v_line, x_tracker = self.get_v_line_with_x_tracker(graph)-- xs = VGroup(- *graph_label.get_parts_by_tex("x"),- axes.x_axis.label,- )-- self.play(- Write(axes),- self.quick_sine_curve.become, graph,- FadeOutAndShift(self.question_group, UP),- )- self.play(- FadeInFromDown(graph_label),- FadeIn(graph),- )- self.remove(self.quick_sine_curve)- self.add(v_line)- self.play(- ApplyMethod(- x_tracker.set_value, TAU,- rate_func=lambda t: smooth(t, 3),- run_time=5,- ),- LaggedStartMap(- ShowCreationThenFadeAround, xs,- run_time=3,- lag_ratio=0.2,- )- )- self.remove(v_line, x_tracker)- self.wait()-- self.graph = graph- self.graph_label = graph_label- self.v_line = v_line- self.x_tracker = x_tracker-- def reference_curvature(self):- curve_segment, curve_x_tracker = \- self.get_curve_segment_with_x_tracker(self.graph)-- self.add(curve_segment)- self.play(- curve_x_tracker.set_value, TAU,- run_time=5,- rate_func=lambda t: smooth(t, 3),- )- self.play(FadeOut(curve_segment))-- self.curve_segment = curve_segment- self.curve_x_tracker = curve_x_tracker-- def show_derivatives(self):- deriv1 = TexMobject(- "{\\partial T \\over \\partial {x}}({x}, 0)",- "= \\cos\\left({x}\\right)",- tex_to_color_map=self.tex_to_color_map,- )- deriv2 = TexMobject(- "{\\partial^2 T \\over \\partial {x}^2}({x}, 0)",- "= -\\sin\\left({x}\\right)",- tex_to_color_map=self.tex_to_color_map,- )-- deriv1.to_corner(UR)- deriv2.next_to(- deriv1, DOWN,- buff=0.75,- aligned_edge=LEFT,- )- VGroup(deriv1, deriv2).shift(1.4 * RIGHT)-- self.play(- Animation(Group(*self.get_mobjects())),- FadeInFrom(deriv1, LEFT),- self.camera.frame_center.shift, 2 * RIGHT,- )- self.wait()- self.play(- FadeInFrom(deriv2, UP)- )- self.wait()-- self.deriv1 = deriv1- self.deriv2 = deriv2-- def show_curvature_matching_height(self):- axes = self.axes- graph = self.graph- curve_segment = self.curve_segment- curve_x_tracker = self.curve_x_tracker-- d2_graph = self.get_initial_state_graph(- axes, lambda x: -np.sin(x),- )- dashed_d2_graph = DashedVMobject(d2_graph, num_dashes=50)- dashed_d2_graph.color_using_background_image(None)- dashed_d2_graph.set_stroke(RED, 2)-- vector, x_tracker = self.get_v_line_with_x_tracker(- d2_graph,- line_creator=lambda p1, p2: Arrow(- p1, p2, color=RED, buff=0- )- )-- lil_vectors = self.get_many_lil_vectors(graph)- lil_vector = always_redraw(- lambda: self.get_lil_vector(- graph, x_tracker.get_value()- )- )-- d2_rect = SurroundingRectangle(- self.deriv2[-5:],- color=RED,- )- self.play(ShowCreation(d2_rect))- self.add(vector)- self.add(lil_vector)- self.add(curve_segment)- curve_x_tracker.set_value(0)- self.play(- ShowCreation(dashed_d2_graph),- x_tracker.set_value, TAU,- curve_x_tracker.set_value, TAU,- ShowIncreasingSubsets(lil_vectors[1:]),- run_time=8,- rate_func=linear,- )- self.remove(vector)- self.remove(lil_vector)- self.add(lil_vectors)- self.play(- FadeOut(curve_segment),- FadeOut(d2_rect),- )-- self.lil_vectors = lil_vectors- self.dashed_d2_graph = dashed_d2_graph-- def show_time_step_scalings(self):- axes = self.axes- graph_label = self.graph_label- dashed_d2_graph = self.dashed_d2_graph- lil_vectors = self.lil_vectors- graph = self.graph-- factor = 0.9-- new_label = TexMobject(- "T({x}, \\Delta t) = c \\cdot \\sin\\left({x}\\right)",- tex_to_color_map=self.tex_to_color_map,- )- final_label = TexMobject(- "T({x}, {t}) = (\\text{something}) \\cdot \\sin\\left({x}\\right)",- tex_to_color_map=self.tex_to_color_map,- )- for label in (new_label, final_label):- label.shift(- graph_label.get_part_by_tex("=").get_center() -- label.get_part_by_tex("=").get_center()- )- final_label.shift(1.5 * LEFT)-- h_lines = VGroup(- DashedLine(axes.c2p(0, 0, 1), axes.c2p(TAU, 0, 1)),- DashedLine(axes.c2p(0, 0, -1), axes.c2p(TAU, 0, -1)),- )-- lil_vectors.add_updater(lambda m: m.become(- self.get_many_lil_vectors(graph)- ))-- i = 4- self.play(- ReplacementTransform(- graph_label[:i], new_label[:i],- ),- ReplacementTransform(- graph_label[i + 1:i + 3],- new_label[i + 1:i + 3],- ),- FadeOutAndShift(graph_label[i], UP),- FadeInFrom(new_label[i], DOWN),- )- self.play(- ReplacementTransform(- graph_label[i + 3:],- new_label[i + 4:]- ),- FadeInFromDown(new_label[i + 3])- )- self.play(- FadeOut(dashed_d2_graph),- FadeIn(h_lines),- )- self.play(- graph.stretch, factor, 1,- h_lines.stretch, factor, 1,- )- self.wait()-- # Repeat- last_coef = None- last_exp = None- delta_T = new_label.get_part_by_tex("\\Delta t")- c = new_label.get_part_by_tex("c")[0]- prefix = new_label[:4]- prefix.generate_target()- for x in range(5):- coef = Integer(x + 2)- exp = coef.copy().scale(0.7)- coef.next_to(- delta_T, LEFT, SMALL_BUFF,- aligned_edge=DOWN,- )- exp.move_to(c.get_corner(UR), DL)- anims1 = [FadeInFrom(coef, 0.25 * DOWN)]- anims2 = [FadeInFrom(exp, 0.25 * DOWN)]- if last_coef:- anims1.append(- FadeOutAndShift(last_coef, 0.25 * UP)- )- anims2.append(- FadeOutAndShift(last_exp, 0.25 * UP)- )- last_coef = coef- last_exp = exp- prefix.target.next_to(coef, LEFT, SMALL_BUFF)- prefix.target.match_y(prefix)- anims1.append(MoveToTarget(prefix))-- self.play(*anims1)- self.play(- graph.stretch, factor, 1,- h_lines.stretch, factor, 1,- *anims2,- )- self.play(- ReplacementTransform(- new_label[:4],- final_label[:4],- ),- ReplacementTransform(- VGroup(last_coef, delta_T),- final_label.get_part_by_tex("{t}"),- ),- ReplacementTransform(- last_exp,- final_label.get_part_by_tex("something"),- ),- FadeOut(new_label.get_part_by_tex("\\cdot"), UP),- ReplacementTransform(- new_label[-4:],- final_label[-4:],- ),- ReplacementTransform(- new_label.get_part_by_tex("="),- final_label.get_part_by_tex("="),- ),- ReplacementTransform(- new_label.get_part_by_tex(")"),- final_label.get_part_by_tex(")"),- ),- )- final_label.add_background_rectangle(opacity=1)- self.add(final_label)- self.wait()-- group = VGroup(graph, h_lines)- group.add_updater(lambda m, dt: m.stretch(- (1 - 0.1 * dt), 1- ))- self.add(group)- self.wait(10)-- def smooth_evolution(self):- pass-- #- def get_rod(self, temp_func):- pass-- def get_v_line_with_x_tracker(self, graph, line_creator=DashedLine):- axes = self.axes- x_min = axes.x_axis.p2n(graph.get_start())- x_max = axes.x_axis.p2n(graph.get_end())- x_tracker = ValueTracker(x_min)- get_x = x_tracker.get_value- v_line = always_redraw(lambda: line_creator(- axes.c2p(get_x(), 0, 0),- graph.point_from_proportion(- inverse_interpolate(- x_min, x_max, get_x()- )- ),- ))- return v_line, x_tracker-- def get_curve_segment_with_x_tracker(self, graph, delta_x=0.5):- axes = self.axes- x_min = axes.x_axis.p2n(graph.get_start())- x_max = axes.x_axis.p2n(graph.get_end())- x_tracker = ValueTracker(x_min)- get_x = x_tracker.get_value-- def x2a(x):- return inverse_interpolate(x_min, x_max, x)-- curve = VMobject(- stroke_color=WHITE,- stroke_width=5- )- curve.add_updater(lambda m: m.pointwise_become_partial(- graph,- max(x2a(get_x() - delta_x), 0),- min(x2a(get_x() + delta_x), 1),- ))- return curve, x_tracker-- def get_lil_vector(self, graph, x):- x_axis = self.axes.x_axis- point = graph.point_from_proportion(x / TAU)- x_axis_point = x_axis.n2p(x_axis.p2n(point))- return Arrow(- point,- interpolate(- point, x_axis_point, 0.5,- ),- buff=0,- color=RED- )-- def get_many_lil_vectors(self, graph, n=13):- return VGroup(*[- self.get_lil_vector(graph, x)- for x in np.linspace(0, TAU, n)- ])---class SineWaveScaledByExp(TemperatureGraphScene):- CONFIG = {- "axes_config": {- "z_min": -1.5,- "z_max": 1.5,- "z_axis_config": {- "unit_size": 2,- "tick_frequency": 0.5,- "label_direction": LEFT,- },- "y_axis_config": {- "label_direction": RIGHT,- },- },- "k": 0.3,- }-- def construct(self):- self.setup_axes()- self.setup_camera()- self.show_sine_wave()- self.show_decay_surface()- self.linger_at_end()-- def setup_axes(self):- axes = self.get_three_d_axes()-- # Add number labels- self.add_axes_numbers(axes)- for axis in [axes.x_axis, axes.y_axis]:- axis.numbers.rotate(- 90 * DEGREES,- axis=axis.get_vector(),- about_point=axis.point_from_proportion(0.5)- )- axis.numbers.set_shade_in_3d(True)- axes.z_axis.add_numbers(*range(-1, 2))- for number in axes.z_axis.numbers:- number.rotate(90 * DEGREES, RIGHT)-- axes.z_axis.label.next_to(- axes.z_axis.get_end(), OUT,- )-- # Input plane- axes.input_plane.set_opacity(0.25)- self.add(axes.input_plane)-- # Shift into place- # axes.shift(5 * LEFT)- self.axes = axes- self.add(axes)-- def setup_camera(self):- self.set_camera_orientation(- phi=80 * DEGREES,- theta=-80 * DEGREES,- distance=50,- )- self.camera.set_frame_center(- 2 * RIGHT,- )-- def show_sine_wave(self):- time_tracker = ValueTracker(0)- graph = always_redraw(- lambda: self.get_time_slice_graph(- self.axes,- self.sin_exp,- t=time_tracker.get_value(),- )- )- graph.suspend_updating()-- graph_label = TexMobject("\\sin(x)")- graph_label.set_color(BLUE)- graph_label.rotate(90 * DEGREES, RIGHT)- graph_label.next_to(- graph.point_from_proportion(0.25),- OUT,- SMALL_BUFF,- )-- self.play(- ShowCreation(graph),- FadeInFrom(graph_label, IN)- )- self.wait()- graph.resume_updating()-- self.time_tracker = time_tracker- self.graph = graph-- def show_decay_surface(self):- time_tracker = self.time_tracker- axes = self.axes-- plane = Rectangle()- plane.rotate(90 * DEGREES, RIGHT)- plane.set_stroke(width=0)- plane.set_fill(WHITE, 0.2)- plane.match_depth(axes.z_axis)- plane.match_width(axes.x_axis, stretch=True)- plane.add_updater(- lambda p: p.move_to(axes.c2p(- 0,- time_tracker.get_value(),- 0,- ), LEFT)- )-- time_slices = VGroup(*[- self.get_time_slice_graph(- self.axes,- self.sin_exp,- t=t,- )- for t in range(0, 10)- ])- surface_t_tracker = ValueTracker(0)- surface = always_redraw(- lambda: self.get_surface(- self.axes,- self.sin_exp,- v_max=surface_t_tracker.get_value(),- ).set_stroke(opacity=0)- )-- exp_graph = ParametricFunction(- lambda t: axes.c2p(- PI / 2,- t,- self.sin_exp(PI / 2, t)- ),- t_min=axes.y_min,- t_max=axes.y_max,- )- exp_graph.set_stroke(RED, 3)- exp_graph.set_shade_in_3d(True)-- exp_label = TexMobject("e^{-\\alpha t}")- exp_label.scale(1.5)- exp_label.set_color(RED)- exp_label.rotate(90 * DEGREES, RIGHT)- exp_label.rotate(90 * DEGREES, OUT)- exp_label.next_to(- exp_graph.point_from_proportion(0.3),- OUT + UP,- )-- self.move_camera(- theta=-25 * DEGREES,- )- self.add(surface)- self.add(plane)- self.play(- surface_t_tracker.set_value, axes.y_max,- time_tracker.set_value, axes.y_max,- ShowIncreasingSubsets(- time_slices,- int_func=np.ceil,- ),- run_time=5,- rate_func=linear,- )- surface.clear_updaters()-- self.play(- ShowCreation(exp_graph),- FadeOut(plane),- FadeInFrom(exp_label, IN),- time_slices.set_stroke, {"width": 1},- )-- def linger_at_end(self):- self.wait()- self.begin_ambient_camera_rotation(rate=-0.02)- self.wait(20)-- #- def sin_exp(self, x, t):- return np.sin(x) * np.exp(-self.k * t)---class BoundaryConditionReference(ShowEvolvingTempGraphWithArrows):- def construct(self):- self.setup_axes()- self.setup_graph()-- rod = self.get_rod(0, 10)- self.color_rod_by_graph(rod)-- boundary_points = [- rod.get_right(),- rod.get_left(),- ]- boundary_dots = VGroup(*[- Dot(point, radius=0.2)- for point in boundary_points- ])- boundary_arrows = VGroup(*[- Vector(2 * DOWN).next_to(dot, UP)- for dot in boundary_dots- ])- boundary_arrows.set_stroke(YELLOW, 10)-- words = TextMobject(- "Different rules\\\\",- "at the boundary",- )- words.scale(1.5)- words.to_edge(UP)-- # self.add(self.axes)- # self.add(self.graph)- self.add(rod)- self.play(FadeInFromDown(words))- self.play(- LaggedStartMap(GrowArrow, boundary_arrows),- LaggedStartMap(GrowFromCenter, boundary_dots),- lag_ratio=0.3,- run_time=1,- )- self.wait()---class SimulateRealSineCurve(ShowEvolvingTempGraphWithArrows):- CONFIG = {- "axes_config": {- "x_min": 0,- "x_max": TAU,- "x_axis_config": {- "unit_size": 1.5,- "include_tip": False,- "tick_frequency": PI / 4,- },- "y_min": -1.5,- "y_max": 1.5,- "y_axis_config": {- "tick_frequency": 0.5,- "unit_size": 2,- },- },- "graph_x_min": 0,- "graph_x_max": TAU,- "arrow_xs": np.linspace(0, TAU, 13),- "rod_opacity": 0.5,- "wait_time": 30,- "alpha": 0.5,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_clock()- self.add_rod()- self.add_arrows()- self.initialize_updaters()- self.let_play()-- def add_labels_to_axes(self):- x_axis = self.axes.x_axis- x_axis.add(*[- TexMobject(tex).scale(0.5).next_to(- x_axis.n2p(n),- DOWN,- buff=MED_SMALL_BUFF- )- for tex, n in [- ("\\tau \\over 4", TAU / 4),- ("\\tau \\over 2", TAU / 2),- ("3 \\tau \\over 4", 3 * TAU / 4),- ("\\tau", TAU),- ]- ])-- def add_axes(self):- super().add_axes()- self.add_labels_to_axes()-- def add_rod(self):- super().add_rod()- self.rod.set_opacity(self.rod_opacity)- self.rod.set_stroke(width=0)-- def initial_function(self, x):- return np.sin(x)-- def y_to_color(self, y):- return temperature_to_color(0.8 * y)---class StraightLine3DGraph(TemperatureGraphScene):- CONFIG = {- "axes_config": {- "z_min": 0,- "z_max": 10,- "z_axis_config": {- 'unit_size': 0.5,- }- },- "c": 1.2,- }-- def construct(self):- axes = self.get_three_d_axes()- axes.add(axes.input_plane)- axes.move_to(2 * IN + UP, IN)- surface = self.get_surface(- axes, self.func,- )- initial_graph = self.get_initial_state_graph(- axes, lambda x: self.func(x, 0)- )-- plane = self.get_const_time_plane(axes)- initial_graph.add_updater(- lambda m: m.move_to(plane, IN)- )-- self.set_camera_orientation(- phi=80 * DEGREES,- theta=-100 * DEGREES,- )- self.begin_ambient_camera_rotation()-- self.add(axes)- self.add(initial_graph)- self.play(- TransformFromCopy(initial_graph, surface)- )- self.add(surface, initial_graph)- self.wait()-- self.play(- FadeIn(plane),- ApplyMethod(- plane.t_tracker.set_value, 10,- rate_func=linear,- run_time=10,- )- )- self.play(FadeOut(plane))- self.wait(15)-- def func(self, x, t):- return self.c * x---class SimulateLinearGraph(SimulateRealSineCurve):- CONFIG = {- "axes_config": {- "y_min": 0,- "y_max": 3,- "y_axis_config": {- "tick_frequency": 0.5,- "unit_size": 2,- },- },- "arrow_scale_factor": 2,- "alpha": 1,- "wait_time": 40,- "step_size": 0.02,- }-- # def let_play(self):- # pass-- def add_labels_to_axes(self):- pass-- def y_to_color(self, y):- return temperature_to_color(0.8 * (y - 1.5))-- def initial_function(self, x):- axes = self.axes- y_max = axes.y_max- x_max = axes.x_max- slope = y_max / x_max- return slope * x---class EmphasizeBoundaryPoints(SimulateLinearGraph):- CONFIG = {- "wait_time": 30,- }-- def let_play(self):- rod = self.rod- self.graph.update(0.01)- self.arrows.update()-- to_update = VGroup(- self.graph,- self.arrows,- self.time_label,- )- for mob in to_update:- mob.suspend_updating()-- dots = VGroup(- Dot(rod.get_left()),- Dot(rod.get_right()),- )- for dot in dots:- dot.set_height(0.2)- dot.set_color(YELLOW)-- words = TextMobject(- "Different rules\\\\"- "at the boundary"- )- words.next_to(rod, UP)-- arrows = VGroup(*[- Arrow(- words.get_corner(corner),- dot.get_top(),- path_arc=u * 60 * DEGREES,- )- for corner, dot, u in zip(- [LEFT, RIGHT], dots, [1, -1]- )- ])-- self.add(words)- self.play(- LaggedStartMap(- FadeInFromLarge, dots,- scale_factor=5,- ),- LaggedStartMap(- ShowCreation, arrows,- ),- lag_ratio=0.4- )- self.wait()-- for mob in to_update:- mob.resume_updating()-- super().let_play()---class FlatEdgesContinuousEvolution(ShowEvolvingTempGraphWithArrows):- CONFIG = {- "wait_time": 30,- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- ],- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_clock()- self.add_rod()- self.initialize_updaters()- self.add_boundary_lines()- self.let_play()-- def add_boundary_lines(self):-- lines = VGroup(*[- Line(LEFT, RIGHT)- for x in range(2)- ])- lines.set_width(1.5)- lines.set_stroke(WHITE, 5, opacity=0.5)- lines.add_updater(self.update_lines)-- turn_animation_into_updater(- ShowCreation(lines, run_time=2)- )- self.add(lines)-- def update_lines(self, lines):- graph = self.graph- lines[0].move_to(graph.get_start())- lines[1].move_to(graph.get_end())-- def initial_function(self, x):- return ShowEvolvingTempGraphWithArrows.initial_function(self, x)---class MoreAccurateTempFlowWithArrows(ShowEvolvingTempGraphWithArrows):- CONFIG = {- "arrow_scale_factor": 1,- "max_magnitude": 1,- "freq_amplitude_pairs": [- (1, 0.5),- (2, 1),- (3, 0.5),- (4, 0.3),- ],- }-- def setup_axes(self):- super().setup_axes()- y_axis = self.axes.y_axis- y_axis.remove(y_axis.label)---class SlopeToHeatFlow(FlatEdgesContinuousEvolution):- CONFIG = {- "wait_time": 20,- "xs": [1.75, 5.25, 7.8],- "axes_config": {- "x_min": 0,- "x_max": 10,- "x_axis_config": {- "include_tip": False,- }- },- "n_arrows": 10,- "random_seed": 1,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_rod()- #- self.show_slope_labels()- self.show_heat_flow()-- def show_slope_labels(self):- axes = self.axes- # axes.x_axis.add_numbers()- graph = self.graph- xs = self.xs-- lines = VGroup(*[- TangentLine(- graph,- inverse_interpolate(- axes.x_min,- axes.x_max,- x- ),- length=2,- stroke_opacity=0.75,- )- for x in xs- ])-- slope_words = VGroup()- for line in lines:- slope = line.get_slope()- word = TextMobject(- "Slope =",- "${:.2}$".format(slope)- )- if slope > 0:- word[1].set_color(GREEN)- else:- word[1].set_color(RED)-- word.set_width(line.get_length())- word.next_to(ORIGIN, UP, SMALL_BUFF)- word.rotate(- line.get_angle(),- about_point=ORIGIN,- )- word.shift(line.get_center())- slope_words.add(word)-- self.play(- LaggedStartMap(ShowCreation, lines),- LaggedStartMap(Write, slope_words),- lag_ratio=0.5,- run_time=1,- )- self.wait()-- self.lines = lines- self.slope_words = slope_words-- def show_heat_flow(self):- axes = self.axes- xs = self.xs- slope_words = self.slope_words- tan_lines = self.lines-- slopes = map(Line.get_slope, self.lines)- flow_rates = [-s for s in slopes]-- points = list(map(axes.x_axis.n2p, xs))- v_lines = VGroup(*[- Line(- line.get_center(), point,- stroke_width=1,- )- for point, line in zip(points, tan_lines)- ])-- flow_words = VGroup(*[- TextMobject("Heat flow").next_to(- point, DOWN- ).scale(0.8)- for point in points- ])- flow_mobjects = VGroup(*[- self.get_flow(x, flow_rate)- for x, flow_rate in zip(xs, flow_rates)- ])-- self.add(flow_mobjects)- self.wait()- self.play(- LaggedStart(*[- TransformFromCopy(- sw[0], fw[0]- )- for sw, fw in zip(slope_words, flow_words)- ]),- LaggedStartMap(ShowCreation, v_lines),- lag_ratio=0.4,- run_time=2,- )- self.wait(self.wait_time)-- def get_flow(self, x, flow_rate):- return VGroup(*[- self.get_single_flow_arrow(- x, flow_rate,- t_offset=to- )- for to in np.linspace(0, 5, self.n_arrows)- ])-- def get_single_flow_arrow(self, x, flow_rate, t_offset):- axes = self.axes- point = axes.x_axis.n2p(x)-- h_shift = 0.5- v_shift = 0.4 * np.random.random() + 0.1-- arrow = Vector(0.5 * RIGHT * np.sign(flow_rate))- arrow.move_to(point)- arrow.shift(v_shift * UP)- lp = arrow.get_center() + h_shift * LEFT- rp = arrow.get_center() + h_shift * RIGHT- lc = self.rod_point_to_color(lp)- rc = self.rod_point_to_color(rp)-- run_time = 3 / flow_rate- animation = UpdateFromAlphaFunc(- arrow,- lambda m, a: m.move_to(- interpolate(lp, rp, a)- ).set_color(- interpolate_color(lc, rc, a)- ).set_opacity(there_and_back(a)),- run_time=run_time,- )- result = cycle_animation(animation)- animation.total_time += t_offset- return result---class CloserLookAtStraightLine(SimulateLinearGraph):- def construct(self):- self.add_axes()- self.add_graph()- self.add_clock()- self.add_rod()- # self.initialize_updaters()- #- self.show_t_eq_0_state()- self.show_t_gt_0_state()-- def show_t_eq_0_state(self):- t_eq = TexMobject("t", "=", "0")- t_eq.next_to(self.time_label, DOWN)-- circles = VGroup(*[- Circle(- radius=0.25,- stroke_color=YELLOW,- )- for x in range(2)- ])- circles.add_updater(self.attach_to_endpoints)-- self.play(Write(t_eq))- self.play(ShowCreation(circles))- self.wait()- self.play(FadeOut(circles))-- self.circles = circles- self.t_eq = t_eq-- def show_t_gt_0_state(self):- # circles = self.circles- t_eq = self.t_eq-- t_ineq = TexMobject("t", ">", "0")- t_ineq.move_to(t_eq)-- slope_lines = VGroup(*[- Line(LEFT, RIGHT)- for x in range(2)- ])- slope_lines.set_opacity(0.5)- slope_lines.add_updater(self.attach_to_endpoints)-- self.remove(t_eq)- self.add(t_ineq)-- self.initialize_updaters()- self.run_clock(0.1)- for mob in self.mobjects:- mob.suspend_updating()- self.wait()-- self.add(slope_lines)- self.add(self.clock, self.time_label, t_ineq)- self.play(ShowCreation(slope_lines))- for mob in self.mobjects:- mob.resume_updating()-- self.run_clock(self.wait_time)-- #- def attach_to_endpoints(self, mobs):- points = [- self.graph.get_start(),- self.graph.get_end(),- ]- for mob, point in zip(mobs, points):- mob.move_to(point)- return mobs---class ManipulateSinExpSurface(TemperatureGraphScene):- CONFIG = {- "axes_config": {- "z_max": 1.25,- "z_min": -1.25,- "z_axis_config": {- "unit_size": 2.5,- "tick_frequency": 0.5,- },- "x_axis_config": {- # "unit_size": 1.5,- "unit_size": 1.0,- "tick_frequency": 1,- },- "x_max": 10,- "y_max": 15,- },- "alpha": 0.2,- "tex_mobject_config": {- "tex_to_color_map": {- "{x}": GREEN,- "{t}": YELLOW,- "\\omega": MAROON_B,- "^2": WHITE,- },- },- "graph_config": {},- "initial_phi": -90 * DEGREES,- "initial_omega": 1,- }-- def construct(self):- self.setup_axes()- self.add_sine_wave()- self.shift_sine_to_cosine()- self.show_derivatives_of_cos()- self.show_cos_exp_surface()- self.change_frequency()- self.talk_through_omega()- self.show_cos_omega_derivatives()- self.show_rebalanced_exp()-- def setup_axes(self):- axes = self.get_three_d_axes(include_numbers=True)- axes.x_axis.remove(axes.x_axis.numbers)- L = TexMobject("L")- L.rotate(90 * DEGREES, RIGHT)- L.next_to(axes.x_axis.get_end(), IN)- axes.x_axis.label = L- axes.x_axis.add(L)-- axes.shift(5 * LEFT + 0.5 * IN)- axes.z_axis.label[0].remove(- *axes.z_axis.label[0][1:]- )- axes.z_axis.label.next_to(- axes.z_axis.get_end(), OUT- )- axes.z_axis.add_numbers(- *np.arange(-1, 1.5, 0.5),- direction=LEFT,- number_config={- "num_decimal_places": 1,- }- )- for number in axes.z_axis.numbers:- number.rotate(90 * DEGREES, RIGHT)-- self.set_camera_orientation(- phi=90 * DEGREES,- theta=-90 * DEGREES,- distance=100,- )-- self.add(axes)- self.remove(axes.y_axis)- self.axes = axes-- def add_sine_wave(self):- self.initialize_parameter_trackers()- graph = self.get_graph()- sin_label = TexMobject(- "\\sin\\left({x}\\right)",- **self.tex_mobject_config,- )- sin_label.shift(2 * LEFT + 2.75 * UP)-- self.add_fixed_in_frame_mobjects(sin_label)- graph.suspend_updating()- self.play(- ShowCreation(graph),- Write(sin_label),- )- graph.resume_updating()- self.wait()-- self.sin_label = sin_label- self.graph = graph-- def shift_sine_to_cosine(self):- graph = self.graph- sin_label = self.sin_label-- sin_cross = Cross(sin_label)- sin_cross.add_updater(- lambda m: m.move_to(sin_label)- )- cos_label = TexMobject(- "\\cos\\left({x}\\right)",- **self.tex_mobject_config,- )- cos_label.move_to(sin_label, LEFT)- cos_label.shift(LEFT)- # cos_label.shift(- # axes.c2p(0, 0) - axes.c2p(PI / 2, 0),- # )-- left_tangent = Line(ORIGIN, RIGHT)- left_tangent.set_stroke(WHITE, 5)-- self.add_fixed_in_frame_mobjects(cos_label)- self.play(- ApplyMethod(- self.phi_tracker.set_value, 0,- ),- FadeOutAndShift(sin_label, LEFT),- FadeInFrom(cos_label, RIGHT),- run_time=2,- )- left_tangent.move_to(graph.get_start(), LEFT)- self.play(ShowCreation(left_tangent))- self.play(FadeOut(left_tangent))-- self.cos_label = cos_label-- def show_derivatives_of_cos(self):- cos_label = self.cos_label- cos_exp_label = TexMobject(- "\\cos\\left({x}\\right)",- "e^{-\\alpha {t}}",- **self.tex_mobject_config- )- cos_exp_label.move_to(cos_label, LEFT)-- ddx_group, ddx_exp_group = [- self.get_ddx_computation_group(- label,- *[- TexMobject(- s + "\\left({x}\\right)" + exp,- **self.tex_mobject_config,- )- for s in ["-\\sin", "-\\cos"]- ]- )- for label, exp in [- (cos_label, ""),- (cos_exp_label, "e^{-\\alpha {t}}"),- ]- ]-- self.add_fixed_in_frame_mobjects(ddx_group)- self.play(FadeIn(ddx_group))- self.wait()-- # Cos exp- transforms = [- ReplacementTransform(- cos_label, cos_exp_label,- ),- ReplacementTransform(- ddx_group, ddx_exp_group,- ),- ]- for trans in transforms:- trans.begin()- self.add_fixed_in_frame_mobjects(trans.mobject)- self.play(*transforms)- self.add_fixed_in_frame_mobjects(- cos_exp_label, ddx_exp_group- )- self.remove_fixed_in_frame_mobjects(- cos_label,- *[- trans.mobject- for trans in transforms- ]- )-- self.cos_exp_label = cos_exp_label- self.ddx_exp_group = ddx_exp_group-- def show_cos_exp_surface(self):- axes = self.axes-- surface = self.get_cos_exp_surface()- self.add(surface)- surface.max_t_tracker.set_value(0)- self.move_camera(- phi=85 * DEGREES,- theta=-80 * DEGREES,- added_anims=[- ApplyMethod(- surface.max_t_tracker.set_value,- axes.y_max,- run_time=4,- ),- Write(axes.y_axis),- ]- )- self.wait()-- self.surface = surface-- def change_frequency(self):- cos_exp_label = self.cos_exp_label- ddx_exp_group = self.ddx_exp_group- omega_tracker = self.omega_tracker-- cos_omega = TexMobject(- "\\cos\\left(",- "\\omega", "\\cdot", "{x}",- "\\right)",- **self.tex_mobject_config- )- cos_omega.move_to(cos_exp_label, LEFT)-- omega = cos_omega.get_part_by_tex("\\omega")- brace = Brace(omega, UP, buff=SMALL_BUFF)- omega_decimal = always_redraw(- lambda: DecimalNumber(- omega_tracker.get_value(),- color=omega.get_color(),- ).next_to(brace, UP, SMALL_BUFF)- )-- self.add_fixed_in_frame_mobjects(- cos_omega,- brace,- omega_decimal,- )- self.play(- self.camera.phi_tracker.set_value, 90 * DEGREES,- self.camera.theta_tracker.set_value, -90 * DEGREES,- FadeOut(self.surface),- FadeOut(self.axes.y_axis),- FadeOut(cos_exp_label),- FadeOut(ddx_exp_group),- FadeIn(cos_omega),- GrowFromCenter(brace),- FadeInFromDown(omega_decimal)- )- for n in [2, 6, 1, 4]:- freq = n * PI / self.axes.x_max- self.play(- omega_tracker.set_value, freq,- run_time=2- )- self.wait()- self.wait()-- self.cos_omega = cos_omega- self.omega_brace = brace-- def talk_through_omega(self):- axes = self.axes-- x_tracker = ValueTracker(0)- get_x = x_tracker.get_value- v_line = always_redraw(lambda: DashedLine(- axes.c2p(get_x(), 0, 0),- axes.c2p(get_x(), 0, self.func(get_x(), 0)),- ))-- x = self.cos_omega.get_part_by_tex("{x}")- brace = Brace(x, DOWN)- x_decimal = always_redraw(- lambda: DecimalNumber(- get_x(),- color=x.get_color()- ).next_to(brace, DOWN, SMALL_BUFF)- )-- self.add(v_line)- self.add_fixed_in_frame_mobjects(brace, x_decimal)- self.play(- x_tracker.set_value, 5,- run_time=5,- rate_func=linear,- )- self.play(- FadeOut(v_line),- FadeOut(brace),- FadeOut(x_decimal),- )- self.remove_fixed_in_frame_mobjects(- brace, x_decimal- )-- def show_cos_omega_derivatives(self):- cos_omega = self.cos_omega- ddx_omega_group = self.get_ddx_computation_group(- cos_omega,- *[- TexMobject(- s + "\\left(\\omega \\cdot {x}\\right)",- **self.tex_mobject_config,- )- for s in ["-\\omega \\sin", "-\\omega^2 \\cos"]- ]- )-- omega_squared = ddx_omega_group[-1][1:3]- rect = SurroundingRectangle(omega_squared)-- self.add_fixed_in_frame_mobjects(ddx_omega_group)- self.play(FadeIn(ddx_omega_group))- self.wait()- self.add_fixed_in_frame_mobjects(rect)- self.play(ShowCreationThenFadeOut(rect))- self.wait()-- self.ddx_omega_group = ddx_omega_group-- def show_rebalanced_exp(self):- cos_omega = self.cos_omega- ddx_omega_group = self.ddx_omega_group-- cos_exp = TexMobject(- "\\cos\\left(",- "\\omega", "\\cdot", "{x}",- "\\right)",- "e^{-\\alpha \\omega^2 {t}}",- **self.tex_mobject_config- )- cos_exp.move_to(cos_omega, DL)-- self.add_fixed_in_frame_mobjects(cos_exp)- self.play(- FadeOut(cos_omega),- FadeOut(ddx_omega_group),- FadeIn(cos_exp),- )- self.remove_fixed_in_frame_mobjects(- cos_omega,- ddx_omega_group,- )-- self.play(- FadeIn(self.surface),- FadeIn(self.axes.y_axis),- VGroup(- cos_exp,- self.omega_brace,- ).shift, 4 * RIGHT,- self.camera.phi_tracker.set_value, 80 * DEGREES,- self.camera.theta_tracker.set_value, -80 * DEGREES,- )- self.wait()- self.play(- self.omega_tracker.set_value, TAU / 10,- run_time=6,- )-- #- def initialize_parameter_trackers(self):- self.phi_tracker = ValueTracker(- self.initial_phi- )- self.omega_tracker = ValueTracker(- self.initial_omega- )- self.t_tracker = ValueTracker(0)-- def get_graph(self):- return always_redraw(- lambda: self.get_time_slice_graph(- self.axes, self.func,- t=self.t_tracker.get_value(),- **self.graph_config- )- )-- def get_cos_exp_surface(self):- max_t_tracker = ValueTracker(self.axes.y_max)- surface = always_redraw(- lambda: self.get_surface(- self.axes,- self.func,- v_max=max_t_tracker.get_value(),- )- )- surface.max_t_tracker = max_t_tracker- return surface-- def func(self, x, t):- phi = self.phi_tracker.get_value()- omega = self.omega_tracker.get_value()- alpha = self.alpha- return op.mul(- np.cos(omega * (x + phi)),- np.exp(-alpha * (omega**2) * t)- )-- def get_ddx_computation_group(self, f, df, ddf):- arrows = VGroup(*[- Vector(0.5 * RIGHT) for x in range(2)- ])- group = VGroup(- arrows[0], df, arrows[1], ddf- )- group.arrange(RIGHT)- group.next_to(f, RIGHT)-- for arrow in arrows:- label = TexMobject(- "\\partial \\over \\partial {x}",- **self.tex_mobject_config,- )- label.scale(0.5)- label.next_to(arrow, UP, SMALL_BUFF)- arrow.add(label)-- group.arrows = arrows- group.funcs = VGroup(df, ddf)-- return group---class ShowFreq1CosExpDecay(ManipulateSinExpSurface):- CONFIG = {- "freq": 1,- "alpha": 0.2,- }-- def construct(self):- self.setup_axes()- self.add_back_y_axis()- self.initialize_parameter_trackers()- self.phi_tracker.set_value(0)- self.omega_tracker.set_value(- self.freq * TAU / 10,- )- #- self.show_decay()-- def add_back_y_axis(self):- axes = self.axes- self.add(axes.y_axis)- self.remove(axes.y_axis.numbers)- self.remove(axes.y_axis.label)-- def show_decay(self):- axes = self.axes- t_tracker = self.t_tracker- t_max = self.axes.y_max-- graph = always_redraw(- lambda: self.get_time_slice_graph(- axes,- self.func,- t=t_tracker.get_value(),- stroke_width=5,- )- )-- surface = self.get_surface(- self.axes, self.func,- )- plane = self.get_const_time_plane(axes)-- self.add(surface, plane, graph)-- self.set_camera_orientation(- phi=80 * DEGREES,- theta=-85 * DEGREES,- )- self.begin_ambient_camera_rotation(rate=0.01)- self.play(- t_tracker.set_value, t_max,- plane.t_tracker.set_value, t_max,- run_time=t_max,- rate_func=linear,- )---class ShowFreq2CosExpDecay(ShowFreq1CosExpDecay):- CONFIG = {- "freq": 2,- }---class ShowFreq4CosExpDecay(ShowFreq1CosExpDecay):- CONFIG = {- "freq": 4,- }---class ShowHarmonics(SimulateRealSineCurve):- CONFIG = {- "rod_opacity": 0.75,- "initial_omega": 1.27,- "default_n_rod_pieces": 32,- }-- def construct(self):- self.add_axes()- self.add_graph()- self.add_rod()- self.rod.add_updater(self.color_rod_by_graph)- #- self.show_formula()-- def add_graph(self):- omega_tracker = ValueTracker(self.initial_omega)- get_omega = omega_tracker.get_value- graph = always_redraw(- lambda: self.axes.get_graph(- lambda x: np.cos(get_omega() * x),- x_min=self.graph_x_min,- x_max=self.graph_x_max,- step_size=self.step_size,- discontinuities=[5],- ).color_using_background_image("VerticalTempGradient")- )-- self.add(graph)- self.graph = graph- self.omega_tracker = omega_tracker-- def show_formula(self):- rod = self.rod- graph = self.graph- axes = self.axes- omega_tracker = self.omega_tracker- L = TAU-- formula = TexMobject(- "=", "\\cos\\left(",- "2(\\pi / L)", "\\cdot", "{x}",- "\\right)",- tex_to_color_map={- "{x}": GREEN,- }- )- formula.next_to(- self.axes.y_axis.label, RIGHT, SMALL_BUFF- )- omega_part = formula.get_part_by_tex("\\pi")- omega_brace = Brace(omega_part, DOWN)- omega = TexMobject("\\omega")- omega.set_color(MAROON_B)- omega.next_to(omega_brace, DOWN, SMALL_BUFF)- formula.remove(omega_part)-- pi_over_L = TexMobject("(\\pi / L)")- pi_over_L.move_to(omega_part)- pi_over_L.match_color(omega)-- self.add(formula)- self.add(omega_brace)- self.add(omega)-- self.remove(graph)- self.play(GrowFromEdge(rod, LEFT))- self.play(- ShowCreationThenFadeAround(axes.x_axis.label)- )- self.wait()- self.play(FadeIn(graph))- self.play(FadeInFromDown(pi_over_L))- self.play(- omega_tracker.set_value, PI / L,- run_time=2- )- self.wait()-- # Show x- x_tracker = ValueTracker(0)- tip = ArrowTip(- start_angle=-90 * DEGREES,- color=WHITE,- )- tip.add_updater(lambda m: m.move_to(- axes.x_axis.n2p(x_tracker.get_value()),- DOWN,- ))- x_sym = TexMobject("x")- x_sym.set_color(GREEN)- x_sym.add_background_rectangle(buff=SMALL_BUFF)- x_sym.add_updater(lambda m: m.next_to(tip, UP, SMALL_BUFF))-- self.play(- Write(tip),- Write(x_sym),- )- self.play(- x_tracker.set_value, L,- run_time=3,- )- self.wait()- self.play(TransformFromCopy(- x_sym, formula.get_part_by_tex("{x}")- ))- self.play(- FadeOut(tip),- FadeOut(x_sym),- )-- # Harmonics- pi_over_L.generate_target()- n_sym = Integer(2)- n_sym.match_color(pi_over_L)- group = VGroup(n_sym, pi_over_L.target)- group.arrange(RIGHT, buff=SMALL_BUFF)- group.move_to(pi_over_L)-- self.play(- MoveToTarget(pi_over_L),- FadeInFromDown(n_sym),- ApplyMethod(- omega_tracker.set_value, 2 * PI / L,- run_time=2,- )- )- self.wait()- for n in [*range(3, 9), 0]:- new_n_sym = Integer(n)- new_n_sym.move_to(n_sym, DR)- new_n_sym.match_style(n_sym)- self.play(- FadeOutAndShift(n_sym, UP),- FadeInFrom(new_n_sym, DOWN),- omega_tracker.set_value, n * PI / L,- )- self.wait()- n_sym = new_n_sym-- #- def add_labels_to_axes(self):- x_axis = self.axes.x_axis- L = TexMobject("L")- L.next_to(x_axis.get_end(), DOWN)- x_axis.add(L)- x_axis.label = L---class ShowHarmonicSurfaces(ManipulateSinExpSurface):- CONFIG = {- "alpha": 0.2,- "initial_phi": 0,- "initial_omega": PI / 10,- "n_iterations": 8,- "default_surface_config": {- "resolution": (40, 30),- "surface_piece_config": {- "stroke_width": 0.5,- }- }- }-- def construct(self):- self.setup_axes()- self.initialize_parameter_trackers()- self.add_surface()- self.add_graph()- self.show_all_harmonic_surfaces()-- def setup_axes(self):- super().setup_axes()- self.add(self.axes.y_axis)- self.set_camera_orientation(- phi=82 * DEGREES,- theta=-80 * DEGREES,- )-- def add_surface(self):- self.surface = self.get_cos_exp_surface()- self.add(self.surface)-- def add_graph(self):- self.graph = self.get_graph()- self.add(self.graph)-- def show_all_harmonic_surfaces(self):- omega_tracker = self.omega_tracker- formula = self.get_formula(str(1))- L = self.axes.x_max-- self.begin_ambient_camera_rotation(rate=0.01)- self.add_fixed_in_frame_mobjects(formula)- self.wait(2)- for n in range(2, self.n_iterations):- if n > 5:- n_str = "n"- else:- n_str = str(n)- new_formula = self.get_formula(n_str)- self.play(- Transform(formula, new_formula),- ApplyMethod(- omega_tracker.set_value,- n * PI / L- ),- )- self.wait(3)-- #- def get_formula(self, n_str):- n_str = "{" + n_str + "}"- result = TexMobject(- "\\cos\\left(",- n_str, "(", "\\pi / L", ")", "{x}"- "\\right)"- "e^{-\\alpha (", n_str, "\\pi / L", ")^2",- "{t}}",- tex_to_color_map={- "{x}": GREEN,- "{t}": YELLOW,- "\\pi / L": MAROON_B,- n_str: MAROON_B,- }- )- result.to_edge(UP)- return result---class Thumbnail(ShowHarmonicSurfaces):- CONFIG = {- "default_surface_config": {- "resolution": (40, 30),- # "resolution": (10, 10),- },- "graph_config": {- "stroke_width": 8,- },- }-- def construct(self):- self.setup_axes()- self.initialize_parameter_trackers()- self.add_surface()- self.add_graph()- #- self.omega_tracker.set_value(3 * PI / 10)- self.set_camera_orientation(- theta=-70 * DEGREES,- )-- axes = self.axes- for axis in [axes.y_axis, axes.z_axis]:- axis.numbers.set_opacity(0)- axis.remove(*axis.numbers)- axes.x_axis.label.set_opacity(0)- axes.z_axis.label.set_opacity(0)-- for n in range(2, 16, 2):- new_graph = self.get_time_slice_graph(- axes, self.func, t=n,- **self.graph_config- )- new_graph.set_shade_in_3d(True)- new_graph.set_stroke(- width=8 / np.sqrt(n),- # opacity=1 / n**(1 / 4),- )- self.add(new_graph)-- words = TextMobject(- "Sine waves + Linearity + Fourier = Solution"- )- words.set_width(FRAME_WIDTH - 1)- words.to_edge(DOWN)- words.shift(2 * DOWN)- self.add_fixed_in_frame_mobjects(words)-- self.camera.frame_center.shift(DOWN)- self.update_mobjects(0)- self.surface.set_stroke(width=0.1)- self.surface.set_fill(opacity=0.2)diff --git a/active_projects/ode/part3/wordy_scenes.py b/active_projects/ode/part3/wordy_scenes.pydeleted file mode 100644index e1160ff80..000000000--- a/active_projects/ode/part3/wordy_scenes.py+++ /dev/null@@ -1,919 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part2.wordy_scenes import *---class ThreeMainObservations(Scene):- def construct(self):- fourier = ImageMobject("Joseph Fourier")- name = TextMobject("Joseph Fourier")- name.match_width(fourier)- name.next_to(fourier, DOWN, SMALL_BUFF)- fourier.add(name)- fourier.set_height(5)- fourier.to_corner(DR)- fourier.shift(LEFT)- bubble = ThoughtBubble(- direction=RIGHT,- height=3,- width=4,- )- bubble.move_tip_to(fourier.get_corner(UL) + 0.5 * DR)-- observations = VGroup(- TextMobject(- "1)",- "Sine = Nice",- ),- TextMobject(- "2)",- "Linearity"- ),- TextMobject(- "3)",- "Fourier series"- ),- )- # heart = SuitSymbol("hearts")- # heart.replace(observations[0][2])- # observations[0][2].become(heart)- # observations[0][1].add(happiness)- # observations[2][2].align_to(- # observations[2][1], LEFT,- # )-- observations.arrange(- DOWN,- aligned_edge=LEFT,- buff=2 * LARGE_BUFF,- )- observations.set_height(FRAME_HEIGHT - 2)- observations.to_corner(UL, buff=LARGE_BUFF)-- self.add(fourier)- self.play(ShowCreation(bubble))- self.wait()- self.play(LaggedStart(*[- TransformFromCopy(bubble, observation[0])- for observation in observations- ], lag_ratio=0.2))- self.play(- FadeOut(fourier),- FadeOut(bubble),- )- self.wait()- for obs in observations:- self.play(FadeInFrom(obs[1], LEFT))- self.wait()---class LastChapterWrapper(Scene):- def construct(self):- full_rect = FullScreenFadeRectangle(- fill_color=DARK_GREY,- fill_opacity=1,- )- rect = ScreenRectangle(height=6)- rect.set_stroke(WHITE, 2)- rect.set_fill(BLACK, 1)- title = TextMobject("Last chapter")- title.scale(2)- title.to_edge(UP)- rect.next_to(title, DOWN)-- self.add(full_rect)- self.play(- FadeIn(rect),- Write(title, run_time=2),- )- self.wait()---class ThreeConstraints(WriteHeatEquationTemplate):- def construct(self):- self.cross_out_solving()- self.show_three_conditions()-- def cross_out_solving(self):- equation = self.get_d1_equation()- words = TextMobject("Solve this equation")- words.to_edge(UP)- equation.next_to(words, DOWN)- cross = Cross(words)-- self.add(words, equation)- self.wait()- self.play(ShowCreation(cross))- self.wait()-- self.equation = equation- self.to_remove = VGroup(words, cross)-- def show_three_conditions(self):- equation = self.equation- to_remove = self.to_remove-- title = TexMobject(- "\\text{Constraints }"- "T({x}, {t})"- "\\text{ must satisfy:}",- **self.tex_mobject_config- )- title.to_edge(UP)-- items = VGroup(- TextMobject("1)", "The PDE"),- TextMobject("2)", "Boundary condition"),- TextMobject("3)", "Initial condition"),- )- items.scale(0.7)- items.arrange(RIGHT, buff=LARGE_BUFF)- items.set_width(FRAME_WIDTH - 2)- items.next_to(title, DOWN, LARGE_BUFF)- items[1].set_color(MAROON_B)- items[2].set_color(RED)-- bc_paren = TextMobject("(Explained soon)")- bc_paren.scale(0.7)- bc_paren.next_to(items[1], DOWN)-- self.play(- FadeInFromDown(title),- FadeOutAndShift(to_remove, UP),- equation.scale, 0.6,- equation.next_to, items[0], DOWN,- equation.shift_onto_screen,- LaggedStartMap(FadeIn, [- items[0],- items[1][0],- items[2][0],- ])- )- self.wait()- self.play(Write(items[1][1]))- bc_paren.match_y(equation)- self.play(FadeInFrom(bc_paren, UP))- self.wait(2)- self.play(Write(items[2][1]))- self.wait(2)-- self.title = title- self.items = items- self.pde = equation- self.bc_paren = bc_paren---class RectAroundEquation(WriteHeatEquationTemplate):- def construct(self):- eq = self.get_d1_equation()- self.play(ShowCreationThenFadeAround(eq))---class BorderRect(Scene):- def construct(self):- rect = FullScreenFadeRectangle()- rect.set_stroke(WHITE, 3)- rect.set_fill(opacity=0)- self.add(rect)---class SeekIdealized(Scene):- def construct(self):- phrases = VGroup(*[- TextMobject(- "Seek", text, "problems",- tex_to_color_map={- "realistic": GREEN,- "{idealized}": YELLOW,- "over-idealized": YELLOW,- "general": BLUE,- }- )- for text in [- "realistic",- "{idealized}",- "over-idealized",- "general",- ]- ])- phrases.scale(2)- words = VGroup()- for phrase in phrases:- phrase.center()- word = phrase[1]- words.add(word)- phrase.remove(word)- arrow = Vector(DOWN)- arrow.set_stroke(WHITE, 6)- arrow.next_to(words[3], UP)- low_arrow = arrow.copy()- low_arrow.next_to(words[3], DOWN)-- solutions = TextMobject("solutions")- solutions.scale(2)- solutions.move_to(phrases[3][1], UL)- models = TextMobject("models")- models.scale(2)- models.next_to(- words[0], RIGHT, buff=0.35,- aligned_edge=DOWN- )-- phrases.center()- phrase = phrases[0]-- self.add(phrase)- self.add(words[0])- self.wait()- words[0].save_state()- self.play(- words[0].to_edge, DOWN,- words[0].set_opacity, 0.5,- Transform(phrase, phrases[1]),- FadeInFrom(words[1], UP)- )- self.wait()- # self.play(- # words[1].move_to, words[2], RIGHT,- # FadeIn(words[2]),- # Transform(phrase, phrases[2])- # )- # self.wait()- self.play(- words[1].next_to, arrow, UP,- ShowCreation(arrow),- MaintainPositionRelativeTo(- phrase, words[1]- ),- FadeInFrom(solutions, LEFT),- FadeIn(words[3]),- )- self.wait()-- words[0].generate_target()- words[0].target.next_to(low_arrow, DOWN)- words[0].target.set_opacity(1)- models.shift(- words[0].target.get_center() -- words[0].saved_state.get_center()- )- self.play(- MoveToTarget(words[0]),- ShowCreation(low_arrow),- FadeInFrom(models, LEFT)- )- self.wait()---class SecondDerivativeOfSine(Scene):- def construct(self):- equation = TexMobject(- "{d^2 \\over d{x}^2}",- "\\cos\\left({x}\\right) =",- "-\\cos\\left({x}\\right)",- tex_to_color_map={- "{x}": GREEN,- }- )-- self.add(equation)---class EquationAboveSineAnalysis(WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d1_equation()- equation.to_edge(UP)- equation.shift(2 * LEFT)- eq_index = equation.index_of_part_by_tex("=")- lhs = equation[:eq_index]- eq = equation[eq_index]- rhs = equation[eq_index + 1:]- t_terms = equation.get_parts_by_tex("{t}")[1:]- t_terms.save_state()- zeros = VGroup(*[- TexMobject("0").replace(t, dim_to_match=1)- for t in t_terms- ])- zeros.align_to(t_terms, DOWN)- new_rhs = TexMobject(- "=", "-\\alpha \\cdot {T}", "({x}, 0)",- **self.tex_mobject_config- )- # new_rhs.move_to(equation.get_right())- # new_rhs.next_to(equation, DOWN, MED_LARGE_BUFF)- # new_rhs.align_to(eq, LEFT)- new_rhs.next_to(equation, RIGHT)- new_rhs.shift(SMALL_BUFF * DOWN)-- self.add(equation)- self.play(ShowCreationThenFadeAround(rhs))- self.wait()- self.play(- FadeOutAndShift(t_terms, UP),- FadeInFrom(zeros, DOWN),- )- t_terms.fade(1)- self.wait()- self.play(- # VGroup(equation, zeros).next_to,- # new_rhs, LEFT,- FadeIn(new_rhs),- )- self.wait()- self.play(- VGroup(- lhs[6:],- eq,- rhs,- new_rhs[0],- new_rhs[-3:],- zeros,- ).fade, 0.5,- )- self.play(ShowCreationThenFadeAround(lhs[:6]))- self.play(ShowCreationThenFadeAround(new_rhs[1:-3]))- self.wait()---class ExpVideoWrapper(Scene):- def construct(self):- self.add(FullScreenFadeRectangle(- fill_color=DARKER_GREY,- fill_opacity=1,- ))-- screen = ImageMobject("eoc_chapter5_thumbnail")- screen.set_height(6)- rect = SurroundingRectangle(screen, buff=0)- rect.set_stroke(WHITE, 2)- screen.add(rect)- title = TextMobject("Need a refresher?")- title.scale(1.5)- title.to_edge(UP)- screen.next_to(title, DOWN)-- screen.center()- self.play(- # FadeInFrom(title, LEFT),- FadeInFrom(screen, DOWN),- )- self.wait()---class ShowSinExpDerivatives(WriteHeatEquationTemplate):- CONFIG = {- "tex_mobject_config": {- "tex_to_color_map": {- "{0}": WHITE,- "\\partial": WHITE,- "=": WHITE,- }- }- }-- def construct(self):- pde = self.get_d1_equation_without_inputs()- pde.to_edge(UP)- pde.generate_target()-- new_rhs = TexMobject(- "=- \\alpha \\cdot T",- **self.tex_mobject_config,- )- new_rhs.next_to(pde, RIGHT)- new_rhs.align_to(pde.get_part_by_tex("alpha"), DOWN)-- equation1 = TexMobject(- "T({x}, {0}) = \\sin\\left({x}\\right)",- **self.tex_mobject_config- )- equation2 = TexMobject(- "T({x}, {t}) = \\sin\\left({x}\\right)",- "e^{-\\alpha{t}}",- **self.tex_mobject_config- )- for eq in equation1, equation2:- eq.next_to(pde, DOWN, MED_LARGE_BUFF)-- eq2_part1 = equation2[:len(equation1)]- eq2_part2 = equation2[len(equation1):]-- # Rectangles- exp_rect = SurroundingRectangle(eq2_part2)- exp_rect.set_stroke(RED, 3)- sin_rect = SurroundingRectangle(- eq2_part1[-3:]- )- sin_rect.set_color(BLUE)-- VGroup(pde.target, new_rhs).center().to_edge(UP)-- # Show proposed solution- self.add(pde)- self.add(equation1)- self.wait()- self.play(- MoveToTarget(pde),- FadeInFrom(new_rhs, LEFT)- )- self.wait()- self.play(- ReplacementTransform(equation1, eq2_part1),- FadeIn(eq2_part2),- )- self.play(ShowCreation(exp_rect))- self.wait()- self.play(FadeOut(exp_rect))-- # Take partial derivatives wrt x- q_mark = TexMobject("?")- q_mark.next_to(pde.get_part_by_tex("="), UP)- q_mark.set_color(RED)-- arrow1 = Vector(3 * DOWN + 1 * RIGHT, color=WHITE)- arrow1.scale(1.2 / arrow1.get_length())- arrow1.next_to(- eq2_part2.get_corner(DL),- DOWN, MED_LARGE_BUFF- )- ddx_label1 = TexMobject(- "\\partial \\over \\partial {x}",- **self.tex_mobject_config,- )- ddx_label1.scale(0.7)- ddx_label1.next_to(- arrow1.point_from_proportion(0.8),- UR, SMALL_BUFF- )-- pde_ddx = VGroup(- *pde.get_parts_by_tex("\\partial")[2:],- pde.get_parts_by_tex("\\over")[1],- pde.get_part_by_tex("{x}"),- )- pde_ddx_rect = SurroundingRectangle(pde_ddx)- pde_ddx_rect.set_color(GREEN)-- eq2_part2_rect = SurroundingRectangle(eq2_part2)-- dx = TexMobject(- "\\cos\\left({x}\\right)", "e^{-\\alpha {t}}",- **self.tex_mobject_config- )- ddx = TexMobject(- "-\\sin\\left({x}\\right)", "e^{-\\alpha {t}}",- **self.tex_mobject_config- )- dx.next_to(arrow1, DOWN)- dx.align_to(eq2_part2, RIGHT)- x_shift = arrow1.get_end()[0] - arrow1.get_start()[0]- x_shift *= 2- dx.shift(x_shift * RIGHT)- arrow2 = arrow1.copy()- arrow2.next_to(dx, DOWN)- arrow2.shift(MED_SMALL_BUFF * RIGHT)- dx_arrows = VGroup(arrow1, arrow2)-- ddx_label2 = ddx_label1.copy()- ddx_label2.shift(- arrow2.get_center() - arrow1.get_center()- )- ddx.next_to(arrow2, DOWN)- ddx.align_to(eq2_part2, RIGHT)- ddx.shift(2 * x_shift * RIGHT)-- rhs = equation2[-6:]-- self.play(- FadeInFromDown(q_mark)- )- self.play(- ShowCreation(pde_ddx_rect)- )- self.wait()- self.play(- LaggedStart(- GrowArrow(arrow1),- GrowArrow(arrow2),- ),- TransformFromCopy(- pde_ddx[0], ddx_label1- ),- TransformFromCopy(- pde_ddx[0], ddx_label2- ),- )- self.wait()- self.play(- TransformFromCopy(rhs, dx)- )- self.wait()- self.play(- FadeIn(eq2_part2_rect)- )- self.play(- Transform(- eq2_part2_rect,- SurroundingRectangle(dx[-3:])- )- )- self.play(- FadeOut(eq2_part2_rect)- )- self.wait()- self.play(- TransformFromCopy(dx, ddx)- )- self.play(- FadeIn(- SurroundingRectangle(ddx).match_style(- pde_ddx_rect- )- )- )- self.wait()-- # Take partial derivative wrt t- pde_ddt = pde[:pde.index_of_part_by_tex("=") - 1]- pde_ddt_rect = SurroundingRectangle(pde_ddt)-- dt_arrow = Arrow(- arrow1.get_start(),- arrow2.get_end() + RIGHT,- buff=0- )- dt_arrow.flip(UP)- dt_arrow.next_to(dx_arrows, LEFT, MED_LARGE_BUFF)-- dt_label = TexMobject(- "\\partial \\over \\partial {t}",- **self.tex_mobject_config,- )- dt_label.scale(1)- dt_label.next_to(- dt_arrow.get_center(), UL,- SMALL_BUFF,- )-- rhs_copy = rhs.copy()- rhs_copy.next_to(dt_arrow.get_end(), DOWN)- rhs_copy.shift(MED_LARGE_BUFF * LEFT)- rhs_copy.match_y(ddx)-- minus_alpha_in_exp = rhs_copy[-3][1:].copy()- minus_alpha_in_exp.set_color(RED)- minus_alpha = TexMobject("-\\alpha")- minus_alpha.next_to(rhs_copy, LEFT)- minus_alpha.align_to(rhs_copy[0][0], DOWN)- dot = TexMobject("\\cdot")- dot.move_to(midpoint(- minus_alpha.get_right(),- rhs_copy.get_left(),- ))-- self.play(- TransformFromCopy(- pde_ddx_rect,- pde_ddt_rect,- )- )- self.play(- GrowArrow(dt_arrow),- TransformFromCopy(- pde_ddt,- dt_label,- )- )- self.wait()- self.play(TransformFromCopy(rhs, rhs_copy))- self.play(FadeIn(minus_alpha_in_exp))- self.play(- ApplyMethod(- minus_alpha_in_exp.replace, minus_alpha,- path_arc=TAU / 4- ),- FadeIn(dot),- )- self.play(- FadeIn(minus_alpha),- FadeOut(minus_alpha_in_exp),- )- self.wait()- rhs_copy.add(minus_alpha, dot)- self.play(- FadeIn(SurroundingRectangle(rhs_copy))- )- self.wait()-- #- checkmark = TexMobject("\\checkmark")- checkmark.set_color(GREEN)- checkmark.move_to(q_mark, DOWN)- self.play(- FadeInFromDown(checkmark),- FadeOutAndShift(q_mark, UP)- )- self.wait()---class DerivativesOfLinearFunction(WriteHeatEquationTemplate):- CONFIG = {- "tex_mobject_config": {- "tex_to_color_map": {- "{c}": WHITE,- }- }- }-- def construct(self):- func = TexMobject(- "T({x}, {t}) = {c} \\cdot {x}",- **self.tex_mobject_config- )- dx_T = TexMobject("{c}", **self.tex_mobject_config)- ddx_T = TexMobject("0")- dt_T = TexMobject("0")-- for mob in func, dx_T, ddx_T, dt_T:- mob.scale(1.5)-- func.generate_target()-- arrows = VGroup(*[- Vector(1.5 * RIGHT, color=WHITE)- for x in range(3)- ])- dx_arrows = arrows[:2]- dt_arrow = arrows[2]- dt_arrow.rotate(-TAU / 4)- dx_group = VGroup(- func.target,- dx_arrows[0],- dx_T,- dx_arrows[1],- ddx_T,- )- dx_group.arrange(RIGHT)- for arrow, char, vect in zip(arrows, "xxt", [UP, UP, RIGHT]):- label = TexMobject(- "\\partial \\over \\partial {%s}" % char,- **self.tex_mobject_config- )- label.scale(0.7)- label.next_to(arrow.get_center(), vect)- arrow.add(label)-- dt_arrow.shift(- func.target[-3:].get_bottom() + MED_SMALL_BUFF * DOWN -- dt_arrow.get_start(),- )- dt_T.next_to(dt_arrow.get_end(), DOWN)-- self.play(FadeInFromDown(func))- self.wait()- self.play(- MoveToTarget(func),- LaggedStartMap(Write, dx_arrows),- run_time=1,- )- self.play(- TransformFromCopy(func[-3:], dx_T),- path_arc=-TAU / 4,- )- self.play(- TransformFromCopy(dx_T, ddx_T),- path_arc=-TAU / 4,- )- self.wait()-- # dt- self.play(Write(dt_arrow))- self.play(- TransformFromCopy(func[-3:], dt_T)- )- self.wait()---class FlatAtBoundaryWords(Scene):- def construct(self):- words = self.get_bc_words()- self.play(Write(words))- self.wait()-- def get_bc_words(self):- return TextMobject(- "Flat at boundary\\\\"- "for all", "${t}$", "$> 0$",- )---class WriteOutBoundaryCondition(FlatAtBoundaryWords, ThreeConstraints, MovingCameraScene):- def construct(self):- self.force_skipping()- ThreeConstraints.construct(self)- self.revert_to_original_skipping_status()-- self.add_ic()- self.write_bc_words()- self.write_bc_equation()-- def add_ic(self):- image = ImageMobject("temp_initial_condition_example")- image.set_width(3)- border = SurroundingRectangle(image, buff=SMALL_BUFF)- border.shift(SMALL_BUFF * UP)- border.set_stroke(WHITE, 2)- group = Group(image, border)- group.next_to(self.items[2], DOWN)- self.add(group)-- def write_bc_words(self):- bc_paren = self.bc_paren- bc_words = self.get_bc_words()- bc_words.match_width(self.items[1][1])- bc_words.move_to(bc_paren, UP)- bc_words.set_color_by_tex("{t}", YELLOW)-- self.play(ShowCreationThenFadeAround(- VGroup(self.items[0], self.pde)- ))- self.play(- FadeOutAndShift(bc_paren, UP),- FadeInFrom(bc_words, DOWN),- )- self.wait()-- self.bc_words = bc_words-- def write_bc_equation(self):- bc_words = self.bc_words-- equation = TexMobject(- "{\\partial {T} \\over \\partial {x}}(0, {t}) = ",- "{\\partial {T} \\over \\partial {x}}(L, {t}) = ",- "0",- **self.tex_mobject_config,- )- equation.next_to(bc_words, DOWN, MED_LARGE_BUFF)-- self.play(- self.camera_frame.shift, 0.8 * DOWN,- )- self.play(FadeInFrom(equation, UP))- self.wait()---class HeatEquationFrame(WriteHeatEquationTemplate):- def construct(self):- equation = self.get_d1_equation()- equation.to_edge(UP, buff=MED_SMALL_BUFF)-- ddx = equation[-11:]- dt = equation[:11]-- full_rect = FullScreenFadeRectangle(- fill_color=DARK_GREY,- fill_opacity=1,- )- smaller_rect = ScreenRectangle(- height=6,- fill_color=BLACK,- fill_opacity=1,- stroke_color=WHITE,- stroke_width=2,- )- smaller_rect.next_to(equation, DOWN)-- self.add(full_rect)- self.add(smaller_rect)- self.add(equation)- self.wait()- self.play(ShowCreationThenFadeAround(- ddx,- surrounding_rectangle_config={- "stroke_color": GREEN,- }- ))- self.wait()- self.play(ShowCreationThenFadeAround(dt))- self.wait()---class CompareFreqDecays1to2(Scene):- CONFIG = {- "freqs": [1, 2]- }-- def construct(self):- background = FullScreenFadeRectangle(- fill_color=DARKER_GREY,- fill_opacity=1,- )-- screens = VGroup(*[- ScreenRectangle(- height=4,- fill_color=BLACK,- fill_opacity=1,- stroke_width=1,- stroke_color=WHITE,- )- for x in range(2)- ])- screens.arrange(RIGHT)- screens.set_width(FRAME_WIDTH - 1)-- formulas = VGroup(*[- self.get_formula(freq)- for freq in self.freqs- ])- for formula, screen in zip(formulas, screens):- formula.next_to(screen, UP)-- self.add(background)- self.add(screens)- self.add(formulas)- self.wait()-- def get_formula(self, freq):- f_str = str(freq)- return TexMobject(- "\\cos\\left(%s \\cdot {x}\\right)" % f_str,- "e^{-\\alpha \\cdot %s^2 \\cdot {t}}" % f_str,- tex_to_color_map={- "{x}": GREEN,- "{t}": YELLOW,- f_str: MAROON_B,- }- )---class CompareFreqDecays1to4(CompareFreqDecays1to2):- CONFIG = {- "freqs": [1, 4],- }---class CompareFreqDecays2to4(CompareFreqDecays1to2):- CONFIG = {- "freqs": [2, 4],- }---class WorryAboutGenerality(TeacherStudentsScene, WriteHeatEquationTemplate):- def construct(self):- eq = self.get_d1_equation()- diffyq = self.get_diffyq_set()- is_in = TexMobject("\\in")- is_in.scale(2)-- group = VGroup(eq, is_in, diffyq)- group.arrange(RIGHT, buff=MED_LARGE_BUFF)- group.to_edge(UP)-- arrow = Vector(DOWN)- arrow.set_stroke(WHITE, 5)- arrow.next_to(eq, DOWN)- themes = TextMobject("Frequent themes")- themes.scale(1.5)- themes.next_to(arrow, DOWN)-- self.play(- self.get_student_changes(- "sad", "tired", "pleading"- ),- self.teacher.change, "raise_right_hand",- FadeInFromDown(eq)- )- self.play(Write(group[1:]))- self.wait(2)- self.play(- ShowCreation(arrow),- self.get_student_changes(*3 * ["pondering"]),- )- self.play(- FadeInFrom(themes, UP),- self.get_student_changes(*3 * ["thinking"]),- self.teacher.change, "happy"- )- self.wait(4)--- # def get_d1_equation(self):- # result = super().get_d1_equation()- # lp, rp = parens = TexMobject("(", ")")- # parens.match_height(result)- # lp.next_to(result, LEFT, SMALL_BUFF)- # rp.next_to(result, RIGHT, SMALL_BUFF)- # result.add_to_back(lp)- # result.add(rp)- # return result-- def get_diffyq_set(self):- words = TextMobject(- "Differential\\\\equations"- )- words.scale(1.5)- words.set_color(BLUE)- lb = Brace(words, LEFT)- rb = Brace(words, RIGHT)- return VGroup(lb, words, rb)diff --git a/active_projects/ode/part4/fourier_series_scenes.py b/active_projects/ode/part4/fourier_series_scenes.pydeleted file mode 100644index d2ea6feeb..000000000--- a/active_projects/ode/part4/fourier_series_scenes.py+++ /dev/null@@ -1,242 +0,0 @@-from manimlib.imports import *--from active_projects.ode.part2.fourier_series import FourierOfTrebleClef---class ComplexFourierSeriesExample(FourierOfTrebleClef):- CONFIG = {- "file_name": "EighthNote",- "run_time": 10,- "n_vectors": 200,- "n_cycles": 2,- "max_circle_stroke_width": 0.75,- "drawing_height": 5,- "center_point": DOWN,- "top_row_y": 3,- "top_row_label_y": 2,- "top_row_x_spacing": 1.75,- "top_row_copy_scale_factor": 0.9,- "start_drawn": False,- }-- def construct(self):- self.add_vectors_circles_path()- self.add_top_row(self.vectors, self.circles)- self.write_title()- self.highlight_vectors_one_by_one()- self.change_shape()-- def write_title(self):- title = TextMobject("Complex\\\\Fourier series")- title.scale(1.5)- title.to_edge(LEFT)- title.match_y(self.path)-- self.wait(5)- self.play(FadeInFromDown(title))- self.wait(2)- self.title = title-- def highlight_vectors_one_by_one(self):- # Don't know why these vectors can't get copied.- # That seems like a problem that will come up again.- labels = self.top_row[-1]- next_anims = []- for vector, circle, label in zip(self.vectors, self.circles, labels):- # v_color = vector.get_color()- c_color = circle.get_color()- c_stroke_width = circle.get_stroke_width()-- rect = SurroundingRectangle(label, color=PINK)- self.play(- # vector.set_color, PINK,- circle.set_stroke, RED, 3,- FadeIn(rect),- *next_anims- )- self.wait()- next_anims = [- # vector.set_color, v_color,- circle.set_stroke, c_color, c_stroke_width,- FadeOut(rect),- ]- self.play(*next_anims)-- def change_shape(self):- # path_mob = TexMobject("\\pi")- path_mob = SVGMobject("Nail_And_Gear")- new_path = path_mob.family_members_with_points()[0]- new_path.set_height(4)- new_path.move_to(self.path, DOWN)- new_path.shift(0.5 * UP)- new_coefs = self.get_coefficients_of_path(new_path)- new_vectors = self.get_rotating_vectors(- coefficients=new_coefs- )- new_drawn_path = self.get_drawn_path(new_vectors)-- self.vector_clock.set_value(0)- self.vector_clock.suspend_updating(0)-- vectors = self.vectors- anims = []-- for vect, new_vect in zip(vectors, new_vectors):- new_vect.update()- new_vect.clear_updaters()-- line = Line(stroke_width=0)- line.put_start_and_end_on(*vect.get_start_and_end())- anims.append(ApplyMethod(- line.put_start_and_end_on,- *new_vect.get_start_and_end()- ))- vect.freq = new_vect.freq- vect.phase = new_vect.phase- vect.coefficient = new_vect.coefficient-- vect.line = line- vect.add_updater(- lambda v: v.put_start_and_end_on(- *v.line.get_start_and_end()- )- )- anims += [- FadeOut(self.drawn_path)- ]-- self.play(*anims, run_time=3)- self.vector_clock.resume_updating()- for vect in self.vectors:- vect.remove_updater(vect.updaters[-1])-- self.add(new_drawn_path)- for n in range(self.n_cycles):- self.run_one_cycle()-- #- def get_path(self):- path = super().get_path()- path.set_height(self.drawing_height)- path.to_edge(DOWN)- return path-- def add_top_row(self, vectors, circles, max_freq=3):- self.top_row = self.get_top_row(- vectors, circles, max_freq- )- self.add(self.top_row)-- def get_top_row(self, vectors, circles, max_freq=3):- vector_copies = VGroup()- circle_copies = VGroup()- for vector, circle in zip(vectors, circles):- if vector.freq > max_freq:- break- vcopy = vector.copy()- vcopy.clear_updaters()- ccopy = circle.copy()- ccopy.clear_updaters()- ccopy.original = circle- vcopy.original = vector-- vcopy.center_point = np.array([- vector.freq * self.top_row_x_spacing,- self.top_row_y,- 0- ])- ccopy.center_point = vcopy.center_point- vcopy.add_updater(self.update_top_row_vector_copy)- ccopy.add_updater(self.update_top_row_circle_copy)- vector_copies.add(vcopy)- circle_copies.add(ccopy)-- dots = VGroup(*[- TexMobject("\\dots").next_to(- circle_copies, direction,- MED_LARGE_BUFF,- )- for direction in [LEFT, RIGHT]- ])- labels = self.get_top_row_labels(vector_copies)- return VGroup(- vector_copies,- circle_copies,- dots,- labels,- )-- def update_top_row_vector_copy(self, vcopy):- vcopy.become(vcopy.original)- vcopy.scale(self.top_row_copy_scale_factor)- vcopy.shift(vcopy.center_point - vcopy.get_start())- return vcopy-- def update_top_row_circle_copy(self, ccopy):- ccopy.become(ccopy.original)- ccopy.scale(self.top_row_copy_scale_factor)- ccopy.move_to(ccopy.center_point)- return ccopy-- def get_top_row_labels(self, vector_copies):- labels = VGroup()- for vector_copy in vector_copies:- freq = vector_copy.freq- label = Integer(freq)- label.move_to(np.array([- freq * self.top_row_x_spacing,- self.top_row_label_y,- 0- ]))- labels.add(label)- return labels---class ComplexFourierSeriesExampleEnd(ExternallyAnimatedScene):- pass---class FourierSeriesExampleWithRectForZoom(ComplexFourierSeriesExample):- CONFIG = {- "n_vectors": 100,- "slow_factor": 0.01,- "rect_scale_factor": 0.15,- "parametric_function_step_size": 0.0001,- "start_drawn": True,- }-- def construct(self):- self.add_vectors_circles_path()- self.circles.set_stroke(opacity=0.5)- rect = self.get_rect()- rect.set_height(self.rect_scale_factor * FRAME_HEIGHT)- rect.add_updater(lambda m: m.move_to(- center_of_mass([- v.get_end()- for v in self.vectors- ])- ))- self.add(rect)- self.run_one_cycle()-- def get_rect(self):- return ScreenRectangle(- color=WHITE,- stroke_width=2,- )---class ZoomedInFourierSeriesExample(FourierSeriesExampleWithRectForZoom, MovingCameraScene):- CONFIG = {- "vector_config": {- "max_tip_length_to_length_ratio": 0.15,- "tip_length": 0.05,- }- }-- def setup(self):- ComplexFourierSeriesExample.setup(self)- MovingCameraScene.setup(self)-- def get_rect(self):- return self.camera_framediff --git a/active_projects/ode/part4/pi_creature_scenes.py b/active_projects/ode/part4/pi_creature_scenes.pydeleted file mode 100644index 69ef9d321..000000000--- a/active_projects/ode/part4/pi_creature_scenes.py+++ /dev/null@@ -1,22 +0,0 @@-from manimlib.imports import *---class WhyWouldYouCare(TeacherStudentsScene):- def construct(self):- self.student_says(- "Who cares!",- target_mode="sassy",- student_index=2,- added_anims=[self.teacher.change, "guilty"],- )- self.wait()- self.play(- RemovePiCreatureBubble(self.students[2]),- self.teacher.change, "raise_right_hand",- self.get_student_changes(- "pondering", "erm", "thinking",- look_at_arg=self.screen,- )- )- self.look_at(self.screen)- self.wait(5)diff --git a/active_projects/ode/part4/staging.py b/active_projects/ode/part4/staging.pydeleted file mode 100644index 0e16ca07c..000000000--- a/active_projects/ode/part4/staging.py+++ /dev/null@@ -1,345 +0,0 @@-from manimlib.imports import *-from active_projects.ode.part3.temperature_graphs import TemperatureGraphScene-from active_projects.ode.part2.wordy_scenes import WriteHeatEquationTemplate---class RelationToOtherVideos(Scene):- CONFIG = {- "camera_config": {- "background_color": DARK_GREY,- },- }-- def construct(self):- # Show three videos- videos = self.get_video_thumbnails()- brace = Brace(videos, UP)- text = TextMobject("Heat equation")- text.scale(2)- text.next_to(brace, UP)-- self.play(- LaggedStartMap(- FadeInFrom, videos,- lambda m: (m, LEFT),- lag_ratio=0.4,- run_time=2,- ),- GrowFromCenter(brace),- FadeInFromDown(text),- )- self.wait()- group = Group(text, brace, videos)-- # Show Fourier thinking- fourier = ImageMobject("Joseph Fourier")- fourier.set_height(4)- fourier.to_edge(RIGHT)- group.generate_target()- group.target.to_edge(DOWN)- fourier.align_to(group.target[0], DOWN)- bubble = ThoughtBubble(- direction=RIGHT,- width=3,- height=2,- fill_opacity=0.5,- stroke_color=WHITE,- )- bubble[-1].shift(0.25 * DOWN + 0.5 * LEFT)- bubble[:-1].rotate(20 * DEGREES)- for mob in bubble[:-1]:- mob.rotate(-20 * DEGREES)- bubble.move_tip_to(- fourier.get_corner(UL) + DOWN- )- bubble.to_edge(UP, buff=SMALL_BUFF)-- self.play(- MoveToTarget(group),- FadeInFrom(fourier, LEFT)- )- self.play(Write(bubble, run_time=1))- self.wait()-- # Discount first two- first_two = videos[:2]- first_two.generate_target()- first_two.target.scale(0.5)- first_two.target.to_corner(DL)- new_brace = Brace(first_two.target, UP)-- self.play(- # fourier.scale, 0.8,- fourier.match_x, new_brace,- fourier.to_edge, UP,- MoveToTarget(first_two),- Transform(brace, new_brace),- text.scale, 0.7,- text.next_to, new_brace, UP,- FadeOutAndShift(bubble, LEFT),- )- self.play(- videos[2].scale, 1.7,- videos[2].to_corner, UR,- )- self.wait()-- #- def get_video_thumbnails(self):- thumbnails = Group(- ImageMobject("diffyq_part2_thumbnail"),- ImageMobject("diffyq_part3_thumbnail"),- ImageMobject("diffyq_part4_thumbnail"),- )- for thumbnail in thumbnails:- thumbnail.set_height(4)- thumbnail.add(SurroundingRectangle(- thumbnail,- color=WHITE,- stroke_width=2,- buff=0- ))- thumbnails.arrange(RIGHT, buff=LARGE_BUFF)- thumbnails.set_width(FRAME_WIDTH - 1)- return thumbnails---class ShowLinearity(WriteHeatEquationTemplate, TemperatureGraphScene):- CONFIG = {- "temp_text": "Temp",- "alpha": 0.1,- "axes_config": {- "z_max": 2,- "z_min": -2,- "z_axis_config": {- "tick_frequency": 0.5,- "unit_size": 1.5,- },- },- "default_surface_config": {- "resolution": (16, 16)- # "resolution": (4, 4)- },- "freqs": [2, 5],- }-- def setup(self):- TemperatureGraphScene.setup(self)- WriteHeatEquationTemplate.setup(self)-- def construct(self):- self.init_camera()- self.add_three_graphs()- self.show_words()- self.add_function_labels()- self.change_scalars()-- def init_camera(self):- self.camera.set_distance(1000)-- def add_three_graphs(self):- axes_group = self.get_axes_group()- axes0, axes1, axes2 = axes_group- freqs = self.freqs- scalar_trackers = Group(- ValueTracker(1),- ValueTracker(1),- )- graphs = VGroup(- self.get_graph(axes0, [freqs[0]], [scalar_trackers[0]]),- self.get_graph(axes1, [freqs[1]], [scalar_trackers[1]]),- self.get_graph(axes2, freqs, scalar_trackers),- )-- plus = TexMobject("+").scale(2)- equals = TexMobject("=").scale(2)- plus.move_to(midpoint(- axes0.get_right(),- axes1.get_left(),- ))- equals.move_to(midpoint(- axes1.get_right(),- axes2.get_left(),- ))-- self.add(axes_group)- self.add(graphs)- self.add(plus)- self.add(equals)-- self.axes_group = axes_group- self.graphs = graphs- self.scalar_trackers = scalar_trackers- self.plus = plus- self.equals = equals-- def show_words(self):- equation = self.get_d1_equation()- name = TextMobject("Heat equation")- name.next_to(equation, DOWN)- name.set_color_by_gradient(RED, YELLOW)- group = VGroup(equation, name)- group.to_edge(UP)-- shift_val = 0.5 * RIGHT-- arrow = Vector(1.5 * RIGHT)- arrow.move_to(group)- arrow.shift(shift_val)- linear_word = TextMobject("``Linear''")- linear_word.scale(2)- linear_word.next_to(arrow, RIGHT)-- self.add(group)- self.wait()- self.play(- ShowCreation(arrow),- group.next_to, arrow, LEFT- )- self.play(FadeInFrom(linear_word, LEFT))- self.wait()-- def add_function_labels(self):- axes_group = self.axes_group- graphs = self.graphs-- solution_labels = VGroup()- for axes in axes_group:- label = TextMobject("Solution", "$\\checkmark$")- label.set_color_by_tex("checkmark", GREEN)- label.next_to(axes, DOWN)- solution_labels.add(label)-- kw = {- "tex_to_color_map": {- "T_1": BLUE,- "T_2": GREEN,- }- }- T1 = TexMobject("a", "T_1", **kw)- T2 = TexMobject("b", "T_2", **kw)- T_sum = TexMobject("T_1", "+", "T_2", **kw)- T_sum_with_scalars = TexMobject(- "a", "T_1", "+", "b", "T_2", **kw- )-- T1.next_to(graphs[0], UP)- T2.next_to(graphs[1], UP)- T_sum.next_to(graphs[2], UP)- T_sum.shift(SMALL_BUFF * DOWN)- T_sum_with_scalars.move_to(T_sum)-- a_brace = Brace(T1[0], UP, buff=SMALL_BUFF)- b_brace = Brace(T2[0], UP, buff=SMALL_BUFF)- s1_decimal = DecimalNumber()- s1_decimal.match_color(T1[1])- s1_decimal.next_to(a_brace, UP, SMALL_BUFF)- s1_decimal.add_updater(lambda m: m.set_value(- self.scalar_trackers[0].get_value()- ))- s2_decimal = DecimalNumber()- s2_decimal.match_color(T2[1])- s2_decimal.next_to(b_brace, UP, SMALL_BUFF)- s2_decimal.add_updater(lambda m: m.set_value(- self.scalar_trackers[1].get_value()- ))-- self.play(- FadeInFrom(T1[1], DOWN),- FadeInFrom(solution_labels[0], UP),- )- self.play(- FadeInFrom(T2[1], DOWN),- FadeInFrom(solution_labels[1], UP),- )- self.wait()- self.play(- TransformFromCopy(T1[1], T_sum[0]),- TransformFromCopy(T2[1], T_sum[2]),- TransformFromCopy(self.plus, T_sum[1]),- *[- Transform(- graph.copy().set_fill(opacity=0),- graphs[2].copy().set_fill(opacity=0),- remover=True- )- for graph in graphs[:2]- ]- )- self.wait()- self.play(FadeInFrom(solution_labels[2], UP))- self.wait()-- # Show constants- self.play(- FadeIn(T1[0]),- FadeIn(T2[0]),- FadeIn(a_brace),- FadeIn(b_brace),- FadeIn(s1_decimal),- FadeIn(s2_decimal),- FadeOut(T_sum),- FadeIn(T_sum_with_scalars),- )-- def change_scalars(self):- s1, s2 = self.scalar_trackers-- kw = {- "run_time": 2,- }- for graph in self.graphs:- graph.resume_updating()- self.play(s2.set_value, -0.5, **kw)- self.play(s1.set_value, -0.2, **kw)- self.play(s2.set_value, 1.5, **kw)- self.play(s1.set_value, 1.2)- self.play(s2.set_value, 0.3)- self.wait()-- #- def get_axes_group(self):- axes_group = VGroup(*[- self.get_axes()- for x in range(3)- ])- axes_group.arrange(RIGHT, buff=2)- axes_group.set_width(FRAME_WIDTH - 1)- axes_group.to_edge(DOWN, buff=1)- return axes_group-- def get_axes(self):- axes = self.get_three_d_axes()- # axes.input_plane.set_fill(opacity=0)- # axes.input_plane.set_stroke(width=0.5)- # axes.add(axes.input_plane)- self.orient_three_d_mobject(axes)- axes.rotate(-5 * DEGREES, UP)- axes.set_width(4)- axes.x_axis.label.next_to(- axes.x_axis.get_end(), DOWN,- buff=2 * SMALL_BUFF- )- return axes-- def get_graph(self, axes, freqs, scalar_trackers):- L = axes.x_max- a = self.alpha-- def func(x, t):- scalars = [st.get_value() for st in scalar_trackers]- return np.sum([- s * np.cos(k * x) * np.exp(-a * (k**2) * t)- for freq, s in zip(freqs, scalars)- for k in [freq * PI / L]- ])-- def get_surface_graph_group():- return VGroup(- self.get_surface(axes, func),- self.get_time_slice_graph(axes, func, t=0),- )-- result = always_redraw(get_surface_graph_group)- result.suspend_updating()- return resultdiff --git a/active_projects/ode/solve_pendulum_ode_sample_code.py b/active_projects/ode/solve_pendulum_ode_sample_code.pydeleted file mode 100644index e7076c3ca..000000000--- a/active_projects/ode/solve_pendulum_ode_sample_code.py+++ /dev/null@@ -1,63 +0,0 @@-import numpy as np--# Physical constants-g = 9.8-L = 2-mu = 0.1--THETA_0 = np.pi / 3 # 60 degrees-THETA_DOT_0 = 0 # No initial angular velocity--# Definition of ODE-def get_theta_double_dot(theta, theta_dot):- return -mu * theta_dot - (g / L) * np.sin(theta)---# Solution to the differential equation-def theta(t):- # Initialize changing values- theta = THETA_0- theta_dot = THETA_DOT_0- delta_t = 0.01 # Some time step- for time in np.arange(0, t, delta_t):- # Take many little time steps of size delta_t- # until the total time is the function's input- theta_double_dot = get_theta_double_dot(- theta, theta_dot- )- theta += theta_dot * delta_t- theta_dot += theta_double_dot * delta_t- return theta---------------------------------