summaryrefslogtreecommitdiff
path: root/FSF-2020/calculus-of-several-variables
diff options
context:
space:
mode:
authorPurusharth Saxena2020-06-12 20:42:49 +0530
committerGitHub2020-06-12 20:42:49 +0530
commit5b939d1235fc8bc57581d03dda494e5fbf61a962 (patch)
treeb7e8a276d0258d1e467b84c241ac722007e5388c /FSF-2020/calculus-of-several-variables
parent673fa68262ceba275819acc12b7ce158d3c4f33b (diff)
parent70f35b9f0b2f01ca60416fb24e8f4618cdd93735 (diff)
downloadFSF-mathematics-python-code-archive-5b939d1235fc8bc57581d03dda494e5fbf61a962.tar.gz
FSF-mathematics-python-code-archive-5b939d1235fc8bc57581d03dda494e5fbf61a962.tar.bz2
FSF-mathematics-python-code-archive-5b939d1235fc8bc57581d03dda494e5fbf61a962.zip
Merge pull request #32 from panditsomnath10016git/master
Code uploaded after double integral review.
Diffstat (limited to 'FSF-2020/calculus-of-several-variables')
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md12
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/README.md21
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.gif (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif)bin1277788 -> 1277788 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_under_func.py)0
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.gifbin0 -> 6614909 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.py)155
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.gifbin0 -> 1165354 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py)2
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.gif (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif)bin2529511 -> 2529511 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.py)0
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.gif (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif)bin547368 -> 547368 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.py)0
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.gifbin0 -> 3349455 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.py355
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.gifbin0 -> 3031924 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.py366
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gifbin3365528 -> 0 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.gifbin1170435 -> 0 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/README.md14
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.gif (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif)bin3752052 -> 3752052 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py)0
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.gifbin0 -> 3791121 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.py (renamed from FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py)16
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.gifbin0 -> 465521 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.py226
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.gifbin0 -> 1813461 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.py429
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.gifbin0 -> 1282583 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.py102
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gifbin2556585 -> 0 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/README.md9
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.gifbin0 -> 4012467 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.py308
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.gifbin0 -> 1403902 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.py174
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.gifbin0 -> 1385308 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.py149
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/README.md14
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.gifbin0 -> 1051018 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.py227
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.gifbin0 -> 5612895 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.py421
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.gifbin0 -> 1670998 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.py326
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.gifbin0 -> 1237895 bytes
-rw-r--r--FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.py245
46 files changed, 3543 insertions, 28 deletions
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md
index a321caf..4de6c1d 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md
@@ -1 +1,13 @@
FSF2020--Somnath Pandit
+
+# **Topics:**
+
+## Double Integral
+
+## Fubini's Theorem
+
+## Line Integrals
+
+## Fundamental Theorem of Line integrals
+
+## Vector Fields
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/README.md
new file mode 100644
index 0000000..5fa2146
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/README.md
@@ -0,0 +1,21 @@
+**file1_area_under_func**
+![file1_area_under_func](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.gif)
+
+**file2_volume_under_surface**
+![file2_volume_under_surface](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.gif)
+
+**file3_y_limit_dependent_on_x**
+![file3_y_limit_dependent_on_x](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.gif)
+
+**file4_non_rect_region**
+![file4_non_rect_region](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.gif)
+
+**file5_elementary_area**
+![file5_elementary_area](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.gif)
+
+**file6_doing_integration**
+![file6_doing_integration](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.gif)
+
+**file7_int_process_of_example**
+![file7_int_process_of_example](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.gif)
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.gif
index 223218b..223218b 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_under_func.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.py
index 773840c..773840c 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_under_func.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file1_area_under_func.py
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.gif
new file mode 100644
index 0000000..1455573
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py
index a794f46..38d41c6 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file2_volume_under_surface.py
@@ -5,11 +5,11 @@ class SurfacesAnimation(ThreeDScene):
CONFIG = {
"axes_config": {
"x_min": 0,
- "x_max": 8,
+ "x_max": 7,
"y_min": 0,
- "y_max": 8,
+ "y_max": 7,
"z_min": 0,
- "z_max": 6,
+ "z_max": 5,
"a":1 ,"b": 6, "c":2 , "d":6,
"axes_shift":-3*OUT + 5*LEFT,
"x_axis_config": {
@@ -46,13 +46,24 @@ class SurfacesAnimation(ThreeDScene):
self.setup_axes()
self.set_camera_orientation(distance=35,
phi=80 * DEGREES,
- theta=-80 * DEGREES,
+ theta=-100 * DEGREES,
)
- fn_text=TextMobject("$z=f(x,y)$").set_color(PINK)
+ fn_text=TextMobject(
+ "$z=f(x,y)$",
+ color=PINK,
+ stroke_width=1.5
+ )
self.add_fixed_in_frame_mobjects(fn_text)
fn_text.to_edge(TOP,buff=MED_SMALL_BUFF)
+ riemann_sum_text=TextMobject(
+ r"The volume approximated as\\ sum of cuboids",
+ color=BLUE,
+ stroke_width=1.5
+ )
+ riemann_sum_text.to_corner(UR,buff=.2)
+
R=TextMobject("R").set_color(BLACK).scale(3)
R.move_to(self.axes.input_plane,IN)
self.add(R)
@@ -70,13 +81,54 @@ class SurfacesAnimation(ThreeDScene):
)
- self.begin_ambient_camera_rotation(rate=0.07)
+ self.begin_ambient_camera_rotation(rate=0.06)
self.play(Write(surface))
- # self.play(LaggedStart(ShowCreation(surface)))
+ # self.add(surface)
self.get_lines()
- # self.play(FadeIn(self.axes.input_plane))
+ self.wait(1)
+ self.add_fixed_in_frame_mobjects(riemann_sum_text)
+ self.play(Write(riemann_sum_text))
+
+ cuboids1=self.show_the_riemmann_sum(
+ lambda x,y : np.array([x,y,self.Func(x,y)]),
+ fill_opacity=1,
+ dl=.5,
+ start_color=BLUE,
+ end_color=BLUE_E,
+ )
+ self.play(ShowCreation(cuboids1),run_time=5)
+ self.play(FadeOut(surface))
+
+ cuboids2=self.show_the_riemmann_sum(
+ lambda x,y : np.array([x,y,self.Func(x,y)]),
+ fill_opacity=1,
+ dl=.25,
+ start_color=BLUE,
+ end_color=BLUE_E,
+ )
+ self.play(ReplacementTransform(
+ cuboids1,
+ cuboids2
+ ))
+
+ cuboids3=self.show_the_riemmann_sum(
+ lambda x,y : np.array([x,y,self.Func(x,y)]),
+ fill_opacity=1,
+ dl=.1,
+ start_color=BLUE,
+ end_color=BLUE_E,
+ stroke_width=.1,
+ )
+ self.play(
+ FadeOut(cuboids2),
+ ShowCreation(cuboids3),
+ )
+
self.wait(3)
+
+
+
def get_surface(self,axes, func, **kwargs):
config = {
@@ -101,9 +153,6 @@ class SurfacesAnimation(ThreeDScene):
def get_lines(self):
axes = self.axes
- labels=[axes.x_axis.n2p(axes.a), axes.x_axis.n2p(axes.b), axes.y_axis.n2p(axes.c),
- axes.y_axis.n2p(axes.d)]
-
surface_corners=[]
for x,y,z in self.region_corners:
@@ -112,23 +161,89 @@ class SurfacesAnimation(ThreeDScene):
lines=VGroup()
for start , end in zip(surface_corners,
self.region_corners):
- lines.add(self.draw_lines(start,end,"RED"))
+ lines.add(self.draw_lines(start,end,"#9CDCEB"))
+
+ labels=[
+ (axes.a,0,0),
+ (axes.b,0,0),
+ (0,axes.d,0),
+ (0,axes.c,0)
+ ]
+ self.region_corners[-1]=self.region_corners[0]
+ for start , end in zip(labels,self.region_corners):
+ lines.add(self.draw_lines(start,end,"WHITE"))
- for start , end in zip(labels,
- self.region_corners):
- # lines.add(self.draw_lines(start,end,"BLUE"))
- # print (start,end)
- pass
+ # self.add(lines)
self.play(ShowCreation(lines))
-
+
def draw_lines(self,start,end,color):
start=self.axes.c2p(*start)
end=self.axes.c2p(*end)
line=DashedLine(start,end,color=color)
return line
+
+
+ def show_the_riemmann_sum(
+ self,
+ surface,
+ x_min=None,
+ x_max=None,
+ y_min=None,
+ y_max=None,
+ dl=.5,
+ stroke_width=.5,
+ stroke_color=BLACK,
+ fill_opacity=1,
+ start_color=None,
+ end_color=None,
+ ):
+ x_min = x_min if x_min is not None else self.axes.a
+ x_max = x_max if x_max is not None else self.axes.b
+ y_min = y_min if y_min is not None else self.axes.c
+ y_max = y_max if y_max is not None else self.axes.d
+
+ if start_color is None:
+ start_color = BLUE
+ if end_color is None:
+ end_color = BLUE
+
+ cuboids = VGroup()
+ x_range = np.arange(x_min, x_max, dl)
+ y_range = np.arange(y_min, y_max, dl)
+ colors = color_gradient([start_color, end_color], len(x_range))
+ for x, color in zip(x_range, colors):
+ for y in y_range:
+ sample_base = np.array([x ,y ,0])
+ sample_base_dl = np.array([x + dl, y + dl,0])
+ sample_input = np.array([x +0.5*dl, y +0.5*dl,0])
+
+ base_point = self.axes.c2p(*sample_base)
+ base_dx_point = self.axes.c2p(*sample_base_dl)
+
+ surface_val= surface(*sample_input[:2])
+ surface_point = self.axes.c2p(*surface_val)
+
+ points = VGroup(*list(map(VectorizedPoint, [
+ base_point,
+ surface_point,
+ base_dx_point
+ ])))
+
+ # self.add(points)
+ cuboid = Prism(dimensions=[dl,dl,surface_val[-1]])
+ cuboid.replace(points, stretch=True)
+
+ cuboid.set_fill(color, opacity=fill_opacity)
+ cuboid.set_stroke(stroke_color, width=stroke_width)
+ cuboids.add(cuboid)
+
+ return cuboids
+
+#-------------------------------------------------------
+ #customize 3d axes
def get_three_d_axes(self, include_labels=True, include_numbers=True, **kwargs):
config = dict(self.axes_config)
config.update(kwargs)
@@ -165,7 +280,7 @@ class SurfacesAnimation(ThreeDScene):
axes.input_plane = input_plane
self.region_corners=[
- input_plane.get_corner(pos) for pos in (DL,DR,UR,UL)]
+ input_plane.get_corner(pos) for pos in (DL,DR,UL,UR)]
return axes
@@ -232,5 +347,3 @@ class SurfacesAnimation(ThreeDScene):
return axes
-
-#uploaded by Somnath Pandit.FSF2020_Double_Integral
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.gif
new file mode 100644
index 0000000..dcfacb6
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.py
index 4894ebf..f755495 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file3_y_limit_dependent_on_x.py
@@ -29,7 +29,7 @@ class YlimitXdependent(GraphScene):
line_eqn=TextMobject("2x+y=2").move_to(self.graph_origin+.8*X+Y).rotate(np.arctan(-2))
self.line=line
- caption=TextMobject(r"See the value of $y$ \\ is changing with $x$").move_to(self.graph_origin+1.2*X+1.8*Y)
+ caption=TextMobject(r"The value of $y$ is\\ changing with $x$").move_to(self.graph_origin+1.2*X+1.8*Y)
self.play(ShowCreation(line),Write(line_eqn))
# self.show_area()
self.show_rects()
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.gif
index c8e7c8c..c8e7c8c 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.py
index 793a000..793a000 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file4_non_rect_region.py
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.gif
index 5c9ac03..5c9ac03 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.py
index 362b6f8..362b6f8 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file5_elementary_area.py
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.gif
new file mode 100644
index 0000000..7a9271b
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.py
new file mode 100644
index 0000000..5a8cec0
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file6_doing_integration.py
@@ -0,0 +1,355 @@
+from manimlib.imports import *
+
+class IntegrationProcess(SpecialThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": 0,
+ "x_max": 7,
+ "y_min": 0,
+ "y_max": 7,
+ "z_min": 0,
+ "z_max": 4,
+ "a":1 ,"b": 6, "c":2 , "d":6,
+ "axes_shift":-3*OUT,
+ "x_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "y_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "z_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "num_axis_pieces": 1,
+ },
+ "default_graph_style": {
+ "stroke_width": 2,
+ "stroke_color": WHITE,
+ },
+ "default_surface_config": {
+ "fill_opacity": 0.5,
+ "checkerboard_colors": [LIGHT_GREY],
+ "stroke_width": 0.5,
+ "stroke_color": WHITE,
+ "stroke_opacity": 0.5,
+ },
+ "Func": lambda x,y: 2+y/4+np.cos(x/1.4)
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+ axes=self.axes
+
+ self.camera.frame_center.shift(axes.c2p(3,4,1.7))
+ self.set_camera_orientation(distance=35,
+ phi= 80 * DEGREES,
+ theta= -80 * DEGREES,
+ gamma = 0 * DEGREES
+ )
+
+ fn_text=TextMobject("$z=f(x,y)$").set_color(PINK)
+ self.add_fixed_in_frame_mobjects(fn_text)
+
+
+ R=TextMobject("R").set_color(BLACK).scale(3)
+ R.move_to(axes.input_plane,IN)
+ self.add(R)
+
+ # get the surface
+ surface= self.get_surface(
+ axes, lambda x , y:
+ self.Func(x,y)
+ )
+ surface.set_style(
+ fill_opacity=.65,
+ fill_color=PINK,
+ stroke_width=0.8,
+ stroke_color=WHITE,
+ )
+ fn_text.next_to(surface,UP,buff=MED_LARGE_BUFF)
+ slice_curve=(self.get_y_slice_graph(
+ axes,self.Func,5,color=YELLOW))
+
+
+ self.begin_ambient_camera_rotation(rate=0.08)
+ # self.play(Write(surface))
+ self.add(surface)
+
+ self.get_lines()
+
+ self.show_process(axes)
+
+ self.wait(3)
+
+
+
+ def show_process(self,axes):
+ y_tracker = ValueTracker(axes.c)
+ self.y_tracker=y_tracker
+ y=y_tracker.get_value
+
+ graph = always_redraw(
+ lambda: self.get_y_slice_graph(
+ axes, self.Func, y(),
+ stroke_color=YELLOW,
+ stroke_width=4,
+ )
+ )
+ graph.suspend_updating()
+
+
+ plane = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(x,y(),self.Func(x,y()))
+ for x in np.arange(axes.a,axes.b,0.01)
+ ],
+ *[
+ axes.c2p(x, y(), 0)
+ for x in [ axes.b, axes.a,]
+ ],
+ stroke_width=2,
+ fill_color=BLUE_D,
+ fill_opacity=.4,
+ ))
+
+ plane_side1 = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(axes.a,y,self.Func(axes.a,y))
+ for y in np.arange(axes.c,y(),0.01)
+ ],
+ *[
+ axes.c2p(axes.a, y, 0)
+ for y in [ y(),axes.c, ]
+ ],
+ stroke_width=2.5,
+ fill_color=BLUE_C,
+ fill_opacity=.2,
+ ))
+ plane_side2 = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(axes.b,y,self.Func(axes.b,y))
+ for y in np.arange(axes.c,y(),0.01)
+ ],
+ *[
+ axes.c2p(axes.b, y, 0)
+ for y in [y(),axes.c,]
+ ],
+ stroke_width=2.5,
+ fill_color=BLUE_E,
+ fill_opacity=.45,
+ ))
+ plane.suspend_updating()
+ plane_side1.suspend_updating()
+ plane_side2.suspend_updating()
+
+ self.play(Write(VGroup(graph,plane)),run_time=2)
+ self.add(plane.copy(),plane_side1,plane_side2)
+
+
+ plane_side1.resume_updating()
+ plane_side2.resume_updating()
+
+ self.move_camera(
+ distance=30,
+ phi= 85 * DEGREES,
+ theta= -10 * DEGREES,
+ run_time=1.5
+ )
+ self.play(
+ ApplyMethod(
+ y_tracker.set_value, axes.d,
+ rate_func=linear,
+ run_time=6,
+ )
+ )
+ plane.suspend_updating()
+ plane_side1.suspend_updating()
+ plane_side2.suspend_updating()
+
+
+
+ def get_y_slice_graph(self, axes, func, y, **kwargs):
+ config = dict()
+ config.update(self.default_graph_style)
+ config.update({
+ "t_min": axes.a,
+ "t_max": axes.b,
+ })
+ config.update(kwargs)
+ slice_curve=ParametricFunction(
+ lambda x: axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config,
+ )
+ return slice_curve
+
+
+ def get_surface(self,axes, func, **kwargs):
+ config = {
+ "u_min": axes.a,
+ "u_max": axes.b,
+ "v_min": axes.c,
+ "v_max": axes.d,
+ "resolution": (
+ (axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,
+ (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,
+ ),
+ }
+
+ config.update(self.default_surface_config)
+ config.update(kwargs)
+ return ParametricSurface(
+ lambda x,y : axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config
+ )
+
+ def get_lines(self):
+ axes = self.axes
+
+ surface_corners=[]
+ for x,y,z in self.region_corners:
+ surface_corners.append([x,y,self.Func(x,y)])
+
+ lines=VGroup()
+ for start , end in zip(surface_corners,
+ self.region_corners):
+ lines.add(self.draw_lines(start,end,"RED"))
+
+ labels=[
+ (axes.a,0,0),
+ (axes.b,0,0),
+ (0,axes.d,0),
+ (0,axes.c,0)
+ ]
+ self.region_corners[-1]=self.region_corners[0]
+ for start , end in zip(labels,
+ self.region_corners):
+ lines.add(self.draw_lines(start,end,"WHITE"))
+ self.add(lines)
+
+
+ def draw_lines(self,start,end,color):
+ start=self.axes.c2p(*start)
+ end=self.axes.c2p(*end)
+ line=DashedLine(start,end,color=color)
+
+ return line
+
+
+#------------------------------------------------------------
+ #customize 3d axes
+ def get_three_d_axes(self, include_labels=True, include_numbers=True, **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=TEAL,
+ stroke_width=0,
+ stroke_color=WHITE,
+ )
+
+ axes.input_plane = input_plane
+
+ self.region_corners=[
+ input_plane.get_corner(pos) for pos in (DL,DR,UL,UR)]
+
+ return axes
+
+
+ def setup_axes(self):
+ axes = self.get_three_d_axes(include_labels=True)
+ axes.add(axes.input_plane)
+ axes.scale(1)
+ # axes.center()
+ axes.shift(axes.axes_shift)
+
+ self.add(axes)
+
+ self.axes = axes
+
+ def add_axes_numbers(self, axes):
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+ tex_vals_x = [
+ ("a", axes.a),
+ ("b", axes.b),
+ ]
+ tex_vals_y=[
+ ("c", axes.c),
+ ("d", axes.d)
+ ]
+ x_labels = VGroup()
+ y_labels = VGroup()
+ for tex, val in tex_vals_x:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(x_axis.n2p(val), DOWN)
+ x_labels.add(label)
+ x_axis.add(x_labels)
+ x_axis.numbers = x_labels
+
+ for tex, val in tex_vals_y:
+ label = TexMobject(tex)
+ label.scale(1.5)
+ label.next_to(y_axis.n2p(val), LEFT)
+ label.rotate(90 * DEGREES)
+ y_labels.add(label)
+
+ y_axis.add(y_labels)
+ y_axis.numbers = y_labels
+
+ 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
+
+ y_label = TextMobject("y")
+ y_label.rotate(90 * DEGREES, OUT)
+ y_label.next_to(axes.y_axis.get_end(), UP)
+ axes.y_axis.label = y_label
+
+ z_label = TextMobject("z")
+ z_label.rotate(90 * DEGREES, RIGHT)
+ z_label.next_to(axes.z_axis.get_zenith(), RIGHT)
+ axes.z_axis.label = z_label
+ for axis in axes:
+ axis.add(axis.label)
+ return axes
+
+
+
+ #uploaded by Somnath Pandit.FSF2020_Double_Integral
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.gif
new file mode 100644
index 0000000..9fbdde8
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.py
new file mode 100644
index 0000000..f733761
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/file7_int_process_of_example.py
@@ -0,0 +1,366 @@
+from manimlib.imports import *
+
+class IntegrationProcess(SpecialThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": 0,
+ "x_max": 5,
+ "y_min": 0,
+ "y_max": 7,
+ "z_min": 0,
+ "z_max": 3,
+ "a":0 ,"b":4 , "c":0 , "d":6,
+ "axes_shift":1.5*IN+2*LEFT+4*DOWN,
+ "x_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "y_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "z_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "num_axis_pieces": 1,
+ },
+ "default_graph_style": {
+ "stroke_width": 2,
+ "stroke_color": WHITE,
+ },
+ "default_surface_config": {
+ "fill_opacity": 0.5,
+ "checkerboard_colors": [LIGHT_GREY],
+ "stroke_width": 0.5,
+ "stroke_color": WHITE,
+ "stroke_opacity": 0.5,
+ },
+ "Func": lambda x,y: 2*(1+(x+y)/10)
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+ axes=self.axes
+ self.set_camera_orientation(#distance=35,
+ phi=60 * DEGREES,
+ theta=10 * DEGREES,
+ )
+
+ fn_text=TextMobject("$z=(1+x+y)$").set_color(PINK)
+ self.add_fixed_in_frame_mobjects(fn_text)
+ fn_text.to_edge(TOP,buff=.1)
+ self.fn_text=fn_text
+
+ R=TextMobject("R").set_color(BLACK).scale(3).rotate(PI/2)
+ R.move_to(axes.input_plane,IN)
+ self.add(R)
+
+ #get the surface
+ surface= self.get_surface(
+ axes, lambda x , y:
+ self.Func(x,y)
+ )
+ surface.set_style(
+ fill_opacity=0.75,
+ fill_color=PINK,
+ stroke_width=0.8,
+ stroke_color=WHITE,
+ )
+
+ slice_curve=(self.get_y_slice_graph(
+ axes,self.Func,5,color=YELLOW))
+
+
+ self.begin_ambient_camera_rotation(rate=0.04)
+ # self.play(Write(surface))
+ self.add(surface)
+
+ self.get_lines()
+
+ self.show_process(axes)
+
+ self.wait()
+
+
+
+ def show_process(self,axes):
+ y_tracker = ValueTracker(axes.c)
+ self.y_tracker=y_tracker
+ y=y_tracker.get_value
+ graph = always_redraw(
+ lambda: self.get_y_slice_graph(
+ axes, self.Func, y(),
+ stroke_color=YELLOW,
+ stroke_width=4,
+ )
+ )
+ graph.suspend_updating()
+
+ plane = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(x,y(),self.Func(x,y()))
+ for x in np.arange(axes.a,axes.b,0.01)
+ ],
+ *[
+ axes.c2p(x, y(), 0)
+ for x in [ axes.b, axes.a,]
+ ],
+ stroke_width=0,
+ fill_color=BLUE_E,
+ fill_opacity=.65,
+ ))
+ plane_side1 = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(axes.a,y,self.Func(axes.a,y))
+ for y in np.arange(axes.c,y(),0.01)
+ ],
+ *[
+ axes.c2p(axes.a, y, 0)
+ for y in [ y(),axes.c, ]
+ ],
+ stroke_width=2.5,
+ fill_color=BLUE_C,
+ fill_opacity=.2,
+ ))
+ plane_side2 = always_redraw(lambda: Polygon(
+ *[
+ axes.c2p(axes.b,y,self.Func(axes.b,y))
+ for y in np.arange(axes.c,y(),0.01)
+ ],
+ *[
+ axes.c2p(axes.b, y, 0)
+ for y in [y(),axes.c,]
+ ],
+ stroke_width=2.5,
+ fill_color=BLUE_E,
+ fill_opacity=.45,
+ ))
+ plane.suspend_updating()
+ plane_side1.suspend_updating()
+ plane_side2.suspend_updating()
+
+ first_x_text=TextMobject("First the $x$ integration..",color=YELLOW)
+ first_x_text.to_corner(UR,buff=1.1)
+
+ x_func=TextMobject("$\\frac 3 2 + y$",color=BLUE)
+ '''x_func.next_to(self.fn_text,DOWN)
+ x_func.align_to(self.fn_text,LEFT)'''
+ x_func.to_edge(LEFT,buff=1)
+
+ then_y_text=TextMobject("Then the $y$ integration..",color=YELLOW)
+ then_y_text.to_corner(UR,buff=1.1)
+
+ self.add_fixed_in_frame_mobjects(first_x_text)
+ self.play(Write(first_x_text))
+ self.add_fixed_in_frame_mobjects(x_func)
+ self.play(
+ Write(VGroup(graph,plane,x_func)),
+ run_time=3
+ )
+
+ self.wait()
+ self.remove(first_x_text)
+ self.add_fixed_in_frame_mobjects(then_y_text)
+ self.play(Write(then_y_text))
+ self.add(plane.copy(),plane_side1,plane_side2)
+ graph.resume_updating()
+ plane.resume_updating()
+ plane_side1.resume_updating()
+ plane_side2.resume_updating()
+ self.play(
+ ApplyMethod(
+ y_tracker.set_value, axes.d,
+ rate_func=linear,
+ run_time=6,
+ )
+ )
+
+ graph.suspend_updating()
+ plane.suspend_updating()
+ plane_side1.suspend_updating()
+ plane_side2.suspend_updating()
+
+
+ def get_y_slice_graph(self, axes, func, y, **kwargs):
+ config = dict()
+ config.update(self.default_graph_style)
+ config.update({
+ "t_min": axes.a,
+ "t_max": axes.b,
+ })
+ config.update(kwargs)
+ slice_curve=ParametricFunction(
+ lambda x: axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config,
+ )
+ return slice_curve
+
+
+ def get_surface(self,axes, func, **kwargs):
+ config = {
+ "u_min": axes.a,
+ "u_max": axes.b,
+ "v_min": axes.c,
+ "v_max": axes.d,
+ "resolution": (
+ (axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,
+ (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,
+ ),
+ }
+
+ config.update(self.default_surface_config)
+ config.update(kwargs)
+ return ParametricSurface(
+ lambda x,y : axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config
+ )
+
+ def get_lines(self):
+ axes = self.axes
+
+ surface_corners=[]
+ for x,y,z in self.region_corners:
+ surface_corners.append([x,y,self.Func(x,y)])
+
+ lines=VGroup()
+ for start , end in zip(surface_corners,
+ self.region_corners):
+ lines.add(self.draw_lines(start,end,"RED"))
+
+ labels=[
+ (axes.a,0,0),
+ (axes.b,0,0),
+ (0,axes.d,0),
+ (0,axes.c,0)
+ ]
+ self.region_corners[-1]=self.region_corners[0]
+ for start , end in zip(labels,
+ self.region_corners):
+ lines.add(self.draw_lines(start,end,"WHITE"))
+ self.add(lines)
+
+
+ def draw_lines(self,start,end,color):
+ start=self.axes.c2p(*start)
+ end=self.axes.c2p(*end)
+ line=DashedLine(start,end,color=color)
+
+ return line
+
+
+#------------------------------------------------------------
+ #customize 3d axes
+ def get_three_d_axes(self, include_labels=True, include_numbers=True, **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, LEFT,
+ 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.3,
+ fill_color=TEAL,
+ stroke_width=.2,
+ stroke_color=WHITE,
+ )
+
+ axes.input_plane = input_plane
+
+ self.region_corners=[
+ input_plane.get_corner(pos) for pos in (DL,DR,UL,UR)]
+
+ return axes
+
+
+ def setup_axes(self):
+ axes = self.get_three_d_axes(include_labels=True)
+ axes.add(axes.input_plane)
+ axes.scale(1)
+ # axes.center()
+ axes.shift(axes.axes_shift)
+
+ self.add(axes)
+ self.axes = axes
+
+ def add_axes_numbers(self, axes):
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+ tex_vals_x = [
+
+ ("1", axes.b),
+ ]
+ tex_vals_y=[
+
+ ("2", axes.d)
+ ]
+ x_labels = VGroup()
+ y_labels = VGroup()
+ for tex, val in tex_vals_x:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(x_axis.n2p(val), DOWN)
+ label.rotate(180 * DEGREES)
+ x_labels.add(label)
+ x_axis.add(x_labels)
+ x_axis.numbers = x_labels
+
+ for tex, val in tex_vals_y:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(y_axis.n2p(val), LEFT)
+ label.rotate(90 * DEGREES)
+ y_labels.add(label)
+
+ y_axis.add(y_labels)
+ y_axis.numbers = y_labels
+
+ 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
+
+ y_label = TextMobject("y")
+ y_label.rotate(90 * DEGREES, OUT)
+ y_label.next_to(axes.y_axis.get_end(), UP)
+ axes.y_axis.label = y_label
+
+ z_label = TextMobject("z")
+ z_label.rotate(90 * DEGREES, LEFT)
+ z_label.next_to(axes.z_axis.get_zenith(), LEFT)
+ axes.z_axis.label = z_label
+ for axis in axes:
+ axis.add(axis.label)
+ return axes
+
+
+
+ #uploaded by Somnath Pandit.FSF2020_Double_Integral
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif
deleted file mode 100644
index ae23a7b..0000000
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif
+++ /dev/null
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.gif
deleted file mode 100644
index a2bfd9d..0000000
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.gif
+++ /dev/null
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/README.md
new file mode 100644
index 0000000..c1c6e8e
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/README.md
@@ -0,0 +1,14 @@
+
+**file1_surface1**
+![file1_surface1](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.gif)
+
+**file2_surface2**
+![file2_surface2](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.gif)
+
+**file3_iteration_methods**
+![file3_iteration_methods](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.gif)
+
+**file4_curvy_limits**
+![file4_curvy_limits](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.gif)
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.gif
index 8c9fa0a..8c9fa0a 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.py
index a590a53..a590a53 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file1_surface1.py
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.gif
new file mode 100644
index 0000000..37c4b1d
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.py
index c998f3b..3160fdb 100644
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file2_surface2.py
@@ -63,7 +63,7 @@ class SurfacesAnimation(ThreeDScene):
surface.set_style(
fill_opacity=.5,
fill_color=BLUE_E,
- stroke_width=0.2,
+ stroke_width=0.4,
stroke_color=WHITE,
)
#get boundary curves
@@ -85,17 +85,18 @@ class SurfacesAnimation(ThreeDScene):
self.add(c1,c2,c1_label,c2_label)
- self.begin_ambient_camera_rotation(rate=0.4)
+ self.begin_ambient_camera_rotation(rate=0.24)
self.get_region(self.axes,c1,c2)
self.play(Write(surface))
self.get_lines()
- self.wait(1)
+ self.wait(3.5)
self.stop_ambient_camera_rotation()
+ self.wait(.5)
self.move_camera(
distance=20,
phi=10 * DEGREES,
theta=80 * DEGREES,
- run_time=2.5
+ run_time=3
)
self.wait(2)
@@ -128,7 +129,7 @@ class SurfacesAnimation(ThreeDScene):
R=TextMobject("R").set_color(PINK).scale(2).rotate(180*DEGREES , OUT)
R.move_to(region,IN+RIGHT)
- self.play(Write(region))
+ self.play(ShowCreation(region))
self.add(R)
def get_surface(self,axes, func, **kwargs):
@@ -279,8 +280,11 @@ class SurfacesAnimation(ThreeDScene):
axes.z_axis.label = z_label
for axis in axes:
axis.add(axis.label)
- return axes
+ return axes
#uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.gif
new file mode 100644
index 0000000..2e507f9
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.py
new file mode 100644
index 0000000..55f91d3
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3.o_iteration_methods_checkpoint.py
@@ -0,0 +1,226 @@
+from manimlib.imports import *
+
+class IterationMethods(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 1,
+ "y_min" : 0,
+ "y_max" : 1,
+ "x_tick_frequency" : 1,
+ "y_tick_frequency" : 1,
+ "x_labeled_nums": list(np.arange(0,2)),
+ "y_labeled_nums": list(np.arange(0 ,2)),
+ "x_axis_width": 6,
+ "y_axis_height": 6,
+ "graph_origin": ORIGIN+4*LEFT+3*DOWN,
+ "area_color": PINK ,
+ "area_opacity": .6,
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+
+ # self.intro_scene()
+ self.setup_axes(animate=True)
+
+
+ curve1= self.get_graph(
+ lambda x : x**2 ,
+ x_min = 0,
+ x_max = 1,
+ color = ORANGE)
+ c1_eqn=self.get_graph_label(
+ curve1,
+ label="y=x^2",
+ x_val=.5,
+ direction=RIGHT,
+ buff=MED_LARGE_BUFF,
+ color=ORANGE,
+ )
+
+ curve2= self.get_graph(
+ lambda x : x ,
+ x_min = 0,
+ x_max = 1,
+ color = YELLOW)
+ c2_eqn=self.get_graph_label(
+ curve2,
+ label="y=x",
+ x_val=.5,
+ direction=LEFT,
+ buff=MED_LARGE_BUFF,
+ color=YELLOW,
+ )
+ self.curve1=curve1
+ self.curve2=curve2
+
+ caption_y_int=TextMobject(r"Observe the limits\\ of integration").to_corner(UR)
+ int_lim=TextMobject(
+ "$$\\int_0^1$$"
+ ).next_to(
+ caption_y_int,DOWN,buff=.5
+ ).align_to(
+ caption_y_int,LEFT
+ )
+
+ self.play(ShowCreation(VGroup(curve1,curve2)),Write(VGroup(c2_eqn,c1_eqn)))
+ rects=self.get_rects()
+
+ self.play(Write(caption_y_int))
+ self.show_integral_values_at_different_x()
+ self.wait(1)
+ self.add(int_lim)
+ self.play(FadeOut(self.brace_group))
+ self.play(ApplyMethod(
+ self.y_int.next_to,
+ int_lim,RIGHT,buff=0))
+
+ self.play(ApplyMethod(
+ self.dx_label.next_to,
+ self.y_int,RIGHT))
+
+ self.show_area()
+
+ self.wait(2)
+
+ ###################
+ def intro_scene(self):
+ text=TextMobject(r"How different orders of \textbf{iterated integral}\\ works over the same region ?" )
+ self.play(Write(text),run_time=4)
+ self.wait(2)
+ self.play(FadeOut(text))
+
+
+ def show_area(self):
+ area = self.bounded_riemann_rectangles(
+ self.curve1,
+ self.curve2,
+ x_min = 0,
+ x_max = 1,
+ dx =.001,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity = 1,
+ stroke_width = 0,
+ )
+ self.play(ShowCreation(area))
+ # self.transform_between_riemann_rects(self.rects,area)
+ self.area = area
+
+ def get_rects(self):
+ rects = self.bounded_riemann_rectangles(
+ self.curve1,
+ self.curve2,
+ x_min = 0,
+ x_max = 1,
+ dx =.01,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity =self.area_opacity,
+ stroke_width = 0,
+ )
+ # self.transform_between_riemann_rects(self.area,rects)
+ self.rects=rects
+ return rects
+
+ def show_integral_values_at_different_x(self):
+ rects=self.rects
+ rect = rects[len(rects)*1//10]
+ dx_brace = Brace(rect, DOWN, buff = 0)
+ dx_label = dx_brace.get_text("$dx$", buff = SMALL_BUFF)
+ dx_brace_group = VGroup(dx_brace,dx_label)
+ rp=int(len(rects)/10)
+ rects_subset = self.rects[4*rp:5*rp]
+
+ last_rect = None
+ for rect in rects_subset:
+ brace = Brace(rect, LEFT, buff =.1)
+ y_int = TexMobject("\\int_{x^2}^{x}dy")#.rotate(PI/2)
+ y_int.next_to(brace, LEFT, MED_SMALL_BUFF)
+ anims = [
+ rect.set_fill, self.area_color, 1,
+ dx_brace_group.next_to, rect, DOWN, SMALL_BUFF
+ ]
+ if last_rect is not None:
+ anims += [
+ last_rect.set_fill, None, 0,
+ # last_rect.set_fill, self.area_color, self.area_opacity,
+ ReplacementTransform(last_brace, brace),
+ ReplacementTransform(last_y_int, y_int),
+ ]
+ else:
+ anims += [
+ GrowFromCenter(brace),
+ Write(y_int)
+ ]
+ self.play(*anims)
+ # self.wait(.2)
+
+ last_rect = rect
+ last_brace = brace
+ last_y_int = y_int
+
+ y_int = last_y_int
+ y_brace = last_brace
+ self.brace_group=VGroup(y_brace,dx_brace,rect)
+ self.y_int=y_int
+ self.dx_label=dx_label
+
+
+ def bounded_riemann_rectangles(
+ self,
+ graph1,
+ graph2,
+ x_min=None,
+ x_max=None,
+ dx=0.01,
+ input_sample_type="center",
+ stroke_width=1,
+ stroke_color=BLACK,
+ fill_opacity=1,
+ start_color=None,
+ end_color=None,
+ show_signed_area=True,
+ width_scale_factor=1.001
+ ):
+ x_min = x_min if x_min is not None else self.x_min
+ x_max = x_max if x_max is not None else self.x_max
+ if start_color is None:
+ start_color = self.default_riemann_start_color
+ if end_color is None:
+ end_color = self.default_riemann_end_color
+ rectangles = VGroup()
+ x_range = np.arange(x_min, x_max, dx)
+ colors = color_gradient([start_color, end_color], len(x_range))
+ for x, color in zip(x_range, colors):
+ if input_sample_type == "left":
+ sample_input = x
+ elif input_sample_type == "right":
+ sample_input = x + dx
+ elif input_sample_type == "center":
+ sample_input = x + 0.5 * dx
+ else:
+ raise Exception("Invalid input sample type")
+ graph1_point = self.input_to_graph_point(sample_input, graph1)
+ graph1_point_dx= self.input_to_graph_point(sample_input + width_scale_factor * dx, graph1)
+ graph2_point = self.input_to_graph_point(sample_input, graph2)
+
+ points = VGroup(*list(map(VectorizedPoint, [
+ graph1_point,
+ graph1_point_dx,
+ graph2_point
+ ])))
+
+ rect = Rectangle()
+ rect.replace(points, stretch=True)
+ if graph1_point[1] < self.graph_origin[1] and show_signed_area:
+ fill_color = invert_color(color)
+ else:
+ fill_color = color
+ rect.set_fill(fill_color, opacity=fill_opacity)
+ rect.set_stroke(stroke_color, width=stroke_width)
+ rectangles.add(rect)
+ return rectangles
+
+#uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.gif
new file mode 100644
index 0000000..4e1611b
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.py
new file mode 100644
index 0000000..ad78a0b
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file3_iteration_methods.py
@@ -0,0 +1,429 @@
+from manimlib.imports import *
+
+class IterationMethods(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 1,
+ "y_min" : 0,
+ "y_max" : 1,
+ "x_tick_frequency" : 1,
+ "y_tick_frequency" : 1,
+ "x_labeled_nums": list(np.arange(0,2)),
+ "y_labeled_nums": list(np.arange(0 ,2)),
+ "x_axis_width": 6,
+ "y_axis_height": 6,
+ "graph_origin": ORIGIN+4.5*LEFT+3*DOWN,
+ "area_color": PINK ,
+ "area_opacity": .6,
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+
+ self.intro_scene()
+ self.setup_axes(animate=True)
+
+
+ curve1= self.get_graph(
+ lambda x : x**2 ,
+ x_min = 0,
+ x_max = 1,
+ color = ORANGE)
+ c1_eqn=self.get_graph_label(
+ curve1,
+ label="y=x^2",
+ x_val=.5,
+ direction=RIGHT,
+ buff=MED_LARGE_BUFF,
+ color=ORANGE,
+ )
+
+ curve2= self.get_graph(
+ lambda x : x ,
+ x_min = 0,
+ x_max = 1,
+ color = YELLOW)
+ c2_eqn=self.get_graph_label(
+ curve2,
+ label="y=x",
+ x_val=.7,
+ direction=LEFT,
+ buff=MED_LARGE_BUFF,
+ color=YELLOW,
+ )
+ self.curve1=curve1
+ self.curve2=curve2
+
+ caption_limit=TextMobject(r"Observe the limits\\ of integration").to_corner(UR)
+ int_lim=TextMobject(
+ "$$\\int_0^1$$"
+ ).next_to(
+ caption_limit,DOWN,buff=.5
+ ).align_to(
+ caption_limit,LEFT
+ )
+ self.int_lim=int_lim
+ self.play(ShowCreation(VGroup(curve1,curve2)),Write(VGroup(c2_eqn,c1_eqn)))
+
+ self.play(Write(caption_limit))
+ self.get_rects()
+ self.show_integral_values_at_different_x()
+ self.wait(1)
+ self.integral_setup(int_lim,first_y=True)
+
+
+ self.another_method_scene()
+ self.remove(self.area)
+ self.wait()
+
+ c1_eqn_y=self.get_graph_label(
+ curve1,
+ label="x=\sqrt y",
+ x_val=.6,
+ direction=RIGHT,
+ buff=MED_LARGE_BUFF,
+ color=ORANGE,
+ )
+ c2_eqn_y=self.get_graph_label(
+ curve2,
+ label="x=y",
+ x_val=.7,
+ direction=LEFT,
+ buff=MED_LARGE_BUFF,
+ color=YELLOW,
+ )
+ self.play(
+ ReplacementTransform(c1_eqn,c1_eqn_y),
+ ReplacementTransform(c2_eqn,c2_eqn_y)
+ )
+ self.get_rects(base_y=True)
+ self.show_integral_values_at_different_y()
+ self.wait(1)
+
+ int_lim_y=int_lim.copy()
+ int_lim_y.next_to(int_lim,DOWN)
+ self.int_lim_y=int_lim_y
+ equal=TextMobject("$$=$$").next_to(int_lim_y,LEFT)
+ self.add(equal)
+
+ self.integral_setup(int_lim_y,first_y=False)
+
+ self.wait(2)
+
+ ###################
+ def intro_scene(self):
+ text=TextMobject(r"How different orders of \textbf{iterated integral}\\ works over the same region ?" )
+ self.play(Write(text),run_time=4)
+ self.wait(2)
+ self.play(FadeOut(text))
+
+ def another_method_scene(self):
+ text=TextMobject(r"The other method\\ of iteration")
+ text.next_to(self.curve1,UP,buff=-1)
+ self.play(GrowFromCenter(text))
+ self.wait(2)
+ self.play(LaggedStart(FadeOut(text),lag_ratio=2))
+
+ def integral_setup(self,ref_object,first_y=True):
+ if first_y:
+ area=self.get_area()
+ self.area=area
+ self.play(FadeOut(self.brace_group))
+ self.play(ApplyMethod(
+ self.y_int.next_to,
+ ref_object,RIGHT,buff=0)
+ )
+
+ self.play(ApplyMethod(
+ self.dx_label.next_to,
+ self.y_int,RIGHT),
+ ShowCreation(area),
+ Write(self.int_lim),run_time=4
+ )
+ else:
+ area=self.get_area(base_y=True)
+ self.area=area
+ self.play(
+ FadeOut(self.y_brace_group),
+ Rotate(self.x_int,PI/2)
+ )
+ self.play(ApplyMethod(
+ self.x_int.next_to,
+ ref_object,RIGHT,buff=0)
+ )
+ self.play(ApplyMethod(
+ self.dy_label.next_to,
+ self.x_int,RIGHT),
+ ShowCreation(area),
+ Write(self.int_lim_y),run_time=4
+ )
+
+ def get_area(self,base_y=False):
+ if base_y:
+ area = self.bounded_riemann_rectangles_y(
+ lambda x: x,
+ lambda x: np.sqrt(x),
+ y_min = 0,
+ y_max = 1,
+ dy =.001,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity =self.area_opacity,
+ stroke_width = 0,
+ )
+ self.y_area = area
+ else:
+ area = self.bounded_riemann_rectangles(
+ self.curve1,
+ self.curve2,
+ x_min = 0,
+ x_max = 1,
+ dx =.001,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity =self.area_opacity,
+ stroke_width = 0,
+ )
+ self.area = area
+
+ # self.transform_between_riemann_rects(self.rects,area)
+ return area
+
+ def get_rects(self,base_y=False):
+ if base_y:
+ rects = self.bounded_riemann_rectangles_y(
+ lambda x: x,
+ lambda x: np.sqrt(x),
+ y_min = 0,
+ y_max = 1,
+ dy =.01,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity =self.area_opacity,
+ stroke_width = 0,
+ )
+ self.y_rects=rects
+ else:
+ rects = self.bounded_riemann_rectangles(
+ self.curve1,
+ self.curve2,
+ x_min = 0,
+ x_max = 1,
+ dx =.01,
+ start_color = self.area_color,
+ end_color = self.area_color,
+ fill_opacity =self.area_opacity,
+ stroke_width = 0,
+ )
+ self.rects=rects
+ # self.transform_between_riemann_rects(self.area,rects)
+
+ return rects
+
+ def show_integral_values_at_different_x(self):
+ rects=self.rects
+ rect = rects[len(rects)*1//10]
+ dx_brace = Brace(rect, DOWN, buff = 0)
+ dx_label = dx_brace.get_text("$dx$", buff = SMALL_BUFF)
+ dx_brace_group = VGroup(dx_brace,dx_label)
+ rp=int(len(rects)/20)
+ rects_subset = rects[6*rp:7*rp]
+
+ last_rect = None
+ for rect in rects_subset:
+ brace = Brace(rect, LEFT, buff =.1)
+ y_int = TexMobject("\\int_{x^2}^{x}dy")#.rotate(PI/2)
+ y_int.next_to(brace, LEFT, MED_SMALL_BUFF)
+ anims = [
+ rect.set_fill, self.area_color, 1,
+ dx_brace_group.next_to, rect, DOWN, SMALL_BUFF
+ ]
+ if last_rect is not None:
+ anims += [
+ last_rect.set_fill, None, 0,
+ # last_rect.set_fill, self.area_color, self.area_opacity,
+ ReplacementTransform(last_brace, brace),
+ ReplacementTransform(last_y_int, y_int),
+ ]
+ else:
+ anims += [
+ GrowFromCenter(brace),
+ Write(y_int)
+ ]
+ self.play(*anims)
+ # self.wait(.2)
+
+ last_rect = rect
+ last_brace = brace
+ last_y_int = y_int
+
+ y_int = last_y_int
+ y_brace = last_brace
+ self.brace_group=VGroup(y_brace,dx_brace,rect)
+ self.y_int=y_int
+ self.dx_label=dx_label
+
+ def show_integral_values_at_different_y(self):
+ rects=self.y_rects
+ rect = rects[len(rects)*1//10]
+ dy_brace = Brace(rect, LEFT, buff = 0)
+ dy_label = dy_brace.get_text("$dy$", buff = SMALL_BUFF)
+ dy_brace_group = VGroup(dy_brace,dy_label)
+ rp=int(len(rects)/20)
+ rects_subset = rects[5*rp:6*rp]
+
+ last_rect = None
+ for rect in rects_subset:
+ brace = Brace(rect, DOWN, buff =.1)
+ x_int = TexMobject("\\int_{y}^{\sqrt y}dx").rotate(-PI/2)
+ x_int.next_to(brace, DOWN, SMALL_BUFF)
+ anims = [
+ rect.set_fill, self.area_color, 1,
+ dy_brace_group.next_to, rect, LEFT, SMALL_BUFF
+ ]
+ if last_rect is not None:
+ anims += [
+ last_rect.set_fill, None, 0,
+ # last_rect.set_fill, self.area_color, self.area_opacity,
+ ReplacementTransform(last_brace, brace),
+ ReplacementTransform(last_x_int, x_int),
+ ]
+ else:
+ anims += [
+ GrowFromCenter(brace),
+ Write(x_int)
+ ]
+ self.play(*anims)
+ # self.wait(.2)
+
+ last_rect = rect
+ last_brace = brace
+ last_x_int = x_int
+
+ x_int = last_x_int
+ y_brace = last_brace
+ self.y_brace_group=VGroup(y_brace,dy_brace,rect)
+ self.x_int=x_int
+ self.dy_label=dy_label
+
+
+ def bounded_riemann_rectangles(
+ self,
+ graph1,
+ graph2,
+ x_min=None,
+ x_max=None,
+ dx=0.01,
+ input_sample_type="center",
+ stroke_width=1,
+ stroke_color=BLACK,
+ fill_opacity=1,
+ start_color=None,
+ end_color=None,
+ show_signed_area=True,
+ width_scale_factor=1.001
+ ):
+ x_min = x_min if x_min is not None else self.x_min
+ x_max = x_max if x_max is not None else self.x_max
+ if start_color is None:
+ start_color = self.default_riemann_start_color
+ if end_color is None:
+ end_color = self.default_riemann_end_color
+ rectangles = VGroup()
+ x_range = np.arange(x_min, x_max, dx)
+ colors = color_gradient([start_color, end_color], len(x_range))
+ for x, color in zip(x_range, colors):
+ if input_sample_type == "left":
+ sample_input = x
+ elif input_sample_type == "right":
+ sample_input = x + dx
+ elif input_sample_type == "center":
+ sample_input = x + 0.5 * dx
+ else:
+ raise Exception("Invalid input sample type")
+ graph1_point = self.input_to_graph_point(sample_input, graph1)
+ graph1_point_dx= self.input_to_graph_point(sample_input + width_scale_factor * dx, graph1)
+ graph2_point = self.input_to_graph_point(sample_input, graph2)
+
+ points = VGroup(*list(map(VectorizedPoint, [
+ graph1_point,
+ graph1_point_dx,
+ graph2_point
+ ])))
+
+ rect = Rectangle()
+ rect.replace(points, stretch=True)
+ if graph1_point[1] < self.graph_origin[1] and show_signed_area:
+ fill_color = invert_color(color)
+ else:
+ fill_color = color
+ rect.set_fill(fill_color, opacity=fill_opacity)
+ rect.set_stroke(stroke_color, width=stroke_width)
+ rectangles.add(rect)
+ return rectangles
+
+ def bounded_riemann_rectangles_y(
+ self,
+ graph1,
+ graph2,
+ y_min=None,
+ y_max=None,
+ dy=0.01,
+ input_sample_type="center",
+ stroke_width=1,
+ stroke_color=BLACK,
+ fill_opacity=1,
+ start_color=None,
+ end_color=None,
+ show_signed_area=True,
+ width_scale_factor=1.001
+ ):
+ y_min = y_min if y_min is not None else self.y_min
+ y_max = y_max if y_max is not None else self.y_max
+ if start_color is None:
+ start_color = self.default_riemann_start_color
+ if end_color is None:
+ end_color = self.default_riemann_end_color
+ rectangles = VGroup()
+ y_range = np.arange(y_min, y_max, dy)
+ colors = color_gradient([start_color, end_color], len(y_range))
+ for y, color in zip(y_range, colors):
+ if input_sample_type == "left":
+ sample_input = y
+ elif input_sample_type == "right":
+ sample_input = y + dy
+ elif input_sample_type == "center":
+ sample_input = y + 0.5 * dy
+ else:
+ raise Exception("Invalid input sample type")
+ graph1_point = self.coords_to_point(
+ graph1(sample_input),sample_input
+ )
+ dy_input=sample_input + width_scale_factor * dy
+ graph1_point_dy= self.coords_to_point(
+ graph1(dy_input),dy_input
+ )
+ graph2_point = self.coords_to_point(
+ graph2(sample_input),sample_input
+ )
+
+ points = VGroup(*list(map(VectorizedPoint, [
+ graph1_point,
+ graph1_point_dy,
+ graph2_point
+ ])))
+
+ rect = Rectangle()
+ rect.replace(points, stretch=True)
+ if graph1_point[1] < self.graph_origin[1] and show_signed_area:
+ fill_color = invert_color(color)
+ else:
+ fill_color = color
+ rect.set_fill(fill_color, opacity=fill_opacity)
+ rect.set_stroke(stroke_color, width=stroke_width)
+ rectangles.add(rect)
+ return rectangles
+
+
+#uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.gif
new file mode 100644
index 0000000..b0620e5
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.py
new file mode 100644
index 0000000..46134a7
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's-theorem/file4_curvy_region.py
@@ -0,0 +1,102 @@
+from manimlib.imports import *
+
+class CurvyRegion(GraphScene):
+ CONFIG = {
+ "x_min": 0,
+ "x_max": 8,
+ "y_min": 0,
+ "y_max": 6,
+ "graph_origin": ORIGIN+4.5*LEFT+3*DOWN,
+ "x_labeled_nums": np.arange(0, 9,2),
+ "y_labeled_nums": np.arange(0, 7,2),
+ "x_axis_width": 6,
+ "y_axis_height": 6,
+ }
+
+ def construct(self):
+ XD = self.x_axis_width/(self.x_max- self.x_min)
+ YD = self.y_axis_height/(self.y_max- self.y_min)
+ self.X=XD*RIGHT ;self.Y=YD*UP
+
+ sin_curve_points=[self.graph_origin+(2+.5*np.sin(2*y),y,0)
+ for y in np.arange(1,5,.005)]
+
+ cos_curve_points=[self.graph_origin+(
+ 5+.5*np.cos(2*y),y,0)
+ for y in np.arange(1,5,.005)]
+ cos_curve_points.reverse()
+
+ region=Polygon(
+ *sin_curve_points+cos_curve_points,
+ color=YELLOW,
+ stroke_width=1,
+ fill_color=BLUE_E,
+ fill_opacity=.75
+ )
+
+ line=Line((1,0,0),(1,6,0),color=RED)
+ line.move_to(self.graph_origin+2.5*self.X,DOWN)
+ self.line=line
+ self.setup_axes(animate = False)
+
+ self.add(region)
+ self.wait()
+ self.first_y_int_scene()
+ self.try_x_first_scene()
+
+
+ def first_y_int_scene(self):
+ talk=TextMobject(r"For doing the $y$ integration\\ first we need to set\\ proper $y$ limts").to_corner(UR,buff=LARGE_BUFF)
+ problem=TextMobject(r"But here we get\\ more than two $y$ values\\ for a single $x$ value" ).to_corner(UR,buff=LARGE_BUFF)
+ int_y=TextMobject("$$\\int_?^? dy$$").next_to(problem,DOWN,buff=.5)
+
+ self.play(Write(talk))
+ self.play(FadeIn(self.line))
+ self.wait(2)
+ self.play(ReplacementTransform(talk,problem))
+ self.play(
+ ApplyMethod(self.line.shift,3.7*self.X),
+ run_time=4
+ )
+ self.wait()
+ self.play(Write(int_y))
+ self.wait(3)
+ self.play(FadeOut(VGroup(problem,int_y,self.line)))
+
+ def try_x_first_scene(self):
+ try_text=TextMobject(r"But if we try to integrate\\ along $x$ first ...." ).to_corner(UR,buff=LARGE_BUFF)
+ good_limits=TextMobject(r"For one $y$ value we get\\ only \textbf{two} $x$ values $\dots$").to_corner(UR,buff=LARGE_BUFF)
+ limit_values= TextMobject(r"one Lower limit\\ one Upper limit ").next_to(good_limits,DOWN,buff=.5)
+ int_x=TextMobject("$$\\int_{f(y)}^{g(y)} dx$$").next_to(limit_values,DOWN)
+
+ self.setup_line()
+ self.play(Write(try_text))
+ self.play(FadeIn(self.line))
+ self.wait()
+ self.play(ReplacementTransform(try_text,good_limits))
+ self.wait()
+ self.play(
+ ApplyMethod(self.line.shift,3*self.Y),
+ run_time=4
+ )
+ self.play(Write(limit_values))
+ self.wait()
+ self.show_functions()
+ self.play(Write(int_x))
+ self.wait(3)
+
+ def setup_line(self):
+ line=self.line.rotate(PI/2)
+ line.move_to(self.graph_origin+.5*self.X+1.5*self.Y,LEFT)
+ self.line=line
+
+ def show_functions(self):
+ fy=TextMobject("$$f(y)$$")
+ gy=TextMobject("$$g(y)$$")
+ fy.move_to(self.graph_origin+2*self.X+3.3*self.Y)
+ gy.move_to(self.graph_origin+7*self.X+2*self.Y)
+ self.play(FadeIn(VGroup(fy,gy)))
+
+
+ #uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif
deleted file mode 100644
index ac13f21..0000000
--- a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif
+++ /dev/null
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/README.md
new file mode 100644
index 0000000..aa8c7f8
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/README.md
@@ -0,0 +1,9 @@
+**file1_grad_of_scalar_function**
+![file1_grad_of_scalar_function](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.gif)
+
+**file2_line_int_independent_of_path**
+![file2_line_int_independent_of_path](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.gif)
+
+**file3_line_int_example**
+![file3_line_int_example](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.gif)
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.gif
new file mode 100644
index 0000000..5a6e102
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.py
new file mode 100644
index 0000000..c9f479c
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file1_grad_of_scalar_function.py
@@ -0,0 +1,308 @@
+from manimlib.imports import *
+
+class GradOfScalar(ThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": -3,
+ "x_max": 3,
+ "y_min": -3,
+ "y_max": 3,
+ "z_min": 0,
+ "z_max": 3,
+ "a":-3 ,"b": 3, "c":-3 , "d":3,
+ "axes_shift": ORIGIN+IN,
+ "x_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "y_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "z_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "num_axis_pieces": 1,
+ },
+ "default_graph_style": {
+ "stroke_width": 2,
+ "stroke_color": WHITE,
+ },
+ "default_vector_field_config": {
+ "delta_x": 1,
+ "delta_y": 1,
+ "x_min": -3,
+ "x_max": 3,
+ "y_min": -3,
+ "y_max": 3,
+ "min_magnitude": 0,
+ "max_magnitude": 2,
+ "colors": [TEAL,GREEN,GREEN,GREEN,YELLOW,RED],
+ "length_func": lambda norm : norm*np.exp(-.38*norm)/2,
+ "opacity": 1.0,
+ "vector_config": {
+ "stroke_width":8
+ },
+ },
+ "default_surface_config": {
+ "fill_opacity": 0.5,
+ "checkerboard_colors": [BLUE_E],
+ "stroke_width": .5,
+ "stroke_color": WHITE,
+ "stroke_opacity": 0.75,
+ },
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+ axes=self.axes
+
+ self.set_camera_orientation(distance=35,
+ phi=70 * DEGREES,
+ theta=-135 * DEGREES,
+ )
+
+ scalar_fn_text=TexMobject("f(x,y,z)=","xy").set_color(BLUE)
+ scalar_fn_text.to_corner(UR,buff=.6)
+
+ operator=TexMobject("\\vec\\nabla").next_to(
+ scalar_fn_text,LEFT,buff=.2
+ ).set_color(GOLD)
+ grad_text=TexMobject(r"\dfrac{\partial f}{\partial x} \hat i+\dfrac{\partial f}{\partial y} \hat j+\dfrac{\partial f}{\partial z} \hat k").set_color(GOLD)
+ grad_text.next_to(scalar_fn_text,DOWN).scale(.9)
+
+ VGroup(grad_text[0][1],grad_text[0][9],grad_text[0][17]).set_color(BLUE)
+ VGroup(grad_text[0][5:8],grad_text[0][13:16],grad_text[0][21:23]).set_color(WHITE)
+
+ vector_field_text=TexMobject("\\vec F=y\hat i+x\hat j").set_color_by_gradient(*self.default_vector_field_config["colors"])
+ vector_field_text.next_to(scalar_fn_text,DOWN)
+
+
+ #always generate the scalar field first
+ s_field1=self.get_scalar_field(
+ func= lambda u ,v : u*v/7
+ )
+ v_field1=self.get_vector_field(
+ lambda v: np.array([
+ v[1],
+ v[0],
+ 0,
+ ]),
+ on_surface=True,
+ )
+
+ self.add_fixed_in_frame_mobjects(scalar_fn_text)
+
+ self.begin_ambient_camera_rotation(rate=.2)
+ self.play(Write(s_field1))
+ self.wait(1)
+ self.stop_ambient_camera_rotation()
+
+ self.add_fixed_in_frame_mobjects(operator)
+ self.play(Write(operator),FadeOut(scalar_fn_text[1]))
+ self.add_fixed_in_frame_mobjects(grad_text)
+ self.play(Write(grad_text))
+ self.wait(2)
+
+ self.play(FadeOut(grad_text))
+ self.add_fixed_in_frame_mobjects(vector_field_text)
+ show_vec_field=[
+ FadeIn(v_field1),
+ Write(vector_field_text),
+ ]
+
+ self.begin_ambient_camera_rotation(rate=.2)
+ self.move_camera(
+ # distance=20,
+ phi=60 * DEGREES,
+ added_anims=show_vec_field,
+ run_time=4.5
+ )
+
+ self.wait(2)
+ self.stop_ambient_camera_rotation()
+
+ fadeout= [FadeOut(s_field1)]
+ self.move_camera(
+ # distance=20,
+ phi=0 * DEGREES,
+ theta=-90 * DEGREES,
+ added_anims=fadeout,
+ run_time=2
+ )
+ self.wait(2)
+
+
+
+
+
+ def get_scalar_field(self,func,**kwargs):
+ surface= self.get_surface(
+ lambda x , y:
+ func(x,y),
+ )
+
+ self.surface_points=self.get_points(func)
+ return surface
+
+ def get_points(self,func):
+ axes=self.axes
+ dn=.5
+ x_vals=np.arange(axes.a,axes.b,dn)
+ y_vals=np.arange(axes.c,axes.d,dn)
+ points=[]
+ for x_val in x_vals:
+ for y_val in y_vals:
+ points+=[axes.c2p(x_val,y_val,func(x_val,y_val)+.05)]
+ return points
+
+ def get_vector_field(self,func,on_surface=True,**kwargs):
+ config = dict()
+ config.update(self.default_vector_field_config)
+ config.update(kwargs)
+ vector_field= VectorField(func,**config)
+ self.vector_field=vector_field
+
+ if on_surface:
+ vector_field=self.get_vectors_on_surface()
+
+ return vector_field
+
+
+
+ def get_vectors_on_surface(self):
+ config = dict()
+ config.update(self.default_vector_field_config["vector_config"])
+ vectors_on_surface = VGroup(*[
+ self.vector_field.get_vector(point,**config)
+ for point in self.surface_points
+ ])
+
+ return vectors_on_surface
+
+
+ def get_surface(self, func, **kwargs):
+ axes=self.axes
+ config = {
+ "u_min": axes.a,
+ "u_max": axes.b,
+ "v_min": axes.c,
+ "v_max": axes.d,
+ "resolution": (
+ 2*(axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,
+ (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,
+ ),
+ }
+
+ config.update(self.default_surface_config)
+ config.update(kwargs)
+ return ParametricSurface(
+ lambda x,y : axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config
+ )
+
+
+
+#-------------------------------------------------------
+ #customize 3D axes
+ 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)
+ self.axes=axes
+
+ 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, LEFT,
+ about_point=axes.c2p(0, 0, 0),
+ )
+ axes.y_axis.rotate(
+ 90 * DEGREES, UP,
+ about_point=axes.c2p(0, 0, 0),
+ )
+
+ return axes
+
+
+ def setup_axes(self):
+ axes = self.get_three_d_axes(include_labels=True)
+ axes.scale(1)
+ # axes.center()
+ axes.shift(axes.axes_shift)
+
+ self.add(axes)
+ self.axes = axes
+
+ def add_axes_numbers(self, axes):
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+ tex_vals_x = [
+
+ ("1", axes.b),
+ ("-1", axes.a),
+ ]
+ tex_vals_y=[
+
+ ("1", axes.d)
+ ]
+ x_labels = VGroup()
+ y_labels = VGroup()
+ for tex, val in tex_vals_x:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(x_axis.n2p(val), DOWN)
+ # label.rotate(180 * DEGREES)
+ x_labels.add(label)
+ x_axis.add(x_labels)
+ x_axis.numbers = x_labels
+
+ for tex, val in tex_vals_y:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(y_axis.n2p(val), LEFT)
+ label.rotate(90 * DEGREES)
+ y_labels.add(label)
+
+ y_axis.add(y_labels)
+ y_axis.numbers = y_labels
+
+ 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
+
+ y_label = TextMobject("y")
+ y_label.rotate(90 * DEGREES, OUT)
+ y_label.next_to(axes.y_axis.get_end(), UP)
+ axes.y_axis.label = y_label
+
+ z_label = TextMobject("z")
+ z_label.rotate(90 * DEGREES, RIGHT)
+ z_label.next_to(axes.z_axis.get_zenith(), LEFT)
+ axes.z_axis.label = z_label
+ for axis in axes:
+ axis.add(axis.label)
+ return axes
+
+
+
+ #uploaded by Somnath Pandit. FSF2020_Fundamental_Theorem_of_Line_Integrals
+
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.gif
new file mode 100644
index 0000000..29c6d02
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.py
new file mode 100644
index 0000000..b9597b6
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file2_line_int_independent_of_path.py
@@ -0,0 +1,174 @@
+from manimlib.imports import *
+
+
+class LineIntegration(GraphScene):
+ CONFIG = {
+ "x_min" : -5,
+ "x_max" : 5,
+ "y_min" : -5,
+ "y_max" : 5,
+ "axes_color":BLACK,
+ "graph_origin": ORIGIN+1.2*DOWN,
+ "x_axis_width": 10,
+ "y_axis_height": 10 ,
+ "x_axis_label": "",
+ "y_axis_label": "",
+ "x_tick_frequency": 1,
+ "y_tick_frequency": 1,
+ "default_vector_field_config": {
+ "delta_x": .6,
+ "delta_y": .6,
+ "min_magnitude": 0,
+ "max_magnitude": .5,
+ "colors": [GREEN,BLUE,BLUE,TEAL],
+ "length_func": lambda norm : .45*sigmoid(norm),
+ "opacity": .75,
+ "vector_config": {
+ "stroke_width":1.5
+ },
+ },
+
+ "a": .45,"b": 2,
+ "path_color": PURPLE
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+ self.X=X ;self.Y=Y
+
+ self.setup_axes(animate=False)
+
+
+
+
+ vector_field=self.get_vector_field(
+ lambda v: np.array([
+ v[1]-self.graph_origin[1],
+ v[0]-self.graph_origin[0],
+ 0,
+ ])
+ )
+ vector_field_text=TexMobject(
+ "\\vec F(x,y)","=y\hat i+x\hat j",
+ stroke_width=1.5
+ ).to_edge(TOP,buff=.2)
+
+ vector_field_text[0][0:2].set_color(TEAL)
+
+ grad_f=TexMobject(
+ "\\vec\\nabla f(x,y)",
+ stroke_width=1.5
+ )
+ grad_f[0][2].set_color(LIGHT_BROWN)
+ grad_f.move_to(vector_field_text[0])
+
+ self.add(vector_field,)
+ self.play(Write(vector_field_text))
+ self.wait()
+ self.play(
+ ReplacementTransform(
+ vector_field_text[0],grad_f
+ )
+ )
+ self.get_endpoints_of_curve()
+ self.wait(.6)
+ vector_field.set_fill(opacity=.4)
+ self.show_line_integral()
+ self.wait(2)
+
+
+
+
+
+ def get_vector_field(self,func,**kwargs):
+ config = dict()
+ config.update(self.default_vector_field_config)
+ config.update(kwargs)
+ vector_field= VectorField(func,**config)
+
+ self.vector_field= vector_field
+
+ return vector_field
+
+
+
+ def get_endpoints_of_curve(self):
+ points=[[-3,0],[2,2]]
+ point_labels= ["P_i","P_f"]
+ for point,label in zip(points,point_labels):
+ dot=Dot(self.coords_to_point(*point)).set_color(RED)
+ dot_label=TexMobject(label)
+ dot_label.next_to(dot,DR,buff=.2)
+ self.play(FadeIn(VGroup(dot,dot_label)))
+ self.wait(.2)
+
+ self.end_points=points
+
+ def show_line_integral(self):
+ int_text=TexMobject(
+ r"\int_{P_i}^{P_f}\vec F \cdot d\vec r",
+ stroke_width=1.5,
+ ).scale(1.2)
+ int_text[0][0].set_color(self.path_color)
+ int_text[0][5:7].set_color(TEAL)
+ int_text.to_edge(RIGHT+UP,buff=1)
+
+ int_value= TexMobject(r"=f(P_i)-f(P_f)",
+ stroke_width=1.5
+ ).next_to(int_text,DOWN)
+ VGroup(int_value[0][1],
+ int_value[0][7]
+ ).set_color(LIGHT_BROWN)
+
+ path_indepent_text=TextMobject(
+ r"Value of the Line Integral is\\ independent of Path",color=GOLD,stroke_width=2,).to_corner(DR,buff=1)
+
+ path_indepent_text[0][-4:].set_color(self.path_color)
+
+
+ self.play(Write(VGroup(
+ int_text,int_value
+ )),
+ run_time=2
+ )
+ self.wait(1.5)
+
+
+ self.show_path([[0,1],[-1,2],[1,3]])
+ self.play(Indicate(int_value))
+ self.play(Uncreate(self.path))
+
+ self.show_path([[0,1]])
+ self.play(Indicate(int_value))
+ self.play(Uncreate(self.path))
+
+ self.show_path([[-1,1],[-1,-2],[-5,0],[-2,3.5],[1,1]])
+ self.play(Indicate(int_value),run_time=2)
+ self.wait(.6)
+
+ self.play(Write(path_indepent_text))
+
+
+
+ def show_path(self,points):
+ points=[self.end_points[0]]+points+[self.end_points[1]]
+
+ path= VMobject()
+ path.set_points_smoothly([
+ self.coords_to_point(*point)
+ for point in points
+ ])
+ path.set_color(self.path_color)
+ self.play(ShowCreation(path),run_time=1.5)
+
+ self.path=path
+
+
+
+
+
+#uploaded by Somnath Pandit. FSF2020_Fundamental_Theorem_of_Line_Integrals
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.gif
new file mode 100644
index 0000000..20ed081
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.py
new file mode 100644
index 0000000..71506a3
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fundamental-theorem-of-line-integral/file3_line_int_example.py
@@ -0,0 +1,149 @@
+from manimlib.imports import *
+
+
+class LineIntegration(GraphScene):
+ CONFIG = {
+ "x_min" : -1,
+ "x_max" : 2,
+ "y_min" : -1,
+ "y_max" : 2,
+ "graph_origin": ORIGIN+3*LEFT+1.5*DOWN,
+ "x_axis_width": 10,
+ "y_axis_height": 10 ,
+ "x_tick_frequency": 1,
+ "y_tick_frequency": 1,
+ "default_vector_field_config": {
+ "delta_x": .5,
+ "delta_y": .5,
+ "min_magnitude": 0,
+ "max_magnitude": .5,
+ "colors": [GREEN,BLUE,BLUE,TEAL],
+ "length_func": lambda norm : .4*sigmoid(norm),
+ "opacity": .75,
+ "vector_config": {
+ "stroke_width":2
+ },
+ },
+
+ "a": .45,"b": 2,
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+ self.X=X ;self.Y=Y
+
+ self.setup_axes(animate=False)
+
+
+
+
+ vector_field=self.get_vector_field(
+ lambda v: np.array([
+ v[1]-self.graph_origin[1],
+ v[0]-self.graph_origin[0],
+ 0,
+ ])
+ )
+ vector_field_text=TexMobject(
+ "\\vec F=y\hat i+x\hat j",
+ stroke_width=2
+ ).to_corner(UR,buff=.75).scale(1.2)
+
+ vector_field_text[0][0:3].set_color(TEAL),
+ self.add(vector_field,)
+ self.play(Write(vector_field_text))
+ self.wait()
+ self.get_endpoints_of_curve()
+ self.wait(.6)
+ self.play(
+ vector_field_text.shift,5*LEFT,
+
+ )
+ vector_field.set_fill(opacity=.2)
+ self.show_line_integral()
+ self.wait(2)
+
+
+
+
+
+ def get_vector_field(self,func,**kwargs):
+ config = dict()
+ config.update(self.default_vector_field_config)
+ config.update(kwargs)
+ vector_field= VectorField(func,**config)
+
+ self.vector_field= vector_field
+
+ return vector_field
+
+
+
+ def get_endpoints_of_curve(self):
+ points=[[1,1],[0,0]]
+ point_labels= ["(1,1)","(0,0)"]
+ for point,label in zip(points,point_labels):
+ dot=Dot(self.coords_to_point(*point)).set_color(RED)
+ dot_label=TexMobject(label)
+ dot_label.next_to(dot,DR)
+ self.add(dot,dot_label)
+ self.end_points=points
+
+ def show_line_integral(self):
+ int_text=TexMobject(
+ "\\int_\\text{\\textbf{path}}\\vec F \\cdot d\\vec r= 1",
+ color=BLUE,
+ stroke_width=1.5
+ ).scale(1.2)
+ int_text[0][0].set_color(RED_C)
+ int_text[0][5:7].set_color(TEAL)
+ int_text.to_edge(RIGHT+UP,buff=1)
+
+ close_int=TexMobject("O").set_color(RED).scale(1.3)
+ close_int.move_to(int_text[0][0],OUT)
+ close_int_val=TexMobject("0",color=BLUE).scale(1.4)
+ close_int_val.move_to(int_text[0][-1],OUT)
+
+ self.play(Write(int_text))
+
+
+ self.show_method([[0,1]])
+ self.play(Indicate(int_text))
+ self.wait()
+
+ self.show_method([[1,0]])
+ self.play(Indicate(int_text))
+ self.wait()
+ self.remove(int_text[0][-1])
+ self.add(close_int)
+
+ for i in range(2):
+ self.play(self.paths[i].rotate,PI)
+ self.play(Indicate(close_int))
+ self.play(Write(close_int_val))
+ self.wait()
+
+
+ def show_method(self,points):
+ points=points+self.end_points
+ paths=[]
+ for i in range(-1,len(points)-2):
+ path=Arrow(
+ self.coords_to_point(*points[i]),
+ self.coords_to_point(*points[i+1]),
+ buff=0
+ ).set_color(BLUE)
+ paths+=VGroup(path)
+ self.play(GrowArrow(path),run_time=1.5)
+
+ self.paths=paths
+
+
+
+
+
+#uploaded by Somnath Pandit. FSF2020_Fundamental_Theorem_of_Line_Integrals
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/README.md b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/README.md
new file mode 100644
index 0000000..17077b6
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/README.md
@@ -0,0 +1,14 @@
+**file1_scalar_line_int_as_sum**
+![file1_scalar_line_int_as_sum](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.gif)
+
+**file2_scalar_line_integral**
+![file2_scalar_line_integral](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.gif)
+
+
+**file3_vector_line_int_as_sum**
+![file3_vector_line_int_as_sum](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.gif)
+
+
+
+**file4_helix**
+![file4_helix](https://github.com/panditsomnath10016git/FSF-mathematics-python-code-archive/blob/master/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.gif)
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.gif
new file mode 100644
index 0000000..1984b08
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.py
new file mode 100644
index 0000000..e3f3574
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file1_scalar_line_int_as_sum.py
@@ -0,0 +1,227 @@
+from manimlib.imports import *
+
+
+class LineIntegrationAsSum(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 10,
+ "y_min" : 0,
+ "y_max" : 6,
+ "graph_origin": ORIGIN+5*LEFT+3*DOWN,
+ "x_axis_width": 10,
+ "y_axis_height": 6 ,
+ "x_tick_frequency": 2,
+ "y_tick_frequency": 2,
+ "Func":lambda x : 1+x**1.3*np.exp(-.12*(x-2)**2)*np.sin(x/4),
+ "a": 1 ,"b": 9, "n": 15,
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+ self.X=X ;self.Y=Y
+
+ self.setup_axes(animate=False)
+
+ curve=self.get_graph(
+ self.Func,
+ x_min=self.a,
+ x_max=self.b,
+ )
+ curve.set_color([BLACK,BLUE,BLUE,BLUE,BLACK])
+ curve_label= self.get_graph_label(
+ curve,
+ label="\\text{path of intgration}",
+ x_val=4,
+ direction=UR,
+ buff=.6,
+ color=BLUE
+ )
+ self.curve=curve
+ self.curve_label=curve_label
+
+ self.play(ShowCreation(VGroup(curve,curve_label)))
+ self.wait(.6)
+ self.break_in_arcs()
+ self.show_the_sum()
+ self.construct_equation()
+ self.wait(2)
+
+
+
+ def break_in_arcs(self):
+
+ self.write_about_breaking()
+
+ dl=0.8
+ self.get_breakers(dl)
+ self.wait(2)
+ self.play(FadeOut(self.upto_break_text))
+ self.dl=dl
+
+ def write_about_breaking(self):
+ breaking_text=TextMobject("\\texttt{..broken}"," into small", "subarcs")
+ breaking_text.set_color_by_tex_to_color_map({
+ "broken":RED,"subarcs": BLUE
+ })
+ breaking_text.next_to(self.curve_label,DOWN)
+ breaking_text.align_to(self.curve_label,LEFT)
+ self.play(
+ Write(breaking_text)
+ )
+
+ self.upto_break_text=VGroup(
+ self.curve_label,
+ breaking_text,
+ )
+
+ def get_breakers(self,dl):
+ point=self.a
+ points=[]
+ while point<(self.b-dl) :
+ start=point
+ end=point+dl
+ points += [end]
+ breaker=Line(
+ self.input_to_graph_point(start,self.curve),
+ self.input_to_graph_point(end,self.curve),
+ stroke_width=2,
+ color=RED,
+ )
+ breaker.rotate(PI/2).scale(.5)
+
+ point=end
+ self.play(FadeIn(breaker),run_time=.2)
+ # self.add(breaker)
+
+ del points[-1]
+ self.points=points
+
+
+ def show_the_sum(self):
+ at_any_points_text=TextMobject("At any ","point", "in each ", "subarc")
+ at_any_points_text.set_color_by_tex_to_color_map({
+ "point":YELLOW , "subarc": BLUE
+ })
+ at_any_points_text.to_edge(TOP,buff=SMALL_BUFF)
+
+ evaluate_text=TextMobject("$f(x,y)$ ", "is evaluated").next_to(at_any_points_text,DOWN)
+ evaluate_text.set_color_by_tex("$f(x,y)$",ORANGE)
+
+ self.at_any_points_text=at_any_points_text
+ self.evaluate_text=evaluate_text
+
+
+ dots=[]
+ for point in self.points:
+
+ dot=Dot(
+ point=self.input_to_graph_point(point,self.curve),
+ radius= .7*DEFAULT_DOT_RADIUS,
+ stroke_width= 0,
+ fill_opacity= 1.0,
+ color= YELLOW,
+ )
+ dots+=[dot]
+
+ self.play(
+ Write(at_any_points_text),
+ FadeIn(VGroup(*dots)),run_time=1.5
+ )
+ self.wait()
+ self.position_of_point_irrelevent()
+ self.multiply_with_function(dots)
+
+
+
+ def multiply_with_function(self,dots):
+ index=-(len(self.points)//3)
+ dot=dots[index]
+
+
+ multiply_text=TexMobject("f(x_i,y_i)", "\\text{ is multiplied with }","\\Delta s_i")
+ multiply_text.set_color_by_tex_to_color_map({
+ "f(x_i,y_i)":ORANGE , "\\Delta s_i": BLUE
+ })
+ multiply_text.to_edge(TOP,buff=MED_SMALL_BUFF)
+
+ point_coord=TextMobject("$(x_i,y_i)$",color=YELLOW)
+ point_coord.next_to(dot,DL,buff=.01).scale(.8)
+
+ func_val=TextMobject("$f(x_i,y_i)$",color=ORANGE)
+ func_val.next_to(dot,UR)
+
+ sum_up_text=TextMobject("and "," summed ", "for all i' s")
+ sum_up_text.set_color_by_tex("summed",PURPLE)
+ sum_up_text.next_to(multiply_text,DOWN)
+
+ dot.set_color(ORANGE).scale(1.2)
+
+ self.play(FadeIn(VGroup(
+ point_coord,dot
+ )))
+ self.play(Write(self.evaluate_text))
+ self.play(Write(func_val))
+ self.play(FadeIn(VGroup(*[
+ dot.set_color(ORANGE).scale(1.4)
+ for dot in dots ]
+ )))
+ self.wait(2)
+ self.remove(point_coord)
+ self.get_ds(dots,index)
+ self.play(GrowFromCenter(self.ds_brace_group))
+ self.wait(2)
+ self.play(FadeOut(VGroup(
+ self.ds_brace,
+ self.at_any_points_text,
+ self.evaluate_text
+ )))
+ self.play(Write(multiply_text))
+ self.play(ApplyMethod(
+ self.ds_brace_label.next_to,
+ func_val, RIGHT,buff=.2
+ ))
+ self.play(Write(sum_up_text))
+
+ self.func_val=func_val
+ self.sum_text_group=VGroup(multiply_text,sum_up_text)
+
+ def position_of_point_irrelevent(self):
+ pass
+
+
+
+ def get_ds(self,dots,index):
+ p1= dots[index]
+ p2= dots[index+1]
+ ds_brace=Brace(VGroup(p1,p2),DL)
+ ds_brace.move_to(p1,UR)
+ ds_brace_label=ds_brace.get_text("$\Delta s_i$", buff = .05)
+ ds_brace_label.set_color(BLUE)
+ self.ds_brace=ds_brace
+ self.ds_brace_label=ds_brace_label
+ self.ds_brace_group=VGroup(ds_brace,ds_brace_label)
+
+
+ def construct_equation(self):
+ sum_eqn=TextMobject("$$\\sum_i^{ } $$").set_color(PURPLE)
+ sum_eqn.move_to(self.graph_origin+7*self.X+4*self.Y)
+
+ line_integral_text=TextMobject("The Value of the line integral is").next_to(self.sum_text_group,IN)
+ approx=TextMobject("$\\approx$",color=RED).next_to(sum_eqn,LEFT)
+ multipled=VGroup(self.func_val,self.ds_brace_label)
+ self.play(FadeIn(sum_eqn))
+ self.play(ApplyMethod(
+ multipled.next_to,sum_eqn,RIGHT
+ ))
+ self.wait()
+ self.play(FadeOut(self.sum_text_group))
+ self.play(Write(line_integral_text))
+ self.play(FadeIn(approx))
+
+
+
+#uploaded by Somnath Pandit.FSF2020_Line Integrals
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.gif
new file mode 100644
index 0000000..71c97d6
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.py
new file mode 100644
index 0000000..996ead1
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file2_scalar_line_integral.py
@@ -0,0 +1,421 @@
+from manimlib.imports import *
+
+class LineIntegrationProcess(SpecialThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": -4,
+ "x_max": 4,
+ "y_min": 0,
+ "y_max": 4,
+ "z_min": 0,
+ "z_max": 4,
+ "a":-3 ,"b": 3, "c":0 , "d":3.5,
+ "axes_shift":3*IN,
+ "x_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "y_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "z_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ "num_axis_pieces": 1,
+ },
+ "default_graph_style": {
+ "stroke_width": 2,
+ "stroke_color": WHITE,
+ },
+ "default_surface_config": {
+ "fill_opacity": 0.5,
+ "checkerboard_colors": [LIGHT_GREY],
+ "stroke_width": 0.2,
+ "stroke_color": WHITE,
+ "stroke_opacity": 0.75,
+ },
+ "Func": lambda x,y: 1+x**2*y/15
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+ axes=self.axes
+
+ self.set_camera_orientation(distance=35,
+ phi=65 * DEGREES,
+ theta=-65 * DEGREES,
+ )
+
+ fn_text=TextMobject("$z=2+x^2y$").set_color(BLUE)
+ fn_text.to_corner(UR,buff=.8).shift(DOWN)
+
+ #get the surface
+ surface= self.get_surface(
+ lambda x , y:
+ self.Func(x,y)
+ )
+ surface.set_style(
+ fill_opacity=0.5,
+ fill_color=BLUE_D,
+ stroke_width=0.5,
+ stroke_color=WHITE,
+ )
+
+
+ # self.play(Write(surface))
+ self.add_fixed_in_frame_mobjects(fn_text)
+ self.play(Write(surface),Write(fn_text))
+ self.get_line_of_int()
+ self.begin_ambient_camera_rotation(rate=-0.035)
+ self.get_field_values_on_line()
+ self.wait(1.5)
+ self.area=self.get_area()
+ area_text=TextMobject("Line"," Integral in the",r" scalar field\\"," means this" ,"area")
+ area_text.set_color_by_tex_to_color_map({
+ "Line": PINK, "scalar":BLUE, "area":TEAL_A
+ })
+ area_text.to_edge(TOP,buff=MED_SMALL_BUFF)
+
+ self.remove(self.values_on_line_text)
+ self.add_fixed_in_frame_mobjects(area_text)
+ self.play(Write(area_text))
+ self.play(Write(self.area),run_time=2)
+ self.play(FadeOut(VGroup(surface,fn_text)))
+ self.wait()
+
+ self.stop_ambient_camera_rotation()
+ # self.get_lines()
+
+ self.remove(axes,surface)
+ self.trasform_to_graphs()
+ self.wait(2)
+
+
+
+
+ def get_line_of_int(self):
+ line_of_int_text=TextMobject(r"Line of integration is\\","$\\vec r(t)=\cos(t)\hat x+\sin(t)\hat y$")
+ line_of_int_text[1].set_color(PINK)
+ line_of_int_text.to_edge(TOP,buff=SMALL_BUFF)
+
+
+ line_of_int=(self.get_curve(
+ self.Func,on_surface=False
+ ))
+ line_of_int.set_style(
+ stroke_width=5,
+ stroke_color=PINK,
+ )
+
+ self.add_fixed_in_frame_mobjects(line_of_int_text)
+ self.play(Write(line_of_int_text))
+ self.wait()
+ self.play(ShowCreation(line_of_int),run_time=3)
+ # self.add(line_of_int)
+
+ self.line_of_int=line_of_int
+ self.line_of_int_text=line_of_int_text
+
+ def get_field_values_on_line(self):
+ self.remove(self.line_of_int_text)
+
+ values_on_line_text=TextMobject("Values"," of"," function","on the ","line")
+ values_on_line_text.set_color_by_tex_to_color_map({
+ "Values":YELLOW, "function":BLUE,"line":PINK
+ })
+ values_on_line_text.to_edge(TOP,buff=SMALL_BUFF)
+
+ values_on_surface=(self.get_curve(
+ self.Func,on_surface=True
+ ))
+ values_on_surface.set_style(
+ stroke_width=5,
+ stroke_color=YELLOW,
+ )
+
+ self.add_fixed_in_frame_mobjects(values_on_line_text)
+ self.play(Write(values_on_line_text))
+ # self.wait()
+ self.play(ShowCreation(values_on_surface),run_time=3)
+ # self.add(values_on_surface)
+
+ self.values_on_surface=values_on_surface
+ self.values_on_line_text=values_on_line_text
+
+
+ def trasform_to_graphs(self):
+ on_surface_graph=(self.get_graph(
+ self.Func,on_surface=True
+ ))
+ on_surface_graph.set_style(
+ stroke_width=5,
+ stroke_color=YELLOW,
+ )
+
+ line_graph=(self.get_graph(
+ self.Func,on_surface=False
+ ))
+ line_graph.set_style(
+ stroke_width=5,
+ stroke_color=PINK,
+ )
+
+ self.on_surface_graph=on_surface_graph
+ self.line_graph=line_graph
+ graph_area=self.get_area(graph=True)
+
+ into_graph=[
+ ReplacementTransform(
+ self.values_on_surface,
+ on_surface_graph
+ ),
+ ReplacementTransform(
+ self.line_of_int,
+ line_graph
+ ),
+ ReplacementTransform(
+ self.area,
+ graph_area
+ ),
+ ]
+
+ self.move_camera(
+ # distance=20,
+ phi=90 * DEGREES,
+ theta=-90 * DEGREES,
+ added_anims=into_graph,
+ run_time=2
+ )
+
+ def get_area(self,graph=False):
+ axes=self.axes
+ if graph:
+ on_surface=self.on_surface_graph
+ on_base=self.line_graph
+ else:
+ on_surface=self.values_on_surface
+ on_base=self.line_of_int
+ area =Polygon(
+ *[
+ on_surface.get_point_from_function(t)
+ for t in np.arange(0,PI,0.01)
+ ],
+ *[
+ on_base.get_point_from_function(t)
+ for t in np.arange(PI,0,-0.01)
+ ],
+ stroke_width=0,
+ fill_color=TEAL_A,
+ fill_opacity=.6,
+ )
+
+ return area
+
+ def get_curve(self,func,on_surface=False ,**kwargs):
+ config = dict()
+ config.update(self.default_graph_style)
+ config.update({
+ "t_min": 0,
+ "t_max": PI,
+ })
+ config.update(kwargs)
+ r=abs(self.axes.a)
+ curve=ParametricFunction(
+ lambda t: self.axes.c2p(
+ r*np.cos(t),
+ r*np.sin(t),
+ func(r*np.cos(t), r*np.sin(t))*bool(on_surface)
+ ),
+ **config,
+ )
+ return curve
+
+
+ def get_surface(self, func, **kwargs):
+ axes=self.axes
+ config = {
+ "u_min": axes.a-.2,
+ "u_max": axes.b+.2,
+ "v_min": axes.c-.1,
+ "v_max": axes.d,
+ "resolution": (
+ 2*(axes.y_max - axes.y_min) // axes.y_axis.tick_frequency,
+ (axes.x_max - axes.x_min) // axes.x_axis.tick_frequency,
+ ),
+ }
+
+ config.update(self.default_surface_config)
+ config.update(kwargs)
+ return ParametricSurface(
+ lambda x,y : axes.c2p(
+ x, y, func(x, y)
+ ),
+ **config
+ )
+
+ def get_graph(self,func,on_surface=False ,**kwargs):
+ config = dict()
+ config.update(self.default_graph_style)
+ config.update({
+ "t_min": 0,
+ "t_max": PI,
+ })
+ config.update(kwargs)
+ slice_curve=ParametricFunction(
+ lambda t: self.axes.c2p(
+ 4*np.cos(t),
+ 0,
+ 2+func(3*np.cos(t), 3*np.sin(t))*bool(on_surface)
+ ),
+ **config,
+ )
+ return slice_curve
+
+ def get_lines(self):
+ pass
+ axes = self.axes
+ labels=[axes.x_axis.n2p(axes.a), axes.x_axis.n2p(axes.b), axes.y_axis.n2p(axes.c),
+ axes.y_axis.n2p(axes.d)]
+
+
+ surface_corners=[]
+ for x,y,z in self.region_corners:
+ surface_corners.append([x,y,self.Func(x,y)])
+
+ lines=VGroup()
+ for start , end in zip(surface_corners,
+ self.region_corners):
+ lines.add(self.draw_lines(start,end,"PINK"))
+
+ for start , end in zip(labels,
+ self.region_corners):
+ # lines.add(self.draw_lines(start,end,"BLUE"))
+ # print (start,end)
+ pass
+ # self.play(ShowCreation(lines))
+ self.add(lines)
+
+
+ def draw_lines(self,start,end,color):
+ start=self.axes.c2p(*start)
+ end=self.axes.c2p(*end)
+ line=DashedLine(start,end,color=color)
+
+ return line
+
+ #customize 3D axes
+ def get_three_d_axes(self, include_labels=True, include_numbers=True, **kwargs):
+ config = dict(self.axes_config)
+ config.update(kwargs)
+ axes = ThreeDAxes(**config)
+ axes.set_stroke(width=2)
+ self.axes=axes
+
+ 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, LEFT,
+ 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(
+ lambda x, t: 0
+ )
+ '''input_plane.set_style(
+ fill_opacity=0.3,
+ fill_color=PINK,
+ stroke_width=.2,
+ stroke_color=WHITE,
+ )'''
+
+ axes.input_plane = input_plane
+
+ self.region_corners=[
+ input_plane.get_corner(pos) for pos in (DL,DR,UR,UL)]
+
+ return axes
+
+
+ def setup_axes(self):
+ axes = self.get_three_d_axes(include_labels=True)
+ axes.add(axes.input_plane)
+ axes.scale(1)
+ # axes.center()
+ axes.shift(axes.axes_shift)
+
+ self.add(axes)
+ self.axes = axes
+
+ def add_axes_numbers(self, axes):
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+ tex_vals_x = [
+
+ ("1", axes.b),
+ ("-1", axes.a),
+ ]
+ tex_vals_y=[
+
+ ("1", axes.d)
+ ]
+ x_labels = VGroup()
+ y_labels = VGroup()
+ for tex, val in tex_vals_x:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(x_axis.n2p(val), DOWN)
+ # label.rotate(180 * DEGREES)
+ x_labels.add(label)
+ x_axis.add(x_labels)
+ x_axis.numbers = x_labels
+
+ for tex, val in tex_vals_y:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(y_axis.n2p(val), LEFT)
+ label.rotate(90 * DEGREES)
+ y_labels.add(label)
+
+ y_axis.add(y_labels)
+ y_axis.numbers = y_labels
+
+ 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
+
+ y_label = TextMobject("y")
+ y_label.rotate(90 * DEGREES, OUT)
+ y_label.next_to(axes.y_axis.get_end(), UP)
+ axes.y_axis.label = y_label
+
+ z_label = TextMobject("z")
+ z_label.rotate(90 * DEGREES, RIGHT)
+ z_label.next_to(axes.z_axis.get_zenith(), LEFT)
+ axes.z_axis.label = z_label
+ for axis in axes:
+ axis.add(axis.label)
+ return axes
+
+
+
+ #uploaded by Somnath Pandit.FSF2020_Line_Integrals
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.gif
new file mode 100644
index 0000000..46b35bc
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.py
new file mode 100644
index 0000000..78294cc
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file3_vector_line_int_as_sum.py
@@ -0,0 +1,326 @@
+from manimlib.imports import *
+
+
+class LineIntegrationAsSum(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 10,
+ "y_min" : 0,
+ "y_max" : 6,
+ "graph_origin": ORIGIN+5*LEFT+3*DOWN,
+ "x_axis_width": 10,
+ "y_axis_height": 6 ,
+ "x_tick_frequency": 2,
+ "y_tick_frequency": 2,
+ "Func":lambda x : 1+x**1.3*np.exp(-.12*(x-2)**2)*np.sin(x/4),
+ "a": 1 ,"b": 9, "n": 15,
+ }
+
+ def construct(self):
+ X = RIGHT*self.x_axis_width/(self.x_max- self.x_min)
+ Y = UP*self.y_axis_height/(self.y_max- self.y_min)
+ self.X=X ;self.Y=Y
+
+ self.setup_axes(animate=False)
+
+
+ curve=self.get_graph(
+ self.Func,
+ x_min=self.a,
+ x_max=self.b,
+ )
+ curve.set_color([BLACK,BLUE,BLUE,BLUE,BLACK])
+ curve_label= self.get_graph_label(
+ curve,
+ label="\\text{path of intgration}",
+ x_val=4,
+ direction=UR,
+ buff=.6,
+ color=BLUE
+ )
+ self.curve=curve
+ self.curve_label=curve_label
+
+ self.get_vector_field()
+
+
+ self.play(ShowCreation(VGroup(curve,curve_label)))
+ self.wait(.6)
+ self.break_in_arcs()
+ self.show_the_sum()
+
+ self.wait(2)
+
+
+ def get_vector_field(self):
+ func = lambda v: np.array([
+ v[0], # x
+ -v[1], # y
+ 0 # z
+ ])
+ vector_field= VectorField(
+ func,
+ delta_x=1,
+ delta_y=1,
+ colors=[GREEN_A,GREEN_C],
+ length_func= lambda norm: .8*sigmoid(norm),
+ vector_config={
+ "stroke_width": 2
+ }
+ )
+
+ self.vector_field= vector_field
+
+
+ def break_in_arcs(self):
+
+ self.write_about_breaking()
+
+ dl=0.8
+ self.get_breakers(dl)
+ self.wait(2)
+ self.play(FadeOut(self.upto_break_text))
+ self.dl=dl
+
+ def write_about_breaking(self):
+ breaking_text=TextMobject("\\texttt{..broken}"," into small", "subarcs")
+ breaking_text.set_color_by_tex_to_color_map({
+ "broken":RED,"subarcs": BLUE
+ })
+ breaking_text.next_to(self.curve_label,DOWN)
+ breaking_text.align_to(self.curve_label,LEFT)
+ self.play(
+ Write(breaking_text)
+ )
+
+ self.upto_break_text=VGroup(
+ self.curve_label,
+ breaking_text,
+ )
+
+ def get_breakers(self,dl):
+ point=self.a
+ points=[]
+ while point<(self.b-dl) :
+ start=point
+ end=point+dl
+ points += [end]
+ breaker=Line(
+ self.input_to_graph_point(start,self.curve),
+ self.input_to_graph_point(end,self.curve),
+ stroke_width=2,
+ color=RED,
+ )
+ breaker.rotate(PI/2).scale(.5)
+
+ point=end
+ self.play(FadeIn(breaker),run_time=.2)
+ # self.add(breaker)
+
+ del points[-1]
+ self.points=points
+
+
+ def show_the_sum(self):
+ at_any_points_text=TextMobject("At any ","point", "in each ", "subarc")
+ at_any_points_text.set_color_by_tex_to_color_map({
+ "point":YELLOW , "subarc": BLUE
+ })
+ at_any_points_text.to_edge(TOP,buff=SMALL_BUFF)
+
+ evaluate_text=TextMobject("$\\vec F(x,y)$ ", "is evaluated").next_to(at_any_points_text,DOWN)
+ evaluate_text.set_color_by_tex("$\\vec F(x,y)$",ORANGE)
+
+ multiply_text=TextMobject("...is multiplied with ","$\\Delta s_i$")
+ multiply_text.set_color_by_tex("\\Delta s_i", BLUE)
+ multiply_text.next_to(at_any_points_text,DOWN)
+
+
+
+ self.at_any_points_text=at_any_points_text
+ self.evaluate_text=evaluate_text
+ self.multiply_text=multiply_text
+
+ dots=[]
+ for point in self.points:
+
+ dot=Dot(
+ point=self.input_to_graph_point(point,self.curve),
+ radius= .7*DEFAULT_DOT_RADIUS,
+ stroke_width= 0,
+ fill_opacity= 1.0,
+ color= YELLOW,
+ )
+ dots+=[dot]
+
+ self.play(
+ Write(at_any_points_text),
+ FadeIn(VGroup(*dots)),run_time=1.5
+ )
+ self.dots=dots
+
+ self.wait()
+ self.show_the_dot_product()
+ self.multiply_with_ds()
+ self.construct_equation()
+
+
+ def show_the_dot_product(self):
+ index=-(len(self.points)//3)
+ self.index=index
+
+ dot=self.dots[index]
+
+
+ dot_prod_text=TextMobject("Dot Product of", "$\\vec F(x_i,y_i)$", "and","$\\vec T(x_i,y_i)$")
+ dot_prod_text.set_color_by_tex_to_color_map({
+ "\\vec F(x_i,y_i)":ORANGE ,
+ "\\vec T(x_i,y_i)": "#DC75CD" ,
+ })
+ dot_prod_text.to_edge(TOP,buff=SMALL_BUFF)
+
+
+ point_coord=TextMobject("$(x_i,y_i)$",color=YELLOW)
+ point_coord.next_to(dot,DL,buff=.01).scale(.8)
+
+ func_val=TextMobject("$\\vec F(x_i,y_i)$",color=ORANGE)
+ func_val.next_to(dot,UR).scale(.8)
+
+ self.dot_prod_text=dot_prod_text
+ self.func_val=func_val
+
+ dot.set_color(ORANGE).scale(1.2)
+
+
+ self.play(FadeIn(VGroup(point_coord,dot)))
+ self.play(Write(self.evaluate_text))
+ self.wait(1)
+ self.play(FadeOut(self.vector_field))
+ self.get_vector_and_tangent()
+ self.dot_product()
+
+
+ self.wait(2)
+ self.remove(point_coord)
+
+
+ def get_vector_and_tangent(self):
+ dot=self.dots[self.index]
+ self.show_specific_vectors(dot)
+ self.play(Write(self.func_val))
+ self.wait(1)
+ self.show_tangent(dot)
+ self.play(FadeIn(VGroup(*[
+ dot.set_color(ORANGE).scale(1.4)
+ for dot in self.dots ]
+ )))
+
+
+ def show_specific_vectors(self,dots):
+ for dot in dots:
+ vector=self.vector_field.get_vector(dot.get_center())
+ vector.set_color(ORANGE)
+
+ self.play(Write(vector),run_time=.2)
+
+
+ def show_tangent(self,dot):
+ tangent_sym=TextMobject("$\\vec T(x_i,y_i)$",color="#DC75CD").scale(.8)
+ x=dot.get_center()
+ angle=self.angle_of_tangent(
+ self.point_to_coords(x)[0],
+ self.curve,
+ dx=0.01
+ )
+ vect = Vector().rotate(angle,about_point=x)
+ vect.set_color("#DC75CD")
+ tangent=vect.next_to(x,DR,buff=0)
+ tangent_sym.next_to(tangent,DOWN,buff=.1)
+ self.play(Write(VGroup(tangent,tangent_sym)))
+
+ self.tangent_sym=tangent_sym
+
+ def dot_product(self):
+
+ dot_sym=Dot().next_to(self.func_val,RIGHT)
+
+ self.play(FadeOut(VGroup(
+ self.at_any_points_text,
+ self.evaluate_text
+ )))
+ self.play(Write(self.dot_prod_text))
+ self.play(
+ FadeIn(dot_sym),
+ ApplyMethod(
+ self.tangent_sym.next_to,
+ dot_sym, RIGHT
+ ))
+
+ self.dot_sym=dot_sym
+
+ def multiply_with_ds(self):
+ self.get_ds()
+
+ self.play(GrowFromCenter(self.ds_brace_group))
+ self.wait(2)
+ self.play(Write(self.multiply_text))
+ self.play(ApplyMethod(
+ self.ds_brace_label.next_to,
+ self.tangent_sym, RIGHT,buff=.15
+ ))
+
+
+
+ def get_ds(self):
+ p1= self.dots[self.index]
+ p2= self.dots[self.index+1]
+ ds_brace=Brace(VGroup(p1,p2),DL)
+ ds_brace.move_to(p1,UR)
+ ds_brace_label=ds_brace.get_text("$\Delta s_i$", buff = .05)
+ ds_brace_label.set_color(BLUE)
+ self.ds_brace=ds_brace
+ self.ds_brace_label=ds_brace_label
+ self.ds_brace_group=VGroup(ds_brace,ds_brace_label)
+
+
+ def construct_equation(self):
+ sum_up_text=TextMobject("and"," summed ", "for all i' s")
+ sum_up_text.set_color_by_tex("summed",PURPLE_A)
+ sum_up_text.next_to(self.multiply_text,DOWN,buff=MED_SMALL_BUFF)
+ sum_up_text.shift(LEFT)
+
+ sum_eqn=TextMobject("$$\\sum_i^{ } $$").set_color(PURPLE_A)
+ sum_eqn.move_to(self.graph_origin+6.5*self.X+4*self.Y)
+
+ line_integral_text=TextMobject("The Value of the"," line ","integral is").to_edge(TOP,buff=MED_SMALL_BUFF)
+ line_integral_text.set_color_by_tex("line",BLUE_C)
+ approx=TextMobject("$\\approx$",color=RED).next_to(sum_eqn,LEFT)
+ multipled=VGroup(
+ self.func_val,
+ self.dot_sym,
+ self.tangent_sym,
+ self.ds_brace_label
+ )
+
+
+ self.play(Write(sum_up_text))
+ self.show_specific_vectors(self.dots)
+ self.play(FadeIn(sum_eqn))
+ self.play(ApplyMethod(
+ multipled.next_to,sum_eqn,RIGHT
+ ))
+ self.wait()
+ self.play(FadeOut(VGroup(
+ self.dot_prod_text,
+ self.multiply_text,
+ sum_up_text
+ )))
+ self.play(Write(line_integral_text))
+ self.play(FadeIn(approx))
+
+
+
+#uploaded by Somnath Pandit.FSF2020_Line Integrals
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.gif
new file mode 100644
index 0000000..ceedb1f
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.gif
Binary files differ
diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.py
new file mode 100644
index 0000000..50aeb33
--- /dev/null
+++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/line-integrals/file4_helix.py
@@ -0,0 +1,245 @@
+from manimlib.imports import *
+
+class ParametricCurve(ThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": 0,
+ "x_max": 3,
+ "y_min": 0,
+ "y_max": 3,
+ "z_min": 0,
+ "z_max": 4,
+ "a":0 ,"b": 2, "c":0 , "d":2,
+ "axes_shift":2*IN+1.4*RIGHT+1.4*DOWN,
+ "x_axis_config": {
+ "tick_frequency": 1,
+ "include_tip": False,
+ },
+ "y_axis_config": {
+ "tick_frequency": 1,
+ "include_tip": False,
+ },
+ "z_axis_config": {
+ "tick_frequency": 1,
+ # "include_tip": False,
+ },
+ },
+
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+
+ self.set_camera_orientation(
+ distance=25,
+ phi=60 * DEGREES,
+ theta=40 * DEGREES,
+ )
+
+ label=TextMobject("Helix",color=PURPLE).scale(1.6)
+ label.to_corner(UR,buff=2)
+ self.add_fixed_in_frame_mobjects(label)
+
+ helix=self.get_helix(
+ radius=1.5,
+ t_min= 0,
+ t_max= 4*PI,
+ color=PURPLE
+ )
+ parameter_label=TextMobject(
+ "Parametric equation: ",
+ color=TEAL
+ ).next_to(label,DOWN,buff=.3
+ )
+ parametric_eqn=TextMobject(
+ "$x=\cos$ (","t",
+ r")\\$y=\sin $(","t",
+ r")\\$z$=","t"
+ ).next_to(parameter_label,DOWN,buff=.1)
+ parametric_eqn.set_color_by_tex("t",RED)
+ self.parametric_eqn=parametric_eqn
+
+ parametriztion=VGroup(
+ parameter_label,
+ parametric_eqn
+ )
+
+
+ self.play(ShowCreation(helix),run_time=2)
+ self.begin_ambient_camera_rotation(.1)
+ self.wait(1)
+ self.add_fixed_in_frame_mobjects(parametriztion)
+ self.play(Write(parametriztion))
+ self.wait(1)
+ self.stop_ambient_camera_rotation()
+ self.move_camera(
+ distance=20,
+ phi=85 * DEGREES,
+ # theta=-90 * DEGREES,
+ run_time=3
+ )
+ scale_axes=VGroup(self.axes,helix).scale(1.2)
+ self.show_the_parameter()
+ self.wait(2)
+
+
+
+ def get_helix(self,radius=1, **kwargs):
+ config = {
+ "t_min": 0,
+ "t_max": 2*PI,
+ }
+ config.update(kwargs)
+ helix= ParametricFunction(
+ lambda t : self.axes.c2p(
+ radius*np.cos(t),
+ radius*np.sin(t),
+ t/4
+ ),
+ **config
+ )
+
+ self.helix=helix
+ return helix
+
+ def show_the_parameter(self):
+ t_tracker = ValueTracker(0)
+ t=t_tracker.get_value
+
+ t_label = TexMobject(
+ "t = ",color=RED
+ ).next_to(self.parametric_eqn,DL,buff=.85)
+
+ t_text = always_redraw(
+ lambda: DecimalNumber(
+ t(),
+ color=GOLD,
+ ).next_to(t_label, RIGHT, MED_SMALL_BUFF)
+ )
+ t_text.suspend_updating()
+
+ dot = Sphere(
+ radius= 1.5*DEFAULT_DOT_RADIUS,
+ stroke_width= 1,
+ fill_opacity= 1.0,
+ )
+ dot.set_color(GOLD)
+ dot.add_updater(lambda v: v.move_to(
+ self.helix.get_point_from_function(PI*t())
+ ))
+
+ pi = TexMobject(
+ "\\pi ",
+ color=GOLD,
+ ).next_to(t_text,RIGHT,buff=-.3)
+
+ group = VGroup(t_text,t_label,pi).scale(1.5)
+
+ self.wait(1)
+ self.add_fixed_in_frame_mobjects(group)
+ t_text.resume_updating()
+ self.play(FadeIn(group))
+ self.add(dot)
+ self.play(
+ t_tracker.set_value,2,
+ rate_func=linear,
+ run_time=5
+ )
+
+
+#--------------------------------------------------------
+
+ #customize 3D axes
+ 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=1.5)
+
+ 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, LEFT,
+ about_point=axes.c2p(0, 0, 0),
+ )
+ axes.y_axis.rotate(
+ 90 * DEGREES, UP,
+ about_point=axes.c2p(0, 0, 0),
+ )
+
+
+ return axes
+
+
+ def setup_axes(self):
+ axes = self.get_three_d_axes(include_labels=True)
+ axes.scale(1)
+ # axes.center()
+ axes.shift(axes.axes_shift)
+ self.add(axes)
+ self.axes = axes
+
+ def add_axes_numbers(self, axes):
+ x_axis = axes.x_axis
+ y_axis = axes.y_axis
+ tex_vals_x = [
+ ("1", axes.b),
+ ]
+ tex_vals_y=[
+ ("1", axes.d)
+ ]
+ x_labels = VGroup()
+ y_labels = VGroup()
+ for tex, val in tex_vals_x:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(x_axis.n2p(val), DOWN)
+ label.rotate(180 * DEGREES)
+ x_labels.add(label)
+ x_axis.add(x_labels)
+ x_axis.numbers = x_labels
+
+ for tex, val in tex_vals_y:
+ label = TexMobject(tex)
+ label.scale(1)
+ label.next_to(y_axis.n2p(val), LEFT)
+ label.rotate(90 * DEGREES)
+ y_labels.add(label)
+
+ y_axis.add(y_labels)
+ y_axis.numbers = y_labels
+
+ 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
+
+ y_label = TextMobject("y")
+ y_label.rotate(90 * DEGREES, OUT)
+ y_label.next_to(axes.y_axis.get_end(), UP)
+ axes.y_axis.label = y_label
+
+ z_label = TextMobject("z")
+ z_label.rotate(90 * DEGREES, LEFT)
+ z_label.next_to(axes.z_axis.get_zenith(), LEFT)
+ axes.z_axis.label = z_label
+ for axis in axes:
+ axis.add(axis.label)
+ return axes
+
+ #uploaded by Somnath Pandit.FSF2020_Line_integrals
+
+
+
+
+