from manim import * from manim_voiceover import VoiceoverScene from manim_voiceover.services.elevenlabs import ElevenLabsService import numpy as np config.frame_width = 16 config.frame_height = 9 config.pixel_width = 1920 config.pixel_height = 1080 config.background_color = "#0C0C0E" GOLD_KEY = "#F4C152" GOLD_SOFT = "#E8B04A" TEAL = "#4FC4B8" CYAN = "#5CC8E8" SOFT_BLUE = "#7FA6E0" SAGE = "#86BF7A" MUTED_RED = "#D9655B" INK = "#ECEEF2" MUTED = "#9BA3AE" DIM = "#4A515B" SAFE_X = config.frame_width / 2 - 0.35 SAFE_Y = config.frame_height / 2 - 0.35 SAFE_Y_BOTTOM = config.frame_height / 2 - 0.7 class IntegralDeLinea(VoiceoverScene): def construct(self): self.set_speech_service(ElevenLabsService( voice_id="F3pPb09f6SpwgQJHax6h", model="eleven_multilingual_v2", transcription_model=None, )) axes = Axes( x_range=[-0.5, 1.7, 0.5], y_range=[-0.5, 1.7, 0.5], x_length=5.4, y_length=5.4, tips=False, axis_config={ "color": DIM, "stroke_width": 2.0, "include_ticks": True, "tick_size": 0.055, }, ) axes.move_to(np.array([-3.25, -0.30, 0.0])) x_lab = MathTex("x", font_size=26, color=MUTED) x_lab.next_to(axes.x_axis.get_end(), RIGHT, buff=0.12) y_lab = MathTex("y", font_size=26, color=MUTED) y_lab.next_to(axes.y_axis.get_end(), UP, buff=0.10) title = Text("Integral de línea", font="Inter", font_size=38, color=INK) title.to_edge(UP, buff=0.42) # ---------- beat 1: the field ---------- with self.voiceover( text="El trabajo de un campo vectorial a lo largo de una curva " "se mide con una integral de línea." ) as tracker: self.play( FadeIn(title, shift=0.15 * DOWN), Create(axes), FadeIn(x_lab), FadeIn(y_lab), run_time=tracker.duration, ) field = self.make_field(axes) field_eq = MathTex( r"\vec F(x,y)=(-y,\,x)", font_size=36, color=INK, ) field_eq.set_color_by_tex(r"\vec F", TEAL) header = Text("El campo", font="Inter", font_size=26, color=MUTED) intro = VGroup(header, field_eq).arrange(DOWN, buff=0.22, aligned_edge=LEFT) intro.move_to(np.array([3.55, 1.85, 0.0])) with self.voiceover( text="Tomemos el campo F de x, y, igual a menos y, x. " "Cada flecha apunta en la dirección del campo en ese punto." ) as tracker: self.play( FadeIn(header, shift=0.1 * UP), run_time=min(0.8, tracker.duration * 0.25), ) self.play( LaggedStart( *[GrowArrow(a) for a in field], lag_ratio=0.06, ), Write(field_eq), run_time=max(0.4, tracker.duration - min(0.8, tracker.duration * 0.25)), ) # ---------- beat 2: the curve ---------- curve = axes.plot_parametric_curve( lambda t: np.array([t, t ** 2, 0.0]), t_range=[0.0, 1.0, 0.008], color=GOLD_KEY, stroke_width=4.5, ) start_dot = Dot(axes.c2p(0, 0), radius=0.075, color=GOLD_KEY) end_dot = Dot(axes.c2p(1, 1), radius=0.075, color=GOLD_KEY) start_lab = MathTex(r"\vec r(0)=(0,0)", font_size=24, color=GOLD_SOFT) end_lab = MathTex(r"\vec r(1)=(1,1)", font_size=24, color=GOLD_SOFT) start_lab.next_to(start_dot, DOWN, buff=0.30) start_lab.shift(LEFT * 0.85) end_lab.next_to(end_dot, LEFT, buff=0.30) end_lab.shift(UP * 1.05) curve_eq = MathTex( r"\vec r(t)=(t,\,t^{2})", font_size=34, color=INK, ) curve_eq.set_color_by_tex(r"\vec r", GOLD_KEY) curve_range = MathTex( r"0\leq t\leq 1", font_size=32, color=MUTED, ) curve_block = VGroup(curve_eq, curve_range).arrange( DOWN, buff=0.34, aligned_edge=LEFT, ) curve_block.next_to(intro, DOWN, buff=0.55) curve_block.align_to(intro, LEFT) with self.voiceover( text="La curva C va de t igual a cero hasta t igual a uno, " "con r de t igual a t, t al cuadrado. " "Parte del origen y termina en el punto uno, uno." ) as tracker: self.play( Create(curve), Write(curve_eq), run_time=tracker.duration * 0.62, ) self.play( FadeIn(start_dot, scale=0.4), FadeIn(end_dot, scale=0.4), FadeIn(start_lab), FadeIn(end_lab), FadeIn(curve_range), run_time=tracker.duration * 0.38, ) # ---------- beat 3: segments and the dot product ---------- with self.voiceover( text="Cortemos la curva en cuatro tramos. " "En cada uno, el desplazamiento es el vector tangente, " "r prima de t, por delta t." ) as tracker: self.play( FadeOut(start_lab), FadeOut(end_lab), FadeOut(curve_block), FadeOut(intro), run_time=min(0.7, tracker.duration * 0.22), ) n_cut = 4 cuts = VGroup() for i in range(n_cut + 1): t = i / n_cut cuts.add(Dot(axes.c2p(t, t * t), radius=0.045, color=GOLD_SOFT)) self.play( LaggedStart(*[FadeIn(d, scale=0.5) for d in cuts], lag_ratio=0.2), run_time=max(0.4, tracker.duration - min(0.7, tracker.duration * 0.22)), ) tangents = self.tangent_arrows(axes, 3, 0.09) spot_t = 5.0 / 6.0 spot_F = self.vector_arrow(axes, spot_t, "field", 0.20) spot_T = self.vector_arrow(axes, spot_t, "tangent", 0.15) lab_T = MathTex(r"\vec r'(t)", font_size=26, color=CYAN) lab_F = MathTex(r"\vec F", font_size=26, color=TEAL) lab_T.next_to(spot_T.get_end(), RIGHT, buff=0.22) lab_F.next_to(spot_F.get_end(), LEFT, buff=0.18) dr_eq = MathTex( r"d\vec r=\vec r'(t)\,dt", font_size=32, color=INK, ) dr_eq.set_color_by_tex(r"\vec r'", CYAN) dot_eq = MathTex( r"\vec F\cdot d\vec r", font_size=34, color=GOLD_KEY, ) focus = VGroup(dr_eq, dot_eq).arrange(DOWN, buff=0.28, aligned_edge=LEFT) focus.move_to(np.array([3.55, 1.35, 0.0])) with self.voiceover( text="En un punto de la curva conviven dos vectores: " "el campo F, en verde, y la tangente, en azul. " "Su producto punto dice cuánto empuja el campo en la dirección del movimiento." ) as tracker: self.play( LaggedStart(*[GrowArrow(a) for a in tangents], lag_ratio=0.25), run_time=tracker.duration * 0.34, ) self.play( GrowArrow(spot_F), GrowArrow(spot_T), FadeIn(lab_F), FadeIn(lab_T), run_time=tracker.duration * 0.33, ) self.play( Write(dr_eq), Write(dot_eq), run_time=tracker.duration * 0.33, ) # ---------- beat 4: Riemann sums ---------- bars, values = self.riemann_bars(4) suma_header = Text("Suma de Riemann", font="Inter", font_size=26, color=MUTED) suma_eq = MathTex( r"\sum\,\vec F\cdot\Delta\vec r", font_size=32, color=INK, ) value_read = MathTex(r"\approx 0.22", font_size=34, color=GOLD_KEY) suma_block = VGroup(suma_header, suma_eq).arrange(DOWN, buff=0.32) suma_block.move_to(np.array([3.55, 0.55, 0.0])) value_read.next_to(bars, UP, buff=0.18) with self.voiceover( text="Sumando el producto punto en cada tramo, " "con cuatro pedazos obtenemos cerca de cero punto veintidós." ) as tracker: self.play( FadeOut(focus), FadeOut(lab_F), FadeOut(lab_T), FadeOut(spot_F), FadeOut(spot_T), FadeOut(tangents), run_time=min(0.7, tracker.duration * 0.22), ) self.play( LaggedStart(*[FadeIn(b, shift=0.15 * UP) for b in bars[:-1]], lag_ratio=0.12), Create(bars[-1]), FadeIn(suma_header), Write(suma_eq), FadeIn(value_read), run_time=max(0.5, tracker.duration - min(0.7, tracker.duration * 0.22)), ) with self.voiceover( text="Con ocho tramos sube a cero punto veintisiete, " "y con dieciséis ya llega a cero punto treinta." ) as tracker: bars8, v8 = self.riemann_bars(8) read8 = MathTex(r"\approx 0.27", font_size=34, color=GOLD_KEY) read8.next_to(bars8, UP, buff=0.18) self.play( ReplacementTransform(bars, bars8), ReplacementTransform(value_read, read8), run_time=tracker.duration * 0.5, ) bars16, v16 = self.riemann_bars(16) read16 = MathTex(r"\approx 0.30", font_size=34, color=GOLD_KEY) read16.next_to(bars16, UP, buff=0.18) self.play( ReplacementTransform(bars8, bars16), ReplacementTransform(read8, read16), run_time=tracker.duration * 0.5, ) with self.voiceover( text="Al refinar más y más, la suma se estabiliza en un tercio. " "Ese límite es la integral de línea." ) as tracker: bars32, v32 = self.riemann_bars(32) read32 = MathTex(r"\to \dfrac{1}{3}", font_size=34, color=GOLD_KEY) read32.next_to(bars32, UP, buff=0.20) self.play( ReplacementTransform(bars16, bars32), ReplacementTransform(read16, read32), run_time=tracker.duration * 0.7, ) self.play( Indicate(read32, color=GOLD_KEY, scale_factor=1.08), run_time=tracker.duration * 0.3, ) # ---------- beat 5: the exact calculation ---------- lines = [ MathTex(r"W=\int_{C}\vec F\cdot d\vec r", font_size=30), MathTex(r"=\int_{0}^{1}\vec F(\vec r(t))\cdot\vec r'(t)\,dt", font_size=30), MathTex(r"=\int_{0}^{1}(-t^{2},\,t)\cdot(1,\,2t)\,dt", font_size=30), MathTex(r"=\int_{0}^{1}t^{2}\,dt=\dfrac{1}{3}", font_size=30), ] for ln in lines: ln.set_color(INK) lines[0].set_color_by_tex(r"W", GOLD_KEY) lines[3].set_color_by_tex(r"\dfrac{1}{3}", GOLD_KEY) calc = VGroup(*lines).arrange(DOWN, buff=0.20, aligned_edge=LEFT) calc.move_to(np.array([3.35, 0.15, 0.0])) with self.voiceover( text="Calculemos el valor exacto. " "El trabajo es la integral sobre C de F punto d r." ) as tracker: self.play( FadeOut(suma_block), FadeOut(read32), FadeOut(bars32), FadeOut(cuts), run_time=min(0.7, tracker.duration * 0.28), ) self.play( Write(lines[0]), run_time=max(0.4, tracker.duration - min(0.7, tracker.duration * 0.28)), ) with self.voiceover( text="Parametrizando, queda la integral de cero a uno " "de F de r de t, punto r prima de t, d t." ) as tracker: self.play(Write(lines[1]), run_time=tracker.duration) with self.voiceover( text="Sustituimos: menos t al cuadrado, t, punto uno, dos t, " "que da t al cuadrado." ) as tracker: self.play(Write(lines[2]), run_time=tracker.duration) with self.voiceover( text="Integrar t al cuadrado de cero a uno da exactamente un tercio." ) as tracker: self.play(Write(lines[3]), run_time=tracker.duration * 0.75) self.play( Circumscribe(lines[3], color=GOLD_KEY, buff=0.08), run_time=tracker.duration * 0.25, ) # ---------- beat 6: the general formula ---------- general = MathTex( r"\int_{C}\vec F\cdot d\vec r" r"=\int_{a}^{b}\vec F(\vec r(t))\cdot\vec r'(t)\,dt", font_size=32, color=INK, ) meaning = Text( "Trabajo del campo a lo largo de la curva", font="Inter", font_size=24, color=MUTED, ) closing = VGroup(general, meaning).arrange(DOWN, buff=0.30) closing.move_to(np.array([0.0, -3.15, 0.0])) if closing.get_bottom()[1] < -SAFE_Y_BOTTOM: closing.shift(UP * (-SAFE_Y_BOTTOM - closing.get_bottom()[1] + 0.05)) with self.voiceover( text="En general, la integral de línea es la integral de a hasta b " "de F de r de t, punto r prima de t, d t: " "el trabajo que realiza el campo al recorrer la curva." ) as tracker: self.play( FadeOut(calc), FadeOut(curve), FadeOut(start_dot), FadeOut(end_dot), FadeOut(field), FadeOut(axes), FadeOut(x_lab), FadeOut(y_lab), run_time=tracker.duration * 0.30, ) self.play( Write(general), FadeIn(meaning, shift=0.1 * UP), run_time=tracker.duration * 0.55, ) self.play( Indicate(general, color=GOLD_KEY, scale_factor=1.03), run_time=tracker.duration * 0.15, ) self.wait(0.6) # ----------------------------------------------------------- def make_field(self, axes): arrows = VGroup() step = 0.4 xs = np.round(np.arange(-0.4, 1.61, step), 5) for x in xs: for y in xs: fx, fy = -y, x if fx * fx + fy * fy < 1e-8: continue # The curve y = x^2 runs through this band; keep arrows off it # so the field and the trajectory stay visually distinct. if -0.05 <= x <= 1.65 and abs(y - x * x) < 0.62: continue if abs(x - 1.2) < 0.05 and (abs(y - 0.4) < 0.05 or abs(y - 0.8) < 0.05): continue tip_x, tip_y = x + 0.20 * fx, y + 0.20 * fy if not (-0.48 <= tip_x <= 1.66 and -0.48 <= tip_y <= 1.66): continue arr = Arrow( axes.c2p(x, y), axes.c2p(tip_x, tip_y), buff=0, stroke_width=2.4, max_tip_length_to_length_ratio=0.32, max_stroke_width_to_length_ratio=8, color=TEAL, ) arr.set_stroke(opacity=0.85) arr.set_fill(opacity=0.85) arrows.add(arr) return arrows def vector_arrow(self, axes, t, kind, scale): p = np.array([t, t * t]) v = np.array([-t * t, t]) if kind == "field" else np.array([1.0, 2 * t]) color = TEAL if kind == "field" else CYAN tip = p + scale * v return Arrow( axes.c2p(*p), axes.c2p(*tip), buff=0, stroke_width=4.0, max_tip_length_to_length_ratio=0.22, color=color, ) def tangent_arrows(self, axes, n, scale): group = VGroup() for i in range(n): t = (i + 0.5) / n group.add(self.vector_arrow(axes, t, "tangent", scale)) return group def riemann_bars(self, n): """Left Riemann bars for f(t)=t^2 on [0,1], scaled to the right panel.""" width = 2.6 height = 1.35 origin = np.array([2.25, -3.05, 0.0]) bars = VGroup() total = 0.0 for i in range(n): t = i / n val = t * t total += val / n bw = width / n bh = height * val rect = Rectangle( width=bw, height=max(bh, 0.004), stroke_width=1.0 if n <= 16 else 0.4, stroke_color=GOLD_SOFT, fill_color=GOLD_KEY, fill_opacity=0.55, ) rect.move_to(origin + np.array([ (i + 0.5) * bw, bh / 2.0, 0.0, ])) bars.add(rect) base = Line( origin, origin + np.array([width, 0, 0]), stroke_width=1.5, color=DIM, ) bars.add(base) return bars, total

Integral de Línea