Update repo

FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/Conservative fields/Conservative_file1_paths-3d.py

@@ -0,0 +1,41 @@
+from manimlib.imports import *
+import numpy as np
+
+class routes(ThreeDScene):
+	def construct(self):
+
+		axes = ThreeDAxes()
+		self.begin_ambient_camera_rotation(rate=0.08)
+		self.set_camera_orientation(phi=45 * DEGREES,theta=-65*DEGREES, distance = 45)
+		function = ParametricFunction(
+            lambda t: np.array([
+            1.5*np.cos(t),
+            1.5*np.sin(t),
+            t/4
+            ]), t_min = 0, t_max =3*PI).set_color("#0EB1D2")
+
+
+		line = Line(np.array([1.5, 0, 0]), np.array([-1.5, 0, 2.35619])).set_color("#F8F32B")
+
+		dot1 = Sphere(radius = 0.1).move_to(np.array([1.5,0,0])).set_color("#74226C")
+		dot2 = Sphere(radius = 0.1).move_to(np.array([1.5,0,0])).set_color("#74226C")
+
+		label1 = TexMobject(r"A").move_to(np.array([1.5,0,0])).set_color("#FCF7F8")
+		label2 = TexMobject(r"B").move_to(np.array([-1.5,0,2.42])).set_color("#FCF7F8")
+
+		title = TexMobject(r"\textit{Work done}",r"\textit{ against gravity is the}", r"\textit{ same for both paths}").set_color("#F1E3F3").move_to(np.array([0,-3,0]))
+		title[1].set_color("#F8F32B")
+
+		self.add(axes)
+		self.wait()
+		self.play(ShowCreation(function), ShowCreation(line), run_time = 2)
+		self.wait()
+		self.play(MoveAlongPath(dot1, function), run_time = 2)
+		self.wait()
+		self.play(MoveAlongPath(dot2, line), run_time = 1.2)
+		self.wait()
+		self.add_fixed_in_frame_mobjects(title)
+		self.play(Write(title))
+		self.wait()
+
+

FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/Conservative fields/Conservative_file2_line-int.py

@@ -0,0 +1,132 @@
+from manimlib.imports import *
+
+def field_func(coordinate):
+	x,y = coordinate[:2]
+	return np.array([
+					-x, 
+					-y,
+					0
+				])
+
+
+class LineIntegral(MovingCameraScene, Scene):
+	def setup(self):
+		MovingCameraScene.setup(self)
+		Scene.setup(self)
+
+	def get_pending(self,path,proportion,dx=0.01):
+		if proportion < 1:
+			coord_i = path.point_from_proportion(proportion)
+			coord_f = path.point_from_proportion(proportion+dx)
+		else:
+			coord_i = path.point_from_proportion(proportion-dx)
+			coord_f = path.point_from_proportion(proportion)
+		line = Line(coord_i,coord_f)
+		angle = line.get_angle()
+		return angle
+
+	def construct(self):
+
+
+		# all the text
+		vec_f = TexMobject(r"\vec F",r" \textit{ is a vector field defined on the plane}").set_color("#EDF2EF")
+		c = TexMobject(r"C",r" \textit{ is a curve on the plane, oriented counter-clockwise.}").set_color("#EDF2EF")
+		dr = TexMobject(r"\vec dr", r"\textit{ gives the direction as we move along C}").set_color("#EDF2EF")
+
+		intg = TexMobject(r"\oint \vec F \cdot \vec dr", r"\textit{ gives the rotation along the curve}").shift(2.5*DOWN).scale(0.7).set_color("#EDF2EF")
+		text = VGroup(vec_f, c, dr).scale(0.6).set_stroke(width = 1.5)
+		text.arrange(DOWN, buff = 0.2)
+		text.shift(3.2*DOWN)
+
+		vec_f[0].set_color("#D1D646")
+		dr[0].set_color("#D1D646")
+		intg[0].set_color("#D1D646")
+
+
+
+
+		self.camera_frame.save_state()
+		vec_f_sym = TexMobject(r"\vec F")
+		c_sym = TexMobject(r"C").move_to(4.8*RIGHT+1.3*UP)
+		dr_sym = TexMobject(r"\vec dr").next_to(vec_f_sym, DOWN, buff = SMALL_BUFF)
+		dp_sym = TexMobject(r"\vec F \cdot \vec dr")
+		intg_sym = TexMobject(r"\oint \vec F \cdot \vec dr")
+
+		symbols = VGroup(vec_f_sym, dr_sym, dp_sym, intg_sym).shift(3*UP).set_color("#D1D646")
+
+
+
+
+		vector_field = VectorField(field_func, x_min = -15, x_max = 15, y_min = -15, y_max = 15).fade(0.5)
+		boundary = Ellipse(width = 9, height = 3).set_color("#32908F")
+		b2 = Ellipse(width = 9, height = 3).set_color(WHITE)
+
+		start_angle = self.get_pending(boundary, 0)
+
+		pointer = Triangle(fill_opacity = 1).set_height(0.25).set_color(WHITE)
+		pointer.set_fill(WHITE)
+		pointer.move_to(boundary.get_start())
+		pointer.rotate(- PI / 2)
+		pointer.save_state()
+		pointer.rotate(start_angle, about_point=pointer.get_center())
+		dp_sym_1 = TexMobject(r"\vec F \cdot \vec dr").next_to(pointer, RIGHT, buff = SMALL_BUFF).scale(0.5).set_color("#D1D646").add_background_rectangle()
+		intg_sym_1 = TexMobject(r"\oint \vec F \cdot \vec dr").next_to(pointer, RIGHT, buff = SMALL_BUFF).scale(0.5).set_color("#75485E").add_background_rectangle()
+		dp = TexMobject(r"\vec F \cdot \vec dr \textit{ measures whether } \vec F \textit{ and } \vec dr", r" \textit{ are oriented the same way }").next_to(dp_sym_1, DOWN, buff = SMALL_BUFF).scale(0.3).set_color("#EDF2EF")
+		dp[1].next_to(dp[0], DOWN, buff = SMALL_BUFF)
+
+
+		# groups according to animation
+		#one = VGroup( vec_f, vec_f_sym)
+		#two = VGroup(boundary, c_sym)
+		#three = VGroup(dr_sym, pointer)
+		#four = VGroup(dp, dp_sym) #this is when to zoom in
+		#five = VGroup(intg, intg_sym)
+
+		delete = VGroup(vec_f, vec_f_sym, c, dr, dr_sym)
+
+
+		self.play(ShowCreation(vec_f), ShowCreation(vec_f_sym))
+		self.wait()
+		self.play(ShowCreation(vector_field), Indicate(vec_f_sym))
+		self.wait(2)
+		self.play(ShowCreation(c))
+		self.wait()
+		self.play(ShowCreation(boundary), ShowCreation(c_sym), Indicate(c))
+		self.wait(2)
+		self.play(ShowCreation(dr))
+		self.wait(2)
+		self.play(ShowCreation(dr_sym), Indicate(dr), ShowCreation(pointer))
+
+		self.play(FadeOut(delete))
+		self.play(
+			self.camera_frame.scale,.25,
+			self.camera_frame.move_to,pointer
+			)
+		self.play(ShowCreation(dp_sym_1), ShowCreation(dp[0]), ShowCreation(dp[1]))
+		self.add(dp_sym)
+		self.wait(3)
+		self.play(Restore(self.camera_frame))
+		self.remove(dp[0], dp[1], dp_sym_1)
+		self.wait()
+		self.add(boundary, pointer, self.camera_frame)
+		def update_rotate_move(mob,alpha):
+			pointer.restore()
+
+			angle = self.get_pending(boundary,alpha)
+
+			pointer.move_to(boundary.point_from_proportion(alpha))
+			pointer.rotate(angle, about_point=pointer.get_center())
+
+
+
+		self.play(
+			#self.camera_frame.scale,.25,
+			UpdateFromAlphaFunc(pointer,update_rotate_move),
+			run_time=3,
+			)
+		self.play(Write(b2))
+		self.play(ReplacementTransform(dp_sym, intg_sym), ShowCreation(intg))
+		self.play(ReplacementTransform(b2, intg_sym))
+		self.play(Indicate(intg_sym))
+		self.wait(2)
+

FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/Conservative fields/Conservative_file3_path-independent.py

@@ -0,0 +1,131 @@
+from manimlib.imports import *
+import numpy as np
+
+def func(coordinate):
+	x,y = coordinate[:2]
+	return np.array([
+		-2*x,
+		-2*y,
+		0
+	])
+
+
+
+
+class many_paths(GraphScene):
+	CONFIG = {
+			"x_min" : 0,
+			"x_max" : 8.5,
+			"x_axis_height": 8.5,
+			"y_min" : 0,
+			"y_max" : 8.5,
+			"y_axis_height": 8.5,
+			"graph_origin" : ORIGIN, 
+			"function_color" : RED,
+
+		} 
+	def construct(self):
+		self.setup_axes(animate=False)
+		self.remove(self.x_axis, self.y_axis)
+		background = VectorField(func,
+			x_min = 0, x_max = 8.5, y_min = 0, y_max = 8.5, colors = ["#DBD8AE"]
+			)
+
+		pointer = Dot(np.array([0, 1.5, 0])).scale(0.7).set_color_by_gradient(["#84732B", YELLOW_E])
+		start = np.array([0, 1.5, 0])
+		end = np.array([7.53, 5.043, 0])
+		path_one= self.get_graph(self.one, x_min = 0, x_max = 7.53)
+		path_two= self.get_graph(self.two, x_min = 0, x_max = 7.53)
+		path_three = self.get_graph(self.three, x_min = 0, x_max = 7.53)
+
+		group = VGroup(path_one, path_two, background, path_three).move_to(np.array([-3,0, 0])).scale(0.75)
+
+
+
+		path_one.set_color("#F6523C")
+		path_two.set_color("#80475E")
+		path_three.set_color("#0F7173")
+
+		# all the text
+		#function = TexMobject(r"f(x,y) = -(x^2 + y^2)").scale(0.6).set_color("#DBD8AE").shift(3.6*UP + 3*LEFT)
+		field = TexMobject(r"\vec F = -2x\hat i - 2y\hat j").set_color("#DBD8AE").shift(3.6*DOWN + 3*LEFT)
+		c1 = TexMobject(r"C_{1}: y = 6sin(\frac{x}{3} + 1.5)").scale(0.7).set_color("#0F7173").shift(3*UP + 4*RIGHT)
+		#c3 = TexMobject(r"C_{3}: y = 6sin(\frac{x}{3} + 1.5)").scale(0.7).set_color("#0F7173").next_to(li_path2, DOWN, buff = LARGE_BUFF)
+		li_path1 = TexMobject(r"\int_{C_{1}} \vec F \cdot \vec dr = ").set_color("#0F7173").next_to(c1, DOWN, buff = 0.2)
+		c2 = TexMobject(r"C_{2}: y = 0.47x + 1.5").scale(0.7).set_color("#80475E").next_to(li_path1, DOWN, buff = 0.4)
+		li_path2 = TexMobject(r"\int_{C_{2}} \vec F \cdot \vec dr = ").set_color("#80475E").next_to(c2, DOWN, buff = 0.2)
+		c3 = TexMobject(r"C_{3}: y = \frac{x^{16}}{2}+ 1.5").scale(0.7).set_color("#F6523C").next_to(li_path2, DOWN, buff = 0.4)
+		li_path3 = TexMobject(r"\int_{C_{3}} \vec F \cdot \vec dr = ").set_color("#F6523C").next_to(c3, DOWN, buff = 0.2)
+
+		cs = VGroup(c1, c2, c3)
+
+
+		c_1 = lambda x: c1_value.get_value()
+		c_2 = lambda x: c2_value.get_value()
+		c_3 = lambda x: c3_value.get_value()
+
+		c1_value = ValueTracker(0)
+		c2_value = ValueTracker(0)
+		c3_value = ValueTracker(0)
+
+		c1_tex = DecimalNumber(c1_value.get_value()).add_updater(lambda v: v.set_value(c1_value.get_value())).next_to(li_path1, RIGHT, buff = SMALL_BUFF).set_color("#0F7173")
+		c2_tex = DecimalNumber(c2_value.get_value()).add_updater(lambda v: v.set_value(c2_value.get_value())).next_to(li_path2, RIGHT, buff = SMALL_BUFF).set_color("#80475E")
+		c3_tex = DecimalNumber(c3_value.get_value()).add_updater(lambda v: v.set_value(c3_value.get_value())).next_to(li_path3, RIGHT, buff = SMALL_BUFF).set_color("#F6523C")
+
+
+		paths = VGroup(li_path1, li_path2, li_path3, c1_tex, c2_tex, c3_tex)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		self.play(ShowCreation(field), ShowCreation(background))
+		self.wait()
+		self.play(ShowCreation(path_one), ShowCreation(path_two), ShowCreation(path_three), ShowCreation(cs))
+		self.wait(2)
+		self.add(c1_tex)
+		self.play(ShowCreation(li_path1))
+		self.play(MoveAlongPath(pointer, path_three), c1_value.set_value,-78.9,
+			rate_func=linear,
+			run_time=3
+			)
+		self.wait(2)
+		self.play(ShowCreation(li_path2))
+		self.add(c2_tex)
+		self.play(MoveAlongPath(pointer, path_two), c2_value.set_value,-78.9,
+			rate_func=linear,
+			run_time=3
+			)
+		self.play(ShowCreation(li_path3))
+		self.add(c3_tex)
+		self.play(MoveAlongPath(pointer, path_one), c3_value.set_value,-78.9,
+			rate_func=linear,
+			run_time=3
+			)
+		self.wait()
+		self.play(Indicate(paths))
+		self.wait()
+		#self.play(MoveAlongPath(pointer, path_three))
+		#self.wait(2)
+
+	def one(self,x):
+		return x**2/16 + 1.5
+
+	def three(self,x):
+		return 6*np.sin(x/3) + 1.5
+
+	def two(self,x):
+		return 0.4705*x + 1.5
+