summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/README.md1
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4bin0 -> 350623 bytes
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gifbin0 -> 1170435 bytes
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4bin0 -> 681985 bytes
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/area_under_func.py73
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4bin0 -> 378325 bytes
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/elementary_area.py144
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4bin0 -> 1189183 bytes
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/non_rect_region.py154
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/surface.py236
-rw-r--r--FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py113
11 files changed, 721 insertions, 0 deletions
diff --git a/FSF-2020/integrals-of-multivariable-functions/README.md b/FSF-2020/integrals-of-multivariable-functions/README.md
index e69de29..a321caf 100644
--- a/FSF-2020/integrals-of-multivariable-functions/README.md
+++ b/FSF-2020/integrals-of-multivariable-functions/README.md
@@ -0,0 +1 @@
+FSF2020--Somnath Pandit
diff --git a/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 b/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4
new file mode 100644
index 0000000..181615d
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4
Binary files differ
diff --git a/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif b/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif
new file mode 100644
index 0000000..a2bfd9d
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif
Binary files differ
diff --git a/FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4 b/FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4
new file mode 100644
index 0000000..7072672
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4
Binary files differ
diff --git a/FSF-2020/integrals-of-multivariable-functions/area_under_func.py b/FSF-2020/integrals-of-multivariable-functions/area_under_func.py
new file mode 100644
index 0000000..773840c
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/area_under_func.py
@@ -0,0 +1,73 @@
+from manimlib.imports import *
+
+
+class AreaUnderIntegral(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 5,
+ "y_min" : 0,
+ "y_max" : 6,
+ "Func":lambda x : 1+x**2*np.exp(-.15*x**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)
+
+ int_area_sym=TextMobject("$$\int_{a}^b f(x)dx$$").shift(2*UP)
+ area_mean_text = TextMobject(r"means area under the curve of $f(x)$ \\ in the region $a\leq x\leq b$").next_to(int_area_sym,DOWN)
+
+ opening_text=VGroup(*[int_area_sym,area_mean_text])
+ self.play(Write(opening_text),run_time=4)
+ self.wait(2)
+ self.play(FadeOut(opening_text))
+
+ self.setup_axes(animate=True)
+ func= self.get_graph(self.Func, x_min=0,x_max=5)
+ self.curve=func
+
+ func_text = TextMobject(r"$y = f(x)$").next_to(func,UP)
+ min_lim = self.get_vertical_line_to_graph(1,func,DashedLine,color=YELLOW)
+ tick_a=TextMobject(r"$a$").next_to(min_lim,DOWN)
+ max_lim = self.get_vertical_line_to_graph(4,func,DashedLine,color=YELLOW)
+ tick_b=TextMobject(r"$b$").next_to(max_lim,DOWN)
+
+ # area = self.get_area(func,1,4)
+
+ self.play(ShowCreation(func), ShowCreation(func_text))
+
+ self.wait(2)
+ self.play(ShowCreation(min_lim),Write(tick_a), ShowCreation(max_lim),Write(tick_b),run_time=0.5)
+
+
+ approx_text=TextMobject(r"The area can be approximated as \\ sum of small rectangles").next_to(func,4*Y)
+ self.play(Write(approx_text))
+
+ rect_list = self.get_riemann_rectangles_list(
+ self.curve, 5,
+ max_dx = 0.25,
+ x_min = 1,
+ x_max = 4,
+ )
+ flat_graph = self.get_graph(lambda t : 0)
+ rects = self.get_riemann_rectangles( flat_graph, x_min = 1, x_max = 4, dx = 0.5)
+ for new_rects in rect_list:
+ new_rects.set_fill(opacity = 0.8)
+ rects.align_submobjects(new_rects)
+ for alt_rect in rects[::2]:
+ alt_rect.set_fill(opacity = 0)
+ self.play(Transform(
+ rects, new_rects,
+ run_time = 1.5,
+ lag_ratio = 0.5
+ ))
+ conclude_text=TextMobject(r"Making the rectangles infinitesimally thin \\ we get the real area under the curve.").next_to(func,4*Y)
+ self.play(Transform(approx_text,conclude_text))
+ self.wait(3)
+ int_area_sym.next_to(self.curve,IN)
+ self.play(Transform(conclude_text,int_area_sym))
+
+ # self.play(ShowCreation(area))
+ self.wait(3)
+
+#uploaded by Somnath Pandit.FSF2020_Double_Integral
diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 b/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4
new file mode 100644
index 0000000..601a56a
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4
Binary files differ
diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py
new file mode 100644
index 0000000..362b6f8
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py
@@ -0,0 +1,144 @@
+from manimlib.imports import *
+
+class ElementaryArea(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 2,
+ "y_min" : 0,
+ "y_max" : 2,
+ "x_tick_frequency" : 1,
+ "y_tick_frequency" : 1,
+ # "x_labeled_nums": list(np.arange(0,3)),
+ # "y_labeled_nums": list(np.arange(0 ,3)),
+ "x_axis_width": 6,
+ "y_axis_height": 6,
+ "graph_origin": ORIGIN+3.5*LEFT+3.5*DOWN,
+ }
+
+ def construct(self):
+ X = self.x_axis_width/(self.x_max- self.x_min)
+ Y = self.y_axis_height/(self.y_max- self.y_min)
+ self.X=X ;self.Y=Y
+ self.setup_axes(animate=False)
+
+ caption=TextMobject("The elementary area in ").to_edge(UP)
+ rect_text=TextMobject("Cartesian Coordinates").next_to(caption,DOWN,)
+ polar_text=TextMobject("Polar Coordinates").next_to(caption,DOWN,)
+
+ self.add(caption)
+ self.play(Write(rect_text))
+ self.get_rect_element()
+ # self.play(Write(polar_text))
+ self.play(ReplacementTransform(rect_text,polar_text),
+ FadeOut(VGroup(self.dydx,self.rect_brace_gr)))
+ self.get_polar_element()
+
+
+
+ def get_rect_element(self):
+ rect=Rectangle(
+ height=2, width=3,fill_color=BLUE_D,
+ fill_opacity=1, color=BLUE_D
+ ).scale(.75).move_to(
+ self.graph_origin+(RIGHT*self.X+UP*self.Y)
+ )
+ dx_brace=Brace(rect, DOWN, buff = SMALL_BUFF)
+ dx_label=dx_brace.get_text("$dx$", buff = SMALL_BUFF)
+ dx_brace_gr=VGroup(dx_brace,dx_label)
+
+ dy_brace=Brace(rect,RIGHT, buff = SMALL_BUFF)
+ dy_label=dy_brace.get_text("$dy$", buff = SMALL_BUFF)
+ dy_brace_gr=VGroup(dy_brace,dy_label)
+
+ brace_gr=VGroup(dx_brace_gr,dy_brace_gr)
+
+ dydx=TextMobject("$dxdy$",color=BLACK).next_to(rect,IN)
+
+ self.play(FadeIn(rect))
+ self.play(GrowFromCenter(brace_gr))
+ self.play(GrowFromCenter(dydx))
+
+ self.rect=rect
+ self.rect_brace_gr=brace_gr
+ self.dydx=dydx
+ self.wait(2)
+
+
+ def get_polar_element(self):
+ X=self.X ;Y=self.Y
+ theta1=25*DEGREES
+ dtheta=TAU/12
+ r_in=1.3*X ; r_out=1.9*X
+
+ arc=AnnularSector(
+ arc_center=self.graph_origin,
+ inner_radius=r_in,
+ outer_radius=r_out ,
+ angle= dtheta,
+ start_angle= theta1,
+ fill_opacity= 1,
+ stroke_width= 0,
+ color= BLUE_D,
+ )
+
+
+ # # #getting braces
+ r_in_theta1=self.graph_origin+r_in*(np.cos(theta1)*RIGHT+np.sin(theta1)*UP)
+ dr_line=Line(r_in_theta1,r_in_theta1+RIGHT*(r_out-r_in))
+ dr_brace=Brace(dr_line, DOWN, buff = SMALL_BUFF
+ ).rotate(theta1, about_point=r_in_theta1
+ )
+ dr_label=dr_brace.get_text("$dr$", buff = SMALL_BUFF)
+ dr_brace_gr=VGroup(dr_brace,dr_label)
+
+ theta2=theta1+dtheta
+ r_out_theta2=self.graph_origin+r_out*(
+ np.cos(theta2)*RIGHT+np.sin(theta2)*UP
+ )
+ rdt_line=Line(r_out_theta2,r_out_theta2
+ +DOWN*(r_out*dtheta)
+ )
+ rdt_brace=Brace(rdt_line, RIGHT,
+ buff = MED_SMALL_BUFF).rotate(
+ theta2-(dtheta/2), about_point=r_out_theta2
+ )
+ rdt_label=rdt_brace.get_text("$rd\\theta$",buff = SMALL_BUFF)
+ rdt_brace_gr=VGroup(rdt_brace,rdt_label)
+
+ #getting label r and dtheta
+ r1=DashedLine(self.graph_origin,r_in_theta1).set_color(RED)
+ r2=DashedLine(self.graph_origin,r_out_theta2).set_color(RED)
+ r_brace=Brace(r1, DOWN, buff = SMALL_BUFF).rotate(theta1, about_point=self.graph_origin)
+ r_label=r_brace.get_text("$r$", buff = SMALL_BUFF)
+ r_brace_gr=VGroup(r_brace,r_label)
+
+ dtheta_arc=Arc(
+ arc_center=self.graph_origin,
+ radius=.5*X,
+ angle= dtheta,
+ start_angle= theta1,
+ )
+ dtheta_arc_label=TextMobject("$d\\theta$").move_to(.99*dtheta_arc.get_corner(UR))
+ dtheta_label=VGroup(dtheta_arc,dtheta_arc_label)
+
+
+ rdrdt=TextMobject("$rdrd\\theta$",color=BLACK).next_to(arc,IN)
+ self.play(ReplacementTransform(self.rect,arc))
+ self.wait()
+ self.play(ShowCreation(r1),
+ ShowCreation(r2)
+ )
+ self.play(ShowCreation(r_brace_gr),
+ Write(dtheta_label)
+ )
+ self.wait()
+ self.play(GrowFromCenter(rdt_brace_gr))
+ self.wait(.5)
+ self.play(GrowFromCenter(dr_brace_gr))
+ self.wait(.5)
+ self.play(GrowFromCenter(rdrdt))
+
+ self.wait(2)
+
+
+ #uploaded by Somnath Pandit.FSF2020_Double_Integral
diff --git a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4
new file mode 100644
index 0000000..2eebc65
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4
Binary files differ
diff --git a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py
new file mode 100644
index 0000000..793a000
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py
@@ -0,0 +1,154 @@
+from manimlib.imports import *
+
+class AreaUnderCurve(GraphScene):
+ CONFIG = {
+ "x_min" : -1,
+ "x_max" : 8,
+ "y_min" : -1,
+ "y_max" : 5,
+ "y_axis_label": "$y$",
+ "x_tick_frequency" : 1,
+ "y_tick_frequency" : 1,
+ "x_labeled_nums": list(np.arange(-1, 9)),
+ "y_labeled_nums": list(np.arange(-1, 6)),
+ "y_axis_height":5.5,
+ "graph_origin": ORIGIN+4*LEFT+2.5*DOWN,
+ }
+
+ 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)
+
+ sofar_text=TextMobject(r"So far we have integrated over \\ rectangular regions")
+ self.play(Write(sofar_text))
+ self.play(sofar_text.to_edge,UP)
+
+ self.setup_axes(animate=False)
+
+ rect= self.get_graph(
+ lambda x : 3,
+ x_min = 0,
+ x_max = 5,
+ color = GREEN)
+
+ rect_region = self.get_riemann_rectangles(
+ rect,
+ x_min = 0,
+ x_max = 5,
+ dx =.01,
+ start_color = GREEN,
+ end_color = GREEN,
+ fill_opacity = 0.75,
+ stroke_width = 0,
+ )
+
+ self.play(ShowCreation(rect_region))
+ self.wait(.5)
+
+ rect_int=TextMobject(r"Here the integration limits are set as").to_edge(UP)
+ rect_lim=TextMobject(r"$$\int_{x=0}^{5}\int_{y=0}^{3}$$").next_to(rect_int,DOWN)
+ const_text=TextMobject(r"$\longleftarrow $ \textsf the limits are\\ constant values").next_to(rect_lim,RIGHT)
+
+ self.play(ReplacementTransform(sofar_text,rect_int))
+ self.wait(1.5)
+ self.play(FadeIn(rect_lim))
+ self.wait(2)
+ self.play(Write(const_text))
+ self.wait(2)
+ self.play(FadeOut(rect_int), FadeOut(rect_lim),FadeOut(const_text))
+
+
+ non_rect_text=TextMobject(r"Now we see how to integrate over \\ non-rectangular regions")
+ non_rect_text.to_edge(UP)
+ self.play(Write(non_rect_text))
+ self.wait(1.5)
+ self.play(FadeOut(rect_region))
+
+ c1= self.get_graph(
+ lambda x : x**2/4,
+ x_min = 0,
+ x_max = 4,
+ color = RED)
+
+ c1_region = self.get_riemann_rectangles(
+ c1,
+ x_min = 0,
+ x_max = 4,
+ dx =.01,
+ start_color = BLUE,
+ end_color = BLUE,
+ fill_opacity = 0.75,
+ stroke_width = 0,
+ )
+ self.add(c1,c1_region)
+ # self.wait(2)
+
+ c2= self.get_graph(
+ lambda x :12-2*x,
+ x_min = 4,
+ x_max = 6,
+ color = RED)
+
+ c2_region = self.get_riemann_rectangles(
+ c2,
+ x_min = 4,
+ x_max = 6,
+ dx =.01,
+ start_color = BLUE,
+ end_color = BLUE,
+ fill_opacity = .75,
+ stroke_width = 0,
+ )
+ self.add(c2_region,c2)
+ self.wait(1.5)
+ c=VGroup(*[c1,c2])
+
+ no_func_text=TextMobject(r"The whole region can't be expressed as\\ bounded by a single $f(x)$").next_to(c2,UP,buff=LARGE_BUFF)
+
+ self.play(ReplacementTransform(non_rect_text,no_func_text))
+ self.wait(1)
+ self.play(Indicate(c))
+ self.wait(2)
+
+ div_region_text=TextMobject(r"So the region is divided into two").next_to(c2,UP,buff=MED_LARGE_BUFF)
+ self.play(ReplacementTransform(no_func_text,div_region_text))
+
+ c2.set_color(YELLOW)
+ self.play(c2_region.set_color,YELLOW)
+ c1_text=TextMobject("$\dfrac{x^2}{4}$").next_to(c1,IN)
+ c2_text=TextMobject("$12-2x$").next_to(c2,IN+2*X)
+ c_text=VGroup(*[c1_text,c2_text])
+
+ self.play(FadeIn(c_text))
+ self.wait(.4)
+ self.play(Indicate(c1),Indicate(c1_text))
+ self.play(Indicate(c2),Indicate(c2_text))
+
+ easy_text=TextMobject(r"Now the limis can be set easily").next_to(c2,UP,buff=.5)
+ self.play(ReplacementTransform(div_region_text,easy_text))
+
+ c1_int=TextMobject(r"$$\int_{x=0}^{4}\int_{y=0}^{\dfrac{x^2}{4}}$$").next_to(c1,IN).shift(.5*(-X+1.3*Y))
+ c2_int=TextMobject(r"$$\int_{x=4}^{6}\int_{y=0}^{12-2x}$$").next_to(c2,IN+X)
+
+ self.play(ReplacementTransform(c1_text,c1_int),ReplacementTransform(c2_text,c2_int))
+ self.wait(2)
+
+ total_int=TextMobject(r"The total integraton= ").to_edge(UP)
+ plus=TextMobject("$$+$$").move_to(self.graph_origin+4*X+4.8*Y)
+ self.play(ReplacementTransform(easy_text,total_int))
+ self.play(c2_region.set_color,BLUE)
+ self.play(c1_int.next_to,c1,.1*UP, c2_int.next_to,plus,RIGHT, FadeIn(plus))
+
+ region=VGroup(*[c1_region,c2_region])
+ region.set_color(GREEN)
+ self.play(ShowCreation(region))
+ self.wait(3)
+
+
+
+#uploaded by Somnath Pandit.FSF2020_Double_Integral
+
+
+
+
+
diff --git a/FSF-2020/integrals-of-multivariable-functions/surface.py b/FSF-2020/integrals-of-multivariable-functions/surface.py
new file mode 100644
index 0000000..a794f46
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/surface.py
@@ -0,0 +1,236 @@
+from manimlib.imports import *
+
+class SurfacesAnimation(ThreeDScene):
+
+ CONFIG = {
+ "axes_config": {
+ "x_min": 0,
+ "x_max": 8,
+ "y_min": 0,
+ "y_max": 8,
+ "z_min": 0,
+ "z_max": 6,
+ "a":1 ,"b": 6, "c":2 , "d":6,
+ "axes_shift":-3*OUT + 5*LEFT,
+ "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.sin(x)
+ }
+
+
+ def construct(self):
+
+ self.setup_axes()
+ self.set_camera_orientation(distance=35,
+ phi=80 * DEGREES,
+ theta=-80 * DEGREES,
+ )
+
+ fn_text=TextMobject("$z=f(x,y)$").set_color(PINK)
+ self.add_fixed_in_frame_mobjects(fn_text)
+ fn_text.to_edge(TOP,buff=MED_SMALL_BUFF)
+
+ R=TextMobject("R").set_color(BLACK).scale(3)
+ R.move_to(self.axes.input_plane,IN)
+ self.add(R)
+
+ #get the surface
+ surface= self.get_surface(
+ self.axes, lambda x , y:
+ self.Func(x,y)
+ )
+ surface.set_style(
+ fill_opacity=0.8,
+ fill_color=PINK,
+ stroke_width=0.8,
+ stroke_color=WHITE,
+ )
+
+
+ self.begin_ambient_camera_rotation(rate=0.07)
+ self.play(Write(surface))
+ # self.play(LaggedStart(ShowCreation(surface)))
+
+ self.get_lines()
+ # self.play(FadeIn(self.axes.input_plane))
+ self.wait(3)
+
+ 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
+ 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,"RED"))
+
+ 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))
+
+
+ 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 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,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 = [
+ ("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/integrals-of-multivariable-functions/y_limit_dependent_on_x.py b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py
new file mode 100644
index 0000000..4894ebf
--- /dev/null
+++ b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py
@@ -0,0 +1,113 @@
+from manimlib.imports import *
+
+class YlimitXdependent(GraphScene):
+ CONFIG = {
+ "x_min" : 0,
+ "x_max" : 1,
+ "y_min" : 0,
+ "y_max" : 2,
+ "x_tick_frequency" : 1,
+ "y_tick_frequency" : 1,
+ "x_labeled_nums": list(np.arange(0,2)),
+ "y_labeled_nums": list(np.arange(0 ,3)),
+ "x_axis_width": 3.5,
+ "y_axis_height": 6,
+ "graph_origin": ORIGIN+2.5*LEFT+3*DOWN,
+ }
+
+ 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.setup_axes(animate=False)
+
+ line= self.get_graph(
+ lambda x : 2-2*x ,
+ x_min = 0,
+ x_max = 1,
+ color = RED)
+ 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)
+ self.play(ShowCreation(line),Write(line_eqn))
+ # self.show_area()
+ self.show_rects()
+ self.play(Write(caption))
+ self.show_y_values_at_different_x()
+
+ self.wait(.5)
+
+ ###################
+ def show_area(self):
+ area = self.get_riemann_rectangles(
+ self.line,
+ x_min = 0,
+ x_max = 1,
+ dx =.0001,
+ start_color = BLUE,
+ end_color = BLUE,
+ fill_opacity = 1,
+ stroke_width = 0,
+ )
+ self.play(ShowCreation(area))
+ # self.transform_between_riemann_rects(self.rects,area)
+ self.area = area
+
+ def show_rects(self):
+ rects = self.get_riemann_rectangles(
+ self.line,
+ x_min = 0,
+ x_max = 1,
+ dx =.01,
+ start_color = BLUE,
+ end_color = BLUE,
+ fill_opacity =1,
+ stroke_width = 0,
+ )
+ # self.play(ShowCreation(rects))
+ # self.transform_between_riemann_rects(self.area,rects)
+ self.rects=rects
+
+ def show_y_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[3*rp:5*rp]
+
+ last_rect = None
+ for rect in rects_subset:
+ brace = Brace(rect, LEFT, buff = 0)
+ y = TexMobject("y=2-2x")#.rotate(PI/2)
+ y.next_to(brace, LEFT, SMALL_BUFF)
+ anims = [
+ rect.set_fill, BLUE_E, 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, BLUE, .75,
+ ReplacementTransform(last_brace, brace),
+ ReplacementTransform(last_y, y),
+ ]
+ else:
+ anims += [
+ GrowFromCenter(brace),
+ Write(y)
+ ]
+ self.play(*anims)
+ # self.wait(.2)
+
+ last_rect = rect
+ last_brace = brace
+ last_y = y
+
+ y = last_y
+ y_brace = last_brace
+
+
+#uploaded by Somnath Pandit.FSF2020_Double_Integral