From d2b23ebb2c372a4d5283c1cc1ea55c01a956784f Mon Sep 17 00:00:00 2001 From: Archit Sangal Date: Wed, 6 May 2020 17:43:57 +0530 Subject: Update README.md Added 'my name as a contributor' and 'Added Sub Topics'--- FSF-2020/linear-transformations/README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/FSF-2020/linear-transformations/README.md b/FSF-2020/linear-transformations/README.md index e69de29..feb72c5 100644 --- a/FSF-2020/linear-transformations/README.md +++ b/FSF-2020/linear-transformations/README.md @@ -0,0 +1,8 @@ +# Contributer: Archit Sangal +

+## Sub-Topics Covered: ++ Vector Space Homomorphisms (Linear Maps) ++ The Four Fundamental Subspaces ++ Rank-Nullity Theorem ++ Orthonormal basis ++ Gramm-Schmidt Orthogonalization Process -- cgit From 28617e2371a7598de288efb6a4949a673929cd17 Mon Sep 17 00:00:00 2001 From: Archit Sangal Date: Wed, 6 May 2020 18:28:54 +0530 Subject: Update README.md Added link to my github account--- FSF-2020/linear-transformations/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/FSF-2020/linear-transformations/README.md b/FSF-2020/linear-transformations/README.md index feb72c5..692201e 100644 --- a/FSF-2020/linear-transformations/README.md +++ b/FSF-2020/linear-transformations/README.md @@ -1,4 +1,5 @@ # Contributer: Archit Sangal +My Github Account : architsangal

## Sub-Topics Covered: + Vector Space Homomorphisms (Linear Maps) -- cgit From d7a038fb033d920b35f42c65e8ff72a52ea32e1a Mon Sep 17 00:00:00 2001 From: Archit Sangal Date: Sun, 10 May 2020 20:39:37 +0530 Subject: adding files --- .../Linear Transformations (Linear Maps)/Animation.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py diff --git a/FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py b/FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py new file mode 100644 index 0000000..e69de29 -- cgit From 459c8ef6c3efdbb264e0a3eb1687110553571b05 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 12 May 2020 00:19:54 +0530 Subject: Add files via upload Area under a curve as Riemann sum of infinitesimal rectangular regions.--- .../area_under_func.py | 72 ++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/area_under_func.py 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..0269d74 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/area_under_func.py @@ -0,0 +1,72 @@ +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) + -- cgit From ed67cc04f0c7ea10f6d702fe6d11e169fc8749f4 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 12 May 2020 00:21:32 +0530 Subject: Update area_under_func.py --- FSF-2020/integrals-of-multivariable-functions/area_under_func.py | 1 + 1 file changed, 1 insertion(+) diff --git a/FSF-2020/integrals-of-multivariable-functions/area_under_func.py b/FSF-2020/integrals-of-multivariable-functions/area_under_func.py index 0269d74..773840c 100644 --- a/FSF-2020/integrals-of-multivariable-functions/area_under_func.py +++ b/FSF-2020/integrals-of-multivariable-functions/area_under_func.py @@ -70,3 +70,4 @@ class AreaUnderIntegral(GraphScene): # self.play(ShowCreation(area)) self.wait(3) +#uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 5621f0942dd245244c9bab42f929b9ddb9943023 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Thu, 14 May 2020 20:11:32 +0530 Subject: Add files via upload Integrating over non-rectengular region and division of the region to get some meaningful functions.--- .../non_rect_region.py | 152 +++++++++++++++++++++ 1 file changed, 152 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/non_rect_region.py 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..3634b7e --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py @@ -0,0 +1,152 @@ +from manimlib.imports import * + +class AreaUnderCurve(GraphScene): + CONFIG = { + "x_min" : -1, + "x_max" : 8, + "y_min" : -1, + "y_max" : 6, + "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, 7)), + "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+5*Y) + self.play(ReplacementTransform(easy_text,total_int)) + self.play(c2_region.set_color,BLUE) + self.play(c1_int.next_to,c1,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) + + + + + + + + -- cgit From 192bfa785bba078f776ed9cb05e85fc2d3ada5ed Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Thu, 14 May 2020 20:12:59 +0530 Subject: Update non_rect_region.py --- FSF-2020/integrals-of-multivariable-functions/non_rect_region.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py index 3634b7e..79937da 100644 --- a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py +++ b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py @@ -144,7 +144,8 @@ class AreaUnderCurve(GraphScene): self.wait(3) - + +#uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 5f2abfec1aff1d1fb461a00222f0be22218d5dec Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Thu, 14 May 2020 23:16:58 +0530 Subject: Update non_rect_region.py --- .../integrals-of-multivariable-functions/non_rect_region.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py index 79937da..793a000 100644 --- a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py +++ b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py @@ -5,12 +5,13 @@ class AreaUnderCurve(GraphScene): "x_min" : -1, "x_max" : 8, "y_min" : -1, - "y_max" : 6, + "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, 7)), + "y_labeled_nums": list(np.arange(-1, 6)), + "y_axis_height":5.5, "graph_origin": ORIGIN+4*LEFT+2.5*DOWN, } @@ -133,16 +134,16 @@ class AreaUnderCurve(GraphScene): self.wait(2) total_int=TextMobject(r"The total integraton= ").to_edge(UP) - plus=TextMobject("$$+$$").move_to(self.graph_origin+4*X+5*Y) + 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,UP,c2_int.next_to,plus,RIGHT, FadeIn(plus)) + 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 -- cgit From ba5878523fe684f7bee1664fda3e27239f77119e Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Fri, 15 May 2020 11:26:16 +0530 Subject: Update README.md --- FSF-2020/integrals-of-multivariable-functions/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/FSF-2020/integrals-of-multivariable-functions/README.md b/FSF-2020/integrals-of-multivariable-functions/README.md index e69de29..cd8bfe7 100644 --- a/FSF-2020/integrals-of-multivariable-functions/README.md +++ b/FSF-2020/integrals-of-multivariable-functions/README.md @@ -0,0 +1 @@ +FSF2020--Somnath Pandiy -- cgit From 5f19d0f96f2e5e050008e66fc6f8ecfacd3a7f6d Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Fri, 15 May 2020 11:26:31 +0530 Subject: Update README.md --- FSF-2020/integrals-of-multivariable-functions/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/README.md b/FSF-2020/integrals-of-multivariable-functions/README.md index cd8bfe7..a321caf 100644 --- a/FSF-2020/integrals-of-multivariable-functions/README.md +++ b/FSF-2020/integrals-of-multivariable-functions/README.md @@ -1 +1 @@ -FSF2020--Somnath Pandiy +FSF2020--Somnath Pandit -- cgit From add191d2d30573bd0f455f533a9899e8819e9b46 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Fri, 15 May 2020 15:49:53 +0530 Subject: Add files via upload --- .../Area_Under_func.mp4 | Bin 0 -> 681985 bytes .../non_rect_region.mp4 | Bin 0 -> 1189183 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 create mode 100644 FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 differ 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 differ -- cgit From edf9724bbed86eb8909999a3ef704d346b7231ea Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 01:55:32 +0530 Subject: Add files via upload --- .../y_limit_dependent_on_x.mp4 | Bin 0 -> 333938 bytes .../y_limit_dependent_on_x.py | 112 +++++++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 create mode 100644 FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py diff --git a/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 new file mode 100644 index 0000000..fe0512b Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 differ 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..931ffd6 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py @@ -0,0 +1,112 @@ +from manimlib.imports import * + +class AreaUnderCurve(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=0").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(2) + + ################### + 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 =.02, + start_color = BLUE, + end_color = BLUE, + fill_opacity = 0.75, + 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") + y.next_to(brace, LEFT, SMALL_BUFF) + anims = [ + rect.set_fill, YELLOW, 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 + + -- cgit From 3e2aac467c92c8880001f738b712e27e02fee42f Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 01:56:05 +0530 Subject: Delete Area_Under_func.mp4 --- .../Area_Under_func.mp4 | Bin 681985 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 diff --git a/FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 b/FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 deleted file mode 100644 index 7072672..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/Area_Under_func.mp4 and /dev/null differ -- cgit From 03280d3ac9b81f1e17cb8b39b9efa0abe05eceb9 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 01:57:21 +0530 Subject: Add files via upload --- .../area_under_func.mp4 | Bin 0 -> 681985 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4 differ -- cgit From f3685beb51d24878be9bcd80a0bbbc51ae45f97c Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 01:58:10 +0530 Subject: Update y_limit_dependent_on_x.py --- FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py | 1 + 1 file changed, 1 insertion(+) 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 index 931ffd6..27fe23c 100644 --- 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 @@ -110,3 +110,4 @@ class AreaUnderCurve(GraphScene): y_brace = last_brace +#uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 12c51f740bd53d11072a6641d1a8dee0448dbac0 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 19:52:32 +0530 Subject: Add files via upload --- .../elementary_area.mp4 | Bin 0 -> 378325 bytes .../elementary_area.py | 130 +++++++++++++++++++++ 2 files changed, 130 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 create mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.py 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 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..fdd164d --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py @@ -0,0 +1,130 @@ +from manimlib.imports import * + +class AreaUnderCurve(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) + + + + + + + -- cgit From 32c6afda2e59d477f8694becd6448098ba977cb2 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 19:53:19 +0530 Subject: Update elementary_area.py --- FSF-2020/integrals-of-multivariable-functions/elementary_area.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py index fdd164d..0ca96fe 100644 --- a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py +++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py @@ -125,6 +125,6 @@ class AreaUnderCurve(GraphScene): - +#uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 9673d63f9e9a858f3fc63781e23e9c4303082553 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 21:50:50 +0530 Subject: Delete elementary_area.py --- .../elementary_area.py | 130 --------------------- 1 file changed, 130 deletions(-) delete mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.py diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py deleted file mode 100644 index 0ca96fe..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py +++ /dev/null @@ -1,130 +0,0 @@ -from manimlib.imports import * - -class AreaUnderCurve(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 - - -- cgit From d6c4122bbce6752750a81e49a2627a26b9443046 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 21:51:10 +0530 Subject: Add files via upload --- .../elementary_area.py | 148 +++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.py 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..3fd3f20 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py @@ -0,0 +1,148 @@ +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) + + + + + + + -- cgit From c1ad559e7f629912215949158680b26fe2986aba Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Sun, 17 May 2020 21:52:11 +0530 Subject: Update elementary_area.py --- FSF-2020/integrals-of-multivariable-functions/elementary_area.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py index 3fd3f20..362b6f8 100644 --- a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py +++ b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py @@ -141,8 +141,4 @@ class ElementaryArea(GraphScene): self.wait(2) - - - - - + #uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From d0c166b9eec77361ccb50eec31d0c039abd05f20 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 01:57:55 +0530 Subject: Add files via upload --- .../SurfacesAnimation.mp4 | Bin 0 -> 350623 bytes .../surface.py | 234 +++++++++++++++++++++ 2 files changed, 234 insertions(+) create mode 100644 FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 create mode 100644 FSF-2020/integrals-of-multivariable-functions/surface.py 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 differ 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..6148ec8 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/surface.py @@ -0,0 +1,234 @@ +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":2 ,"b": 6, "c":1 , "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.c, + "u_max": axes.d, + "v_min": axes.a, + "v_max": axes.b, + "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: 1e-5 + ) + 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 + + -- cgit From 6cc272d9fa727db9162d1fa0ff0e33c645c7eda1 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 01:58:48 +0530 Subject: Update surface.py --- FSF-2020/integrals-of-multivariable-functions/surface.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/FSF-2020/integrals-of-multivariable-functions/surface.py b/FSF-2020/integrals-of-multivariable-functions/surface.py index 6148ec8..8fb4b45 100644 --- a/FSF-2020/integrals-of-multivariable-functions/surface.py +++ b/FSF-2020/integrals-of-multivariable-functions/surface.py @@ -232,3 +232,5 @@ class SurfacesAnimation(ThreeDScene): return axes + +#uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 8f21bfeeaef888ffed958d933b58b057bf215e42 Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 14:59:46 +0530 Subject: Update surface.py --- FSF-2020/integrals-of-multivariable-functions/surface.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/FSF-2020/integrals-of-multivariable-functions/surface.py b/FSF-2020/integrals-of-multivariable-functions/surface.py index 8fb4b45..a794f46 100644 --- a/FSF-2020/integrals-of-multivariable-functions/surface.py +++ b/FSF-2020/integrals-of-multivariable-functions/surface.py @@ -10,7 +10,7 @@ class SurfacesAnimation(ThreeDScene): "y_max": 8, "z_min": 0, "z_max": 6, - "a":2 ,"b": 6, "c":1 , "d":6, + "a":1 ,"b": 6, "c":2 , "d":6, "axes_shift":-3*OUT + 5*LEFT, "x_axis_config": { "tick_frequency": 1, @@ -80,10 +80,10 @@ class SurfacesAnimation(ThreeDScene): def get_surface(self,axes, func, **kwargs): config = { - "u_min": axes.c, - "u_max": axes.d, - "v_min": axes.a, - "v_max": axes.b, + "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, @@ -153,7 +153,7 @@ class SurfacesAnimation(ThreeDScene): # Add xy-plane input_plane = self.get_surface( - axes, lambda x, t: 1e-5 + axes, lambda x, t: 0 ) input_plane.set_style( fill_opacity=0.5, -- cgit From 8088f5ff7693e9a6d02f74876b39f9729737024f Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 20:22:43 +0530 Subject: Update y_limit_dependent_on_x.py --- .../y_limit_dependent_on_x.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) 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 index 27fe23c..4894ebf 100644 --- 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 @@ -1,6 +1,6 @@ from manimlib.imports import * -class AreaUnderCurve(GraphScene): +class YlimitXdependent(GraphScene): CONFIG = { "x_min" : 0, "x_max" : 1, @@ -26,7 +26,7 @@ class AreaUnderCurve(GraphScene): x_min = 0, x_max = 1, color = RED) - line_eqn=TextMobject("2x+y=0").move_to(self.graph_origin+.8*X+Y).rotate(np.arctan(-2)) + 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) @@ -36,7 +36,7 @@ class AreaUnderCurve(GraphScene): self.play(Write(caption)) self.show_y_values_at_different_x() - self.wait(2) + self.wait(.5) ################### def show_area(self): @@ -59,10 +59,10 @@ class AreaUnderCurve(GraphScene): self.line, x_min = 0, x_max = 1, - dx =.02, + dx =.01, start_color = BLUE, end_color = BLUE, - fill_opacity = 0.75, + fill_opacity =1, stroke_width = 0, ) # self.play(ShowCreation(rects)) @@ -81,10 +81,10 @@ class AreaUnderCurve(GraphScene): last_rect = None for rect in rects_subset: brace = Brace(rect, LEFT, buff = 0) - y = TexMobject("y=2-2x") + y = TexMobject("y=2-2x")#.rotate(PI/2) y.next_to(brace, LEFT, SMALL_BUFF) anims = [ - rect.set_fill, YELLOW, 1, + rect.set_fill, BLUE_E, 1, dx_brace_group.next_to, rect, DOWN, SMALL_BUFF ] if last_rect is not None: @@ -109,5 +109,5 @@ class AreaUnderCurve(GraphScene): y = last_y y_brace = last_brace - + #uploaded by Somnath Pandit.FSF2020_Double_Integral -- cgit From 604c28e69ed79802a3e5bbfb5bca58811a0d900c Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 20:23:13 +0530 Subject: Delete y_limit_dependent_on_x.mp4 --- .../y_limit_dependent_on_x.mp4 | Bin 333938 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 diff --git a/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 b/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 deleted file mode 100644 index fe0512b..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.mp4 and /dev/null differ -- cgit From 9e06815dc88c15da39281983b62bbf3c1bf00ddc Mon Sep 17 00:00:00 2001 From: panditsomnath10016git Date: Tue, 19 May 2020 20:24:16 +0530 Subject: Add files via upload --- .../YlimitXdependent.gif | Bin 0 -> 1170435 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif 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 Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif differ -- cgit From 80ac12242f298beeafb87fe1e90c564119e9777c Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 02:54:05 +0530 Subject: Critical Points MCQ Questions --- Critical_Points_mcq_questions.pdf | Bin 0 -> 414750 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 Critical_Points_mcq_questions.pdf diff --git a/Critical_Points_mcq_questions.pdf b/Critical_Points_mcq_questions.pdf new file mode 100644 index 0000000..25c4e4d Binary files /dev/null and b/Critical_Points_mcq_questions.pdf differ -- cgit From f90b69c43dfe3f39ef17144aaea90045f6d3b17e Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 03:01:50 +0530 Subject: Update README.md --- FSF-2020/approximations-and-optimizations/README.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/approximations-and-optimizations/README.md index e69de29..42e9eb5 100644 --- a/FSF-2020/approximations-and-optimizations/README.md +++ b/FSF-2020/approximations-and-optimizations/README.md @@ -0,0 +1,9 @@ +Contributor: + Vaishnavi Bisht + +Subtopics Covered: + Critical Points + The Second Derivative Test + Tangent Plane Approximations + Total Differential + Lagrange Multipliers -- cgit From aef8a0c2e3e79f984eb94a8251ad268cd5ff774b Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 03:05:51 +0530 Subject: Update README.md --- FSF-2020/approximations-and-optimizations/README.md | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/approximations-and-optimizations/README.md index 42e9eb5..2c3cdc8 100644 --- a/FSF-2020/approximations-and-optimizations/README.md +++ b/FSF-2020/approximations-and-optimizations/README.md @@ -1,9 +1,8 @@ -Contributor: - Vaishnavi Bisht - -Subtopics Covered: - Critical Points - The Second Derivative Test - Tangent Plane Approximations - Total Differential - Lagrange Multipliers +# Contributer: Vaishnavi Bisht +

+## Sub-Topics Covered: ++ Critical Points ++ The Second Derivative Test ++ Tangent Plane Approximations ++ Total Differential ++ Lagrange Multipliers -- cgit From d6b1e9c36ab093445978caa58db9d78206209299 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 03:06:52 +0530 Subject: Update README.md --- FSF-2020/approximations-and-optimizations/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/approximations-and-optimizations/README.md index 2c3cdc8..478b96b 100644 --- a/FSF-2020/approximations-and-optimizations/README.md +++ b/FSF-2020/approximations-and-optimizations/README.md @@ -1,4 +1,5 @@ # Contributer: Vaishnavi Bisht +Github: https://github.com/vnb09

## Sub-Topics Covered: + Critical Points -- cgit From 53b53c1682d65a861b3707507d9ad48393ad70cd Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 03:10:57 +0530 Subject: Update README.md --- FSF-2020/approximations-and-optimizations/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/approximations-and-optimizations/README.md index 478b96b..f56f4e8 100644 --- a/FSF-2020/approximations-and-optimizations/README.md +++ b/FSF-2020/approximations-and-optimizations/README.md @@ -1,4 +1,4 @@ -# Contributer: Vaishnavi Bisht +# Contributor: Vaishnavi Bisht Github: https://github.com/vnb09

## Sub-Topics Covered: -- cgit From bb22e19560de4184b3cc96dbdf993f565060424c Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Sat, 23 May 2020 03:45:06 +0530 Subject: The Second Derivative Test MCQ Questions --- The_Second_Derivative_Test_MCQ.pdf | Bin 0 -> 646880 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 The_Second_Derivative_Test_MCQ.pdf diff --git a/The_Second_Derivative_Test_MCQ.pdf b/The_Second_Derivative_Test_MCQ.pdf new file mode 100644 index 0000000..ca60cbf Binary files /dev/null and b/The_Second_Derivative_Test_MCQ.pdf differ -- cgit From a240c40156d5a05eb0ec95d2002241ab84ebca81 Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:32:54 +0530 Subject: add topic folders --- .../approximations-and-optimizations/README.md | 0 .../calculus-of-several-variables/div-curl-grad-and-all-that/README.md | 0 .../calculus-of-several-variables/geometry-of-planes-and-curves/README.md | 0 .../integrals-of-multivariable-functions/README.md | 0 .../multivariable-functions-and-paritial-derivatives/README.md | 0 .../calculus-of-several-variables/triple-and-surface-integrals/README.md | 0 FSF-2020/calculus/intro-to-calculus/README.md | 0 FSF-2020/calculus/series-and-transformations/README.md | 0 FSF-2020/linear-algebra/linear-transformations/README.md | 0 FSF-2020/linear-algebra/vector-spaces/README.md | 0 10 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/README.md create mode 100644 FSF-2020/calculus-of-several-variables/geometry-of-planes-and-curves/README.md create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/README.md create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/README.md create mode 100644 FSF-2020/calculus-of-several-variables/triple-and-surface-integrals/README.md create mode 100644 FSF-2020/calculus/intro-to-calculus/README.md create mode 100644 FSF-2020/calculus/series-and-transformations/README.md create mode 100644 FSF-2020/linear-algebra/linear-transformations/README.md create mode 100644 FSF-2020/linear-algebra/vector-spaces/README.md diff --git a/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/README.md b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus-of-several-variables/geometry-of-planes-and-curves/README.md b/FSF-2020/calculus-of-several-variables/geometry-of-planes-and-curves/README.md new file mode 100644 index 0000000..e69de29 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 new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/README.md b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus-of-several-variables/triple-and-surface-integrals/README.md b/FSF-2020/calculus-of-several-variables/triple-and-surface-integrals/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus/intro-to-calculus/README.md b/FSF-2020/calculus/intro-to-calculus/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/calculus/series-and-transformations/README.md b/FSF-2020/calculus/series-and-transformations/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/linear-algebra/linear-transformations/README.md b/FSF-2020/linear-algebra/linear-transformations/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/linear-algebra/vector-spaces/README.md b/FSF-2020/linear-algebra/vector-spaces/README.md new file mode 100644 index 0000000..e69de29 -- cgit From 6b85a25ff7d11849d27eb2362bf5ac2ae2a5db17 Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:35:53 +0530 Subject: remove .mp4 files --- .../SurfacesAnimation.mp4 | Bin 350623 -> 0 bytes .../area_under_func.mp4 | Bin 681985 -> 0 bytes .../elementary_area.mp4 | Bin 378325 -> 0 bytes .../non_rect_region.mp4 | Bin 1189183 -> 0 bytes 4 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 delete mode 100644 FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4 delete mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 delete mode 100644 FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 diff --git a/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 b/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 deleted file mode 100644 index 181615d..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/SurfacesAnimation.mp4 and /dev/null 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 deleted file mode 100644 index 7072672..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/area_under_func.mp4 and /dev/null differ diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 b/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 deleted file mode 100644 index 601a56a..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/elementary_area.mp4 and /dev/null differ diff --git a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 deleted file mode 100644 index 2eebc65..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.mp4 and /dev/null differ -- cgit From 951134e6cb56c2cad83df8505a47772fc5316af6 Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:39:01 +0530 Subject: change folder hirachy --- .../YlimitXdependent.gif | Bin 1170435 -> 0 bytes .../area_under_func.py | 73 ------- .../double-integrals/YlimitXdependent.gif | Bin 0 -> 1170435 bytes .../double-integrals/area_under_func.py | 73 +++++++ .../double-integrals/elementary_area.py | 144 +++++++++++++ .../double-integrals/non_rect_region.py | 154 ++++++++++++++ .../double-integrals/surface.py | 236 +++++++++++++++++++++ .../double-integrals/y_limit_dependent_on_x.py | 113 ++++++++++ .../elementary_area.py | 144 ------------- .../non_rect_region.py | 154 -------------- .../surface.py | 236 --------------------- .../y_limit_dependent_on_x.py | 113 ---------- 12 files changed, 720 insertions(+), 720 deletions(-) delete mode 100644 FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif delete mode 100644 FSF-2020/integrals-of-multivariable-functions/area_under_func.py create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/elementary_area.py create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/non_rect_region.py create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/surface.py create mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/elementary_area.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/non_rect_region.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/surface.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py diff --git a/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif b/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif deleted file mode 100644 index a2bfd9d..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/YlimitXdependent.gif and /dev/null 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 deleted file mode 100644 index 773840c..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/area_under_func.py +++ /dev/null @@ -1,73 +0,0 @@ -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/double-integrals/YlimitXdependent.gif b/FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif new file mode 100644 index 0000000..a2bfd9d Binary files /dev/null and b/FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif differ diff --git a/FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py new file mode 100644 index 0000000..773840c --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/double-integrals/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/double-integrals/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/elementary_area.py new file mode 100644 index 0000000..362b6f8 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/double-integrals/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/double-integrals/non_rect_region.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/non_rect_region.py new file mode 100644 index 0000000..793a000 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/double-integrals/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/double-integrals/surface.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/surface.py new file mode 100644 index 0000000..a794f46 --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/double-integrals/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/double-integrals/y_limit_dependent_on_x.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py new file mode 100644 index 0000000..4894ebf --- /dev/null +++ b/FSF-2020/integrals-of-multivariable-functions/double-integrals/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 diff --git a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/elementary_area.py deleted file mode 100644 index 362b6f8..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/elementary_area.py +++ /dev/null @@ -1,144 +0,0 @@ -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.py b/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py deleted file mode 100644 index 793a000..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/non_rect_region.py +++ /dev/null @@ -1,154 +0,0 @@ -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 deleted file mode 100644 index a794f46..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/surface.py +++ /dev/null @@ -1,236 +0,0 @@ -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 deleted file mode 100644 index 4894ebf..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/y_limit_dependent_on_x.py +++ /dev/null @@ -1,113 +0,0 @@ -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 -- cgit From 48785d983e9063284e3c007acf88969dd58f47f2 Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:49:35 +0530 Subject: fix folder structure from last pr --- .../Critical_Points_mcq_questions.pdf | Bin 0 -> 414750 bytes .../The_Second_Derivative_Test_MCQ.pdf | Bin 0 -> 646880 bytes .../linear-algebra/linear-transformations/README.md | 0 FSF-2020/linear-algebra/vector-spaces/README.md | 0 4 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf create mode 100644 FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf delete mode 100644 FSF-2020/linear-algebra/linear-transformations/README.md delete mode 100644 FSF-2020/linear-algebra/vector-spaces/README.md diff --git a/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf b/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf new file mode 100644 index 0000000..25c4e4d Binary files /dev/null and b/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf differ diff --git a/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf b/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf new file mode 100644 index 0000000..ca60cbf Binary files /dev/null and b/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf differ diff --git a/FSF-2020/linear-algebra/linear-transformations/README.md b/FSF-2020/linear-algebra/linear-transformations/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/linear-algebra/vector-spaces/README.md b/FSF-2020/linear-algebra/vector-spaces/README.md deleted file mode 100644 index e69de29..0000000 -- cgit From 94c40fe490487efcba7c3cc9df0153e86bcab26a Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:50:10 +0530 Subject: remove files from root dir --- Critical_Points_mcq_questions.pdf | Bin 414750 -> 0 bytes The_Second_Derivative_Test_MCQ.pdf | Bin 646880 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Critical_Points_mcq_questions.pdf delete mode 100644 The_Second_Derivative_Test_MCQ.pdf diff --git a/Critical_Points_mcq_questions.pdf b/Critical_Points_mcq_questions.pdf deleted file mode 100644 index 25c4e4d..0000000 Binary files a/Critical_Points_mcq_questions.pdf and /dev/null differ diff --git a/The_Second_Derivative_Test_MCQ.pdf b/The_Second_Derivative_Test_MCQ.pdf deleted file mode 100644 index ca60cbf..0000000 Binary files a/The_Second_Derivative_Test_MCQ.pdf and /dev/null differ -- cgit From fe5e18510140b3e02f3f6f03ad449c218f1b8579 Mon Sep 17 00:00:00 2001 From: Purusharth S Date: Sat, 23 May 2020 18:57:11 +0530 Subject: add topic-name folder --- .../Critical_Points_mcq_questions.pdf | Bin 414750 -> 0 bytes .../approximations-and-optimizations/README.md | 9 - .../The_Second_Derivative_Test_MCQ.pdf | Bin 646880 -> 0 bytes .../Critical_Points_mcq_questions.pdf | Bin 0 -> 414750 bytes .../approximations-and-optimizations/README.md | 9 + .../The_Second_Derivative_Test_MCQ.pdf | Bin 0 -> 646880 bytes .../integrals-of-multivariable-functions/README.md | 1 + .../double-integrals/YlimitXdependent.gif | Bin 0 -> 1170435 bytes .../double-integrals/area_under_func.py | 73 +++++++ .../double-integrals/elementary_area.py | 144 +++++++++++++ .../double-integrals/non_rect_region.py | 154 ++++++++++++++ .../double-integrals/surface.py | 236 +++++++++++++++++++++ .../double-integrals/y_limit_dependent_on_x.py | 113 ++++++++++ .../Power Series/PowerSeriesQuestions.pdf | Bin 0 -> 112622 bytes .../Power Series/script1.py | 128 +++++++++++ .../Power Series/script2.py | 94 ++++++++ .../Power Series/script3.py | 156 ++++++++++++++ .../Power Series/script4.py | 108 ++++++++++ .../Power Series/script5.py | 136 ++++++++++++ .../calculus/series-and-transformations/README.md | 13 ++ .../Taylor Series/TaylorSeriesQuestions.pdf | Bin 0 -> 119804 bytes .../Taylor Series/script1.py | 198 +++++++++++++++++ .../Taylor Series/script2.py | 195 +++++++++++++++++ .../Taylor Series/script3.py | 111 ++++++++++ .../Taylor Series/script4.py | 82 +++++++ FSF-2020/div-curl-grad-and-all-that/README.md | 0 FSF-2020/geometry-of-planes-and-curves/README.md | 0 .../integrals-of-multivariable-functions/README.md | 1 - .../double-integrals/YlimitXdependent.gif | Bin 1170435 -> 0 bytes .../double-integrals/area_under_func.py | 73 ------- .../double-integrals/elementary_area.py | 144 ------------- .../double-integrals/non_rect_region.py | 154 -------------- .../double-integrals/surface.py | 236 --------------------- .../double-integrals/y_limit_dependent_on_x.py | 113 ---------- FSF-2020/intro-to-calculus/README.md | 0 .../Animation.py | 0 .../linear-transformations/README.md | 9 + FSF-2020/linear-algebra/vector-spaces/README.md | 0 .../Animation.py | 0 FSF-2020/linear-transformations/README.md | 9 - .../README.md | 0 .../Power Series/PowerSeriesQuestions.pdf | Bin 112622 -> 0 bytes .../Power Series/script1.py | 128 ----------- .../Power Series/script2.py | 94 -------- .../Power Series/script3.py | 156 -------------- .../Power Series/script4.py | 108 ---------- .../Power Series/script5.py | 136 ------------ FSF-2020/series-and-transformations/README.md | 13 -- .../Taylor Series/TaylorSeriesQuestions.pdf | Bin 119804 -> 0 bytes .../Taylor Series/script1.py | 198 ----------------- .../Taylor Series/script2.py | 195 ----------------- .../Taylor Series/script3.py | 111 ---------- .../Taylor Series/script4.py | 82 ------- FSF-2020/triple-and-surface-integrals/README.md | 0 FSF-2020/vector-spaces/README.md | 0 55 files changed, 1960 insertions(+), 1960 deletions(-) delete mode 100644 FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf delete mode 100644 FSF-2020/approximations-and-optimizations/README.md delete mode 100644 FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf create mode 100644 FSF-2020/calculus-of-several-variables/approximations-and-optimizations/Critical_Points_mcq_questions.pdf create mode 100644 FSF-2020/calculus-of-several-variables/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_under_func.py create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.py create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.py create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.py create mode 100644 FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/script1.py create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/script2.py create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/script3.py create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/script4.py create mode 100644 FSF-2020/calculus/series-and-transformations/Power Series/script5.py create mode 100644 FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf create mode 100644 FSF-2020/calculus/series-and-transformations/Taylor Series/script1.py create mode 100644 FSF-2020/calculus/series-and-transformations/Taylor Series/script2.py create mode 100644 FSF-2020/calculus/series-and-transformations/Taylor Series/script3.py create mode 100644 FSF-2020/calculus/series-and-transformations/Taylor Series/script4.py delete mode 100644 FSF-2020/div-curl-grad-and-all-that/README.md delete mode 100644 FSF-2020/geometry-of-planes-and-curves/README.md delete mode 100644 FSF-2020/integrals-of-multivariable-functions/README.md delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/elementary_area.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/non_rect_region.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/surface.py delete mode 100644 FSF-2020/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py delete mode 100644 FSF-2020/intro-to-calculus/README.md create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/README.md create mode 100644 FSF-2020/linear-algebra/vector-spaces/README.md delete mode 100644 FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py delete mode 100644 FSF-2020/linear-transformations/README.md delete mode 100644 FSF-2020/multivariable-functions-and-paritial-derivatives/README.md delete mode 100644 FSF-2020/series-and-transformations/Power Series/PowerSeriesQuestions.pdf delete mode 100644 FSF-2020/series-and-transformations/Power Series/script1.py delete mode 100644 FSF-2020/series-and-transformations/Power Series/script2.py delete mode 100644 FSF-2020/series-and-transformations/Power Series/script3.py delete mode 100644 FSF-2020/series-and-transformations/Power Series/script4.py delete mode 100644 FSF-2020/series-and-transformations/Power Series/script5.py delete mode 100644 FSF-2020/series-and-transformations/README.md delete mode 100644 FSF-2020/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf delete mode 100644 FSF-2020/series-and-transformations/Taylor Series/script1.py delete mode 100644 FSF-2020/series-and-transformations/Taylor Series/script2.py delete mode 100644 FSF-2020/series-and-transformations/Taylor Series/script3.py delete mode 100644 FSF-2020/series-and-transformations/Taylor Series/script4.py delete mode 100644 FSF-2020/triple-and-surface-integrals/README.md delete mode 100644 FSF-2020/vector-spaces/README.md diff --git a/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf b/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf deleted file mode 100644 index 25c4e4d..0000000 Binary files a/FSF-2020/approximations-and-optimizations/Critical_Points_mcq_questions.pdf and /dev/null differ diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/approximations-and-optimizations/README.md deleted file mode 100644 index f56f4e8..0000000 --- a/FSF-2020/approximations-and-optimizations/README.md +++ /dev/null @@ -1,9 +0,0 @@ -# Contributor: Vaishnavi Bisht -Github: https://github.com/vnb09 -

-## Sub-Topics Covered: -+ Critical Points -+ The Second Derivative Test -+ Tangent Plane Approximations -+ Total Differential -+ Lagrange Multipliers diff --git a/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf b/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf deleted file mode 100644 index ca60cbf..0000000 Binary files a/FSF-2020/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf and /dev/null differ diff --git a/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/Critical_Points_mcq_questions.pdf b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/Critical_Points_mcq_questions.pdf new file mode 100644 index 0000000..25c4e4d Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/Critical_Points_mcq_questions.pdf differ diff --git a/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md index e69de29..f56f4e8 100644 --- a/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md +++ b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md @@ -0,0 +1,9 @@ +# Contributor: Vaishnavi Bisht +Github: https://github.com/vnb09 +

+## Sub-Topics Covered: ++ Critical Points ++ The Second Derivative Test ++ Tangent Plane Approximations ++ Total Differential ++ Lagrange Multipliers diff --git a/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf new file mode 100644 index 0000000..ca60cbf Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf differ 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 e69de29..a321caf 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 @@ -0,0 +1 @@ +FSF2020--Somnath Pandit diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif new file mode 100644 index 0000000..a2bfd9d Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif 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/area_under_func.py new file mode 100644 index 0000000..773840c --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/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/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/elementary_area.py new file mode 100644 index 0000000..362b6f8 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/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/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/non_rect_region.py new file mode 100644 index 0000000..793a000 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/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/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/surface.py new file mode 100644 index 0000000..a794f46 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/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/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/y_limit_dependent_on_x.py new file mode 100644 index 0000000..4894ebf --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/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 diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf new file mode 100644 index 0000000..04ed6d5 Binary files /dev/null and b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf differ diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/script1.py b/FSF-2020/calculus/series-and-transformations/Power Series/script1.py new file mode 100644 index 0000000..28eb07c --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/script1.py @@ -0,0 +1,128 @@ +from manimlib.imports import * + + +def formFormula(coeff_list,variable_list): + coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] + variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] + coeff_list[0].shift(2.2*UP+1.6*LEFT) + for i in range(0,3): + coeff_list[i].set_color(GOLD_A) + variable_list[i].next_to(coeff_list[i],buff=0.1) + if i!=2: + coeff_list[i+1].next_to(variable_list[i],buff=0.1) + dots=TextMobject("...") + dots.next_to(variable_list[2]) + expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) + expansion.scale(0.7) + return expansion + +class pieChart(Scene): + def construct(self): + circle1=Circle(radius=3,color=BLUE) + powerText=TextMobject("Power Series") + powerText.scale(0.8) + self.play(FadeIn(powerText)) + self.play(ShowCreation(circle1)) + self.wait(1) + + powerGroup=VGroup(circle1,powerText) + + self.play(ApplyMethod(powerGroup.scale,0.5)) + self.play(ApplyMethod(powerGroup.move_to,2.2*UP)) + self.wait(0.5) + expansion_power_coeff=[] + variables_power=[] + expansion_power=formFormula(expansion_power_coeff,variables_power) + self.play(ReplacementTransform(powerText,expansion_power)) + self.wait(1) + + circle2=Circle(radius=1.5) + circle2.shift(2.2*UP) + expansion_geo_coeff=[0]*3 + variables_geo=[0]*3 + arrow1_2=Line(start=0.7*UP,end=2.5*LEFT) + expansion_geo_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] + for i in range(0,3): + expansion_geo_coeff[i].set_color(GOLD_A) + variables_geo=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] + expansion_geo_coeff[0].shift(2.2*UP+1.6*LEFT) + for i in range(0,3): + variables_geo[i].next_to(expansion_geo_coeff[i],buff=0.1) + if i!=2: + expansion_geo_coeff[i+1].next_to(variables_geo[i],buff=0.1) + dots=TextMobject("...") + dots.next_to(variables_geo[2]) + expansion_geo=VGroup(expansion_geo_coeff[0],expansion_geo_coeff[1],expansion_geo_coeff[2],variables_geo[0],variables_geo[1],variables_geo[2],dots) + expansion_geo.scale(0.7) + + self.play(ApplyMethod(circle2.shift,4*LEFT+2.5*DOWN),ApplyMethod(expansion_geo.shift,4*LEFT+2.5*DOWN)) + self.add(arrow1_2) + self.wait(1) + + ones=[TextMobject("1"),TextMobject("1"),TextMobject("1")] + for i in range(0,3): + ones[i].set_color(GOLD_A) + ones[0].shift(0.3*DOWN,5*LEFT) + ones[1].next_to(ones[0],buff=0.5) + ones[2].next_to(ones[1],buff=0.7) + self.play(ReplacementTransform(expansion_geo_coeff[0],ones[0]),ReplacementTransform(expansion_geo_coeff[1],ones[1]),ReplacementTransform(expansion_geo_coeff[2],ones[2])) + self.wait(1) + expansion_geo=VGroup(ones[0],ones[1],ones[2],variables_geo[0],variables_geo[1],variables_geo[2],dots) + + expansion_geo_final=TextMobject("$1+x+{ x }^{ 2 }..$") + expansion_geo_final.scale(0.8) + expansion_geo_final.shift(0.3*DOWN+4*LEFT) + self.play(ReplacementTransform(expansion_geo,expansion_geo_final)) + self.wait(1) + + circle3=Circle(radius=1.5,color=GREEN) + circle3.shift(2.2*UP) + expansion_taylor_coeff=[0]*3 + variables_taylor=[0]*3 + arrow1_3=Line(start=0.7*UP,end=DOWN*0.3) + expansion_taylor_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] + for i in range(0,3): + expansion_taylor_coeff[i].set_color(GOLD_A) + variables_taylor=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] + expansion_taylor_coeff[0].shift(2.2*UP+1.6*LEFT) + for i in range(0,3): + variables_taylor[i].next_to(expansion_taylor_coeff[i],buff=0.1) + if i!=2: + expansion_taylor_coeff[i+1].next_to(variables_taylor[i],buff=0.1) + dots=TextMobject("...") + dots.next_to(variables_taylor[2]) + expansion_taylor=VGroup(expansion_taylor_coeff[0],expansion_taylor_coeff[1],expansion_taylor_coeff[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots) + expansion_taylor.scale(0.7) + + self.play(ApplyMethod(circle3.shift,4*DOWN),ApplyMethod(expansion_taylor.shift,4*DOWN)) + self.add(arrow1_3) + self.wait(1) + + differentials=[TextMobject("$f(0)$"),TextMobject("${ f'\left( 0 \\right) }$"),TextMobject("$\\frac { f''\left( 0 \\right) }{ 2! }$")] + for i in range(0,3): + differentials[i].set_color(GOLD_A) + differentials[0].shift(1.8*DOWN+1.15*LEFT) + differentials[1].shift(1.8*DOWN+0.45*LEFT) + differentials[2].shift(1.8*DOWN+0.45*RIGHT) + differentials[0].scale(0.35) + differentials[1].scale(0.35) + differentials[2].scale(0.35) + self.play(ReplacementTransform(expansion_taylor_coeff[0],differentials[0]),ReplacementTransform(expansion_taylor_coeff[1],differentials[1]),ReplacementTransform(expansion_taylor_coeff[2],differentials[2])) + self.wait(2) + expansion_taylor_final=VGroup(differentials[0],differentials[1],differentials[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots) + + self.play(FadeOut(expansion_geo_final),FadeOut(expansion_taylor_final)) + geoText=TextMobject("Geometric Series") + geoText.scale(0.7) + geoText.shift(4*LEFT+0.3*DOWN) + taylorText=TextMobject("Taylor Series") + taylorText.scale(0.7) + taylorText.shift(1.8*DOWN) + self.play(FadeIn(geoText),FadeIn(taylorText)) + self.wait(1) + + soOntext=TextMobject("So on..!") + soOntext.shift(4*RIGHT) + soOntext.scale(0.8) + self.play(FadeIn(soOntext)) + self.wait(2) diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/script2.py b/FSF-2020/calculus/series-and-transformations/Power Series/script2.py new file mode 100644 index 0000000..72356c6 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/script2.py @@ -0,0 +1,94 @@ +from manimlib.imports import * +import numpy as np + + +class convergence(Scene): + def construct(self): + originalFormula=TextMobject("$\sum _{ n=0 }^{ \infty }{ { a }_{ n }{ x }^{ n } }$") + originalFormula.set_color(RED) + self.play(Write(originalFormula)) + self.wait(1) + self.play(ApplyMethod(originalFormula.shift,2.7*UP)) + self.wait(1) + + terms=["$a_{ 0 }$","$a_{ 1 }x$","$a_{ 2 }x^{ 2 }$","$a_{ 3 }x^{ 3 }$","$a_{ 4 }x^{ 4 }$","$a_{ 5 }x^{ 5 }$","$a_{ 6 }x^{ 6 }$","$a_{ 7 }x^{ 7 }$","$a_{ 8 }x^{ 8 }$","$a_{ 9 }x^{ 9 }$","$a_{ 10 }x^{ 10 }$","$a_{ 11 }x^{ 11 }$"] + termsTogetherString="+".join(terms) + termsTogether=TextMobject(termsTogetherString+"...") + termsTogether.scale(0.8) + termsTogether.shift(2.7*UP) + self.play(ReplacementTransform(originalFormula,termsTogether)) + self.wait(1) + + termMobjectRect=[0]*12 + termMobject=TextMobject(terms[0]) + termMobject.shift(2.7*UP+6.2*LEFT) + for i in range(1,13): + termMobjectOld=termMobject + termMobjectOld.scale(0.8) + if(i<12): + termMobject=TextMobject(terms[i]) + termMobject.next_to(termMobjectOld) + if(i==1): + rectDefine=TextMobject("Here","each rectangle","represents the","value of the term") + rectDefine.set_color_by_tex_to_color_map({"each rectangle":BLUE,"value of the term":YELLOW}) + rectDefine.scale(0.7) + rectDefine.shift(3.2*DOWN) + self.play(Write(rectDefine)) + self.wait(1) + if(i==2): + ratio=TextMobject("If $\\frac { a_{ n+1 } }{ { a }_{ n } } < 1$") + ratio.set_color(RED) + ratio.scale(0.7) + ratio.move_to(3.2*DOWN) + inequality=TextMobject("$a_{ n+1 } < a_{ n }$") + inequality.set_color(RED) + inequality.scale(0.7) + inequality.move_to(3.2*DOWN) + self.play(FadeOut(rectDefine)) + self.play(Write(ratio)) + self.wait(1) + self.play(ReplacementTransform(ratio,inequality)) + self.wait(1) + #self.play(ApplyMethod(termMobjectOld.move_to,(2-0.3*i)*DOWN+RIGHT*0.2*i)) + termMobjectRect[i-1]=Rectangle(height=0.1,width=(5-0.4*i)) + termMobjectRect[i-1].move_to((2-0.2*i)*DOWN+RIGHT*0.2*i) + #rectangles[p] = termMobjectRect + #p+=1 + self.play(ReplacementTransform(termMobjectOld,termMobjectRect[i-1])) + + uparrow=TextMobject("$\\uparrow$") + uparrow.set_color(GREEN) + uparrow.scale(6) + uparrow.shift(4*RIGHT+0.5*DOWN) + self.play(ShowCreation(uparrow)) + self.wait(1) + + converges=TextMobject("Converges!") + converges.set_color(RED) + converges.scale(0.6) + converges.next_to(uparrow) + self.play(FadeIn(converges)) + self.wait(2) + + self.play(FadeOut(converges),FadeOut(uparrow),FadeOut(inequality)) + self.wait(0.5) + rect=VGroup(termMobjectRect[0],termMobjectRect[1],termMobjectRect[2],termMobjectRect[3],termMobjectRect[4],termMobjectRect[5],termMobjectRect[6],termMobjectRect[7],termMobjectRect[8],termMobjectRect[9],termMobjectRect[10],termMobjectRect[11]) + self.play(ApplyMethod(rect.scale,0.2)) + for i in range(0,12): + self.play(ApplyMethod(termMobjectRect[i].shift,i*0.04*DOWN+(11-(3-0.11*i)*i)*LEFT*0.3)) + func=TextMobject("$\\approx$","$f(x)$") + func.set_color_by_tex_to_color_map({"$f(x)$":RED}) + func.scale(0.8) + func.shift(DOWN+4.5*RIGHT+0.1*UP) + self.play(FadeIn(func)) + + rightarrow=TextMobject("$\\rightarrow$") + rightarrow.set_color(GREEN) + rightarrow.scale(4) + rightarrow.shift(2*DOWN) + converges=TextMobject("Hence even the","sum converges!") + converges.set_color_by_tex_to_color_map({"sum converges!":RED}) + converges.move_to(3*DOWN) + converges.scale(0.7) + self.play(Write(rightarrow),FadeIn(converges)) + self.wait(2) diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/script3.py b/FSF-2020/calculus/series-and-transformations/Power Series/script3.py new file mode 100644 index 0000000..f710f42 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/script3.py @@ -0,0 +1,156 @@ +from manimlib.imports import* +import math + +class intro(Scene): + def construct(self): + introText1=TextMobject("Let's analyse") + introText2=TextMobject("for") + function_main=TextMobject("$\sum { { (-1) }^{ n }{ x }^{ 2n } }$") + function_main.set_color(GREEN) + introText1.scale(1.2) + introText1.shift(2*UP) + introText2.scale(0.7) + introText2.shift(UP) + function_main.scale(2) + function_main.shift(DOWN) + function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") + function_expan.set_color(RED) + function_expan.scale(1.2) + function_expan.shift(2*UP) + + self.play(Write(introText1)) + self.play(FadeIn(introText2)) + self.wait(0.5) + self.play(Write(function_main)) + self.wait(1) + + self.play(FadeOut(introText1),FadeOut(introText2)) + self.play(ApplyMethod(function_main.shift,3*UP)) + self.wait(0.5) + self.play(ReplacementTransform(function_main,function_expan)) + self.wait(1) + self.play(ApplyMethod(function_expan.scale,0.5)) + function_expan.to_edge(UP+RIGHT) + self.play(ReplacementTransform(function_expan,function_expan)) + self.wait(1) + + +class graphScene(GraphScene): + CONFIG = { + "x_min": -8, + "x_max": 8, + "y_min": -8, + "y_max": 8, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-1, 2, 1), + "y_labeled_nums": range(0,2,1) + } + + def construct(self): + + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") + function_expan.set_color(RED) + function_expan.scale(0.6) + function_expan.to_edge(UP+RIGHT) + self.add(function_expan) + + self.setup_axes(animate=True) + + eqText=[TextMobject("$1$"),TextMobject("$1-{ x }^{ 2 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }$")] + for i in range(0,len(eqText)): + eqText[i].scale(0.6) + eqText[i].set_color(BLUE) + eqText[i].shift(ORIGIN+UP*2*y_each_unit+RIGHT*3.3*x_each_unit) + eqTextTerm=TextMobject("And so on..!") + eqTextTerm.set_color(BLUE) + eqTextTerm.scale(0.6) + eqTextTerm.shift(ORIGIN+UP*2*y_each_unit+3*RIGHT*x_each_unit) + equation1 = self.get_graph(lambda x : 1,color = RED,x_min = -8,x_max=8) + equation2 = self.get_graph(lambda x : 1-math.pow(x,2),color = RED,x_min = -1.7,x_max=1.7) + equation3 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4),color = RED,x_min = -1.6,x_max=1.6) + equation4 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6),color = RED,x_min = -1.45,x_max=1.45) + equation5 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8),color = RED,x_min = -1.35,x_max=1.35) + equation6 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10),color = RED,x_min = -1.3,x_max=1.3) + equation7 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12),color = RED,x_min = -1.25,x_max=1.25) + equation8 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14),color = RED,x_min = -1.2,x_max=1.2) + equation9 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16),color = RED,x_min = -1.15,x_max=1.15) + equation10 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.15,x_max=1.15) + + textBtwAnim1=TextMobject("Here the graph just","oscilates") + textBtwAnim1.set_color_by_tex_to_color_map({"oscilates":BLUE}) + textBtwAnim2=TextMobject("after","the","point","(as we add higher order terms)") + textBtwAnim2.set_color_by_tex_to_color_map({"after":BLUE,"point":YELLOW}) + textBtwAnim3=TextMobject("$x=1$") + textBtwAnim1.scale(0.4) + textBtwAnim2.scale(0.4) + textBtwAnim3.scale(1.2) + textBtwAnim1.shift(2.1*DOWN+4.3*RIGHT) + textBtwAnim2.shift(2.4*DOWN+4.1*RIGHT) + textBtwAnim3.shift(2.9*DOWN+4.3*RIGHT) + + self.play(ShowCreation(equation1),run_time=0.8) + self.add(eqText[0]) + self.wait(1) + self.play(ReplacementTransform(equation1,equation2),ReplacementTransform(eqText[0],eqText[1])) + self.wait(0.5) + self.play(ReplacementTransform(equation2,equation3),ReplacementTransform(eqText[1],eqText[2])) + self.wait(0.4) + self.play(ReplacementTransform(equation3,equation4),ReplacementTransform(eqText[2],eqText[3])) + self.wait(0.3) + self.play(FadeOut(eqText[3])) + self.play(FadeIn(eqTextTerm)) + self.play(Write(textBtwAnim1),Write(textBtwAnim2)) + self.play(FadeIn(textBtwAnim3)) + self.play(ReplacementTransform(equation4,equation5)) + self.wait(0.2) + self.play(ReplacementTransform(equation5,equation6)) + self.wait(0.2) + self.play(ReplacementTransform(equation6,equation7)) + self.wait(0.2) + self.play(ReplacementTransform(equation7,equation8)) + self.wait(0.2) + self.play(ReplacementTransform(equation8,equation9)) + self.wait(0.2) + self.play(ReplacementTransform(equation9,equation10)) + self.wait(1) + + self.play(FadeOut(textBtwAnim1),FadeOut(textBtwAnim2),FadeOut(textBtwAnim3),FadeOut(equation10),FadeOut(eqTextTerm)) + self.wait(1) + + convergeLine=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*RIGHT,color=WHITE) + divergeLineLeft=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*LEFT*8,color=RED) + divergeLineRight=Line(start=ORIGIN+x_each_unit*RIGHT,end=ORIGIN+x_each_unit*8*RIGHT,color=RED) + circle1=Circle(radius=0.01,color=PURPLE_E) + circle2=Circle(radius=0.01,color=PURPLE_E) + circle1.shift(ORIGIN+LEFT*x_each_unit) + circle2.shift(ORIGIN+RIGHT*x_each_unit) + convergeText=TextMobject("Converges") + divergeText1=TextMobject("Diverges") + divergeText2=TextMobject("Diverges") + convergeText.set_color(GREEN) + divergeText1.set_color(RED) + divergeText2.set_color(RED) + convergeText.scale(0.5) + divergeText1.scale(0.5) + divergeText2.scale(0.5) + convergeText.shift(1.6*UP) + divergeText1.shift(0.3*UP+1.5*LEFT) + divergeText2.shift(0.3*UP+1.5*RIGHT) + self.play(Write(divergeLineLeft),Write(divergeLineRight)) + self.play(FadeIn(convergeLine)) + self.wait(0.5) + self.play(FadeOut(self.axes)) + self.play(Write(circle1),Write(circle2)) + self.wait(0.5) + self.play(ApplyMethod(convergeLine.shift,1.3*UP),ApplyMethod(function_expan.shift,5*LEFT+DOWN)) + self.play(FadeIn(convergeText),FadeIn(divergeText1),FadeIn(divergeText2)) + self.wait(2) + diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/script4.py b/FSF-2020/calculus/series-and-transformations/Power Series/script4.py new file mode 100644 index 0000000..412d20c --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/script4.py @@ -0,0 +1,108 @@ +from manimlib.imports import * +import math + +class intro(Scene): + def construct(self): + introText1=TextMobject("Consider the","above","example..") + introText1.scale(0.8) + introText1.set_color_by_tex_to_color_map({"above":YELLOW}) + self.play(Write(introText1)) + self.wait(1) + +class graphScene(GraphScene,MovingCameraScene): + CONFIG = { + "x_min": -5, + "x_max": 5, + "y_min": -5, + "y_max": 5, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-1, 2, 1), + "y_labeled_nums": range(0,2,1), + "y_axis_height":7, + "x_axis_width":7 + } + + def setup(self): + GraphScene.setup(self) + MovingCameraScene.setup(self) + + def construct(self): + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") + function_expan.scale(0.6) + function_expan.set_color(RED) + function_expan.to_edge(UP+RIGHT) + self.add(function_expan) + + self.setup_axes() + + equation = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.1,x_max=1.1) + self.play(ShowCreation(equation)) + self.wait(1) + + dashLineLeft=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN) + dashLineRight=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN) + dashLineLeft.shift(ORIGIN+LEFT*x_each_unit) + dashLineRight.shift(ORIGIN+RIGHT*x_each_unit) + radiusLine=Line(start=ORIGIN,end=ORIGIN+RIGHT*x_each_unit) + rangeLine=Line(start=ORIGIN+LEFT*x_each_unit,end=ORIGIN+RIGHT*x_each_unit) + circle=Circle(radius=x_each_unit) + movingPoint=Circle(radius=0.025) + movingPoint.shift(ORIGIN+RIGHT*x_each_unit) + circleEq1=self.get_graph(lambda x:math.sqrt(1-x**2),color=BLUE,x_max=-1,x_min=1) + circleEq2=self.get_graph(lambda x:-math.sqrt(1-x**2),color=BLUE,x_max=1,x_min=-1) + + self.play(Write(dashLineLeft),Write(dashLineRight)) + self.wait(1) + + equation_updated=self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = GREEN,x_min = -1,x_max=1) + self.play(FadeOut(self.axes),ReplacementTransform(equation,equation_updated)) + self.wait(0.5) + self.play(Write(radiusLine)) + self.play(MoveAlongPath(movingPoint,circleEq1)) + self.play(MoveAlongPath(movingPoint,circleEq2)) + self.play(FadeIn(circle)) + self.wait(1) + + radiusText=TextMobject("Radius of convergence") + radiusText.scale(0.14) + radiusText.shift(ORIGIN+RIGHT*x_each_unit*0.45+DOWN*y_each_unit*0.2) + + self.play(Write(radiusText)) + self.wait(0.6) + + self.camera_frame.save_state() + self.camera_frame.set_width(5.5) + self.play(self.camera_frame.move_to, ORIGIN) + self.wait(1) + self.camera_frame.set_width(14) + self.wait(1.3) + + self.play(FadeOut(radiusText),FadeOut(circle),FadeOut(movingPoint)) + extendLine=Line(start=ORIGIN,end=ORIGIN+x_each_unit*LEFT) + self.play(Write(extendLine)) + doubleArrow=TextMobject("$\longleftrightarrow$") + doubleArrow.scale(1.6) + doubleArrow.set_color(BLUE) + doubleArrow.shift(ORIGIN+DOWN*y_each_unit*0.5) + self.play(FadeIn(doubleArrow)) + self.wait(1) + rangeText=TextMobject("Interval of convergence") + rangeText.scale(0.15) + rangeText.shift(ORIGIN+y_each_unit*DOWN) + self.play(Write(rangeText)) + self.wait(0.6) + + self.camera_frame.save_state() + self.camera_frame.set_width(5.5) + self.play(self.camera_frame.move_to, ORIGIN) + self.wait(1) + self.camera_frame.set_width(14) + self.wait(1.5) diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/script5.py b/FSF-2020/calculus/series-and-transformations/Power Series/script5.py new file mode 100644 index 0000000..e9681aa --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/script5.py @@ -0,0 +1,136 @@ +from manimlib.imports import * +import math + +class uniformlyConvergent(Scene): + def construct(self): + introText1=TextMobject("Again consider the","above","example") + introText2=TextMobject("Let","$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$","and","x=0.5 $\in$(-1,1)") + introText3=TextMobject("Lets analyse..","!") + introText1.scale(0.8) + introText2.scale(0.7) + introText3.scale(0.9) + introText3.shift(DOWN) + introText1.set_color_by_tex_to_color_map({"above":YELLOW}) + introText2.set_color_by_tex_to_color_map({"$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$":BLUE,"x=0.5 $\in$(-1,1)":YELLOW}) + introText3.set_color_by_tex_to_color_map({"!":GREEN}) + self.play(Write(introText1)) + self.wait(0.5) + self.play(FadeOut(introText1)) + self.play(Write(introText2)) + self.play(FadeIn(introText3)) + self.wait(2) + + +def gety(x,n): + ans=0 + for i in range(0,n+1): + if(i%2==0): + ans+=(math.pow(x,2*i)) + else: + ans-=(math.pow(x,2*i)) + return ans + +def makeSeries(x,points,x_each_unit,y_each_unit): + p=0 + for point in points: + y=gety(x,p) + point.shift(ORIGIN+RIGHT*x_each_unit*p+UP*y_each_unit*y) + p+=1 + +def makeLines(x,numPoints,x_each_unit,y_each_unit): + lines=[0]*numPoints + for i in range(0,numPoints-1): + y=gety(x,i) + y_next=gety(x,i+1) + lines[i]=Line(start=ORIGIN+RIGHT*x_each_unit*i+UP*y_each_unit*y,end=ORIGIN+RIGHT*x_each_unit*(i+1)+UP*y_each_unit*y_next,color=RED) + return lines + +class graphScene(GraphScene,MovingCameraScene): + CONFIG = { + "x_min": -6, + "x_max": 6, + "y_min": -5, + "y_max": 5, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$k$", + "y_axis_label": "$f(\\frac{1}{2})_k$", + "exclude_zero_label": True, + "x_axis_width":7, + "y_axis_height":7 + } + + def setup(self): + GraphScene.setup(self) + MovingCameraScene.setup(self) + + + def construct(self): + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + sequence=TextMobject("$1$ , $1-(0.5)^2$ , $1-(0.5)^2+(0.5)^4..$") + sequence.set_color(RED) + sequence.scale(0.35) + sequence.to_edge(UP+RIGHT) + formula=TextMobject("$f(x)_{ k }=\sum _{ i=0 }^{ k }{ (-1)^{ i }(x)^{ 2i } } $") + formula.set_color(PURPLE_C) + formula.scale(0.4) + formula.shift(5.3*RIGHT+3*UP) + fLine=Line(start=ORIGIN+x_each_unit*6*LEFT,end=ORIGIN+x_each_unit*6*RIGHT) + fLine.shift(ORIGIN+(4/5)*y_each_unit*UP) + fLineText=TextMobject("$g(0.5)=\\frac { 4 }{ 5 } $") + fLineText.set_color(RED) + fLineText.scale(0.3) + fLineText.shift(UP*1.2*y_each_unit+RIGHT*x_each_unit+4*LEFT) + points=[Dot(radius=0.03,color=BLUE) for i in range(0,6)] + makeSeries(0.5,points,x_each_unit,y_each_unit) + lines=makeLines(0.5,6,x_each_unit,y_each_unit) + + + self.add(sequence) + self.add(formula) + self.setup_axes(animate=True) + self.play(Write(fLine)) + self.add(fLineText) + for p in points: + self.add(p) + for p in range(0,5): + self.play(Write(lines[p])) + self.wait(0.5) + self.camera_frame.save_state() + self.camera_frame.set_width(0.6) + self.play(self.camera_frame.move_to, points[0]) + self.wait(0.4) + self.play(self.camera_frame.move_to, points[1]) + self.wait(0.4) + self.play(self.camera_frame.move_to, points[2]) + self.wait(0.3) + self.play(self.camera_frame.move_to, points[3]) + self.wait(1) + self.play(self.camera_frame.move_to,ORIGIN) + self.camera_frame.set_width(14) + self.wait(1) + + explanation1=TextMobject("Since the series","converges","to") + explanation1.set_color_by_tex_to_color_map({"converges":YELLOW}) + explanation2=TextMobject("$\\frac {4}{5}$") + explanation2.set_color(BLUE) + explanation3=TextMobject("Hence","$\\forall \epsilon>0$,","$\exists k$","such that,") + explanation3.set_color_by_tex_to_color_map({"$\\forall \epsilon>0$":BLUE,"$\exists k$":YELLOW}) + explanation4=TextMobject("$\left| { f\left( \\frac { 1 }{ 2 } \\right) }_{ k }-\\frac { 4 }{ 5 } \\right| <$","$\epsilon$") + explanation4.set_color_by_tex_to_color_map({"$\epsilon$":RED}) + explanation1.scale(0.5) + explanation3.scale(0.5) + explanation1.shift(1.8*DOWN+3.5*RIGHT) + explanation2.shift(2.4*DOWN+3.5*RIGHT) + explanation3.shift(1.8*DOWN+3.5*RIGHT) + explanation4.shift(2.4*DOWN+3.5*RIGHT) + + self.play(Write(explanation1)) + self.play(FadeIn(explanation2)) + self.wait(1) + self.play(FadeOut(explanation1),FadeOut(explanation2)) + self.play(Write(explanation3)) + self.play(Write(explanation4)) + self.wait(2) diff --git a/FSF-2020/calculus/series-and-transformations/README.md b/FSF-2020/calculus/series-and-transformations/README.md index e69de29..4747205 100644 --- a/FSF-2020/calculus/series-and-transformations/README.md +++ b/FSF-2020/calculus/series-and-transformations/README.md @@ -0,0 +1,13 @@ +Contributer: G Sri Harsha + +GitHub Handle: GSri30 + +Sub-Topics Covered: + diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf new file mode 100644 index 0000000..2096f52 Binary files /dev/null and b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf differ diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/script1.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/script1.py new file mode 100644 index 0000000..e83eff8 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/script1.py @@ -0,0 +1,198 @@ +from manimlib.imports import* +import math + +def formFormula(coeff_list,variable_list): + coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] + variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] + coeff_list[0].shift(2.2*UP+1.6*LEFT) + for i in range(0,3): + coeff_list[i].set_color(GOLD_A) + variable_list[i].next_to(coeff_list[i],buff=0.1) + if i!=2: + coeff_list[i+1].next_to(variable_list[i],buff=0.1) + dots=TextMobject("...") + dots.next_to(variable_list[2]) + expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) + #expansion.scale(0.7) + return expansion,coeff_list + +class intro(Scene): + def construct(self): + equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$") + equation.scale(2) + equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED}) + text=TextMobject("let $a=0$") + text.scale(0.7) + text.shift(DOWN) + + self.play(Write(equation)) + self.wait(0.5) + self.play(FadeIn(text)) + self.wait(0.7) + self.play(FadeOut(equation),FadeOut(text)) + +class graphScene(GraphScene): + CONFIG = { + "x_min": -8, + "x_max": 8, + "y_min": -8, + "y_max": 8, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-8, 8, 1), + } + def construct(self): + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + generalized_eq_coeff=[] + variables_eq=[] + eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq) + trText1=TextMobject("let $T_{ n }(x)$:=") + eq.next_to(trText1) + trTextGrup=VGroup(trText1,eq) + trTextGrup.scale(0.5) + trTextGrup.to_corner(UP+RIGHT) + self.play(Write(trTextGrup)) + self.setup_axes(animate=True) + + fx=TextMobject("${ e }^{ -x^{ 2 } }$") + fx.scale(0.5) + fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP) + mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8) + self.play(ShowCreation(mainfunction)) + self.play(FadeIn(fx)) + self.wait(1.4) + + coeff=[TextMobject("$1$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")] + coeff[0].shift(3.39*UP+4.88*RIGHT) + coeff[0].scale(0.5) + coeff[1].shift(3.39*UP+5.3*RIGHT) + coeff[1].scale(0.275) + coeff[2].shift(3.39*UP+5.98*RIGHT) + coeff[2].scale(0.28) + + for obj in coeff: + obj.set_color(GOLD_A) + + firstApprox=[self.get_graph(lambda x:1,color=BLUE)] + secondApprox=[self.get_graph(lambda x:1,color=BLUE), + self.get_graph(lambda x:x+1,color=BLUE), + self.get_graph(lambda x:-x+1,color=BLUE)] + thirdApprox=[self.get_graph(lambda x:1-2*math.pow(x,2),color=BLUE), + self.get_graph(lambda x:1-0.1*math.pow(x,2),color=BLUE), + self.get_graph(lambda x:1,color=BLUE), + self.get_graph(lambda x:1+0.1*math.pow(x,2),color=BLUE), + self.get_graph(lambda x:1+math.pow(x,2),color=BLUE)] + + firstGraph=self.get_graph(lambda x:1,color=BLUE) + secondGraph=self.get_graph(lambda x:1-math.pow(x,2),color=BLUE) + + bottomText1=TextMobject("The polynomial should","satisfy","the function at $x=0$") + bottomText2=TextMobject("This gives","$a_{ 0 }=1$") + bottomText3=TextMobject("Now it could be of","any slope!") + #show graphs of second approx + bottomText4=TextMobject("Hence the","slopes","should","even match") + #final graph + bottomText5=TextMobject("This gives","$a_{ 1 }=0$") + bottomText6=TextMobject("Since the rate of change of this slope","could vary") + #show third approx graphs + bottomText7=TextMobject("Hence the","rate of change of these slopes","should also be","same!") + #final graph + bottomText8=TextMobject("This gives","$a_{ 2 }=-1$") + + bottomText1.set_color_by_tex_to_color_map({"satisfy":YELLOW}) + bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=1$":BLUE}) + bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW}) + bottomText4.set_color_by_tex_to_color_map({"slopes":BLUE,"even match":YELLOW}) + bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=0$":BLUE}) + bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW}) + bottomText7.set_color_by_tex_to_color_map({"rate of change of these slopes":BLUE,"same!":YELLOW}) + bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=-1$":BLUE}) + + bottomText1.scale(0.4) + bottomText2.scale(0.5) + bottomText3.scale(0.4) + bottomText4.scale(0.4) + bottomText5.scale(0.5) + bottomText6.scale(0.4) + bottomText7.scale(0.4) + bottomText8.scale(0.5) + + bottomText1.shift(4.5*RIGHT+2.5*DOWN) + bottomText2.shift(4.5*RIGHT+2.5*DOWN) + bottomText3.shift(4.5*RIGHT+2.5*DOWN) + bottomText4.shift(4.5*RIGHT+2.5*DOWN) + bottomText5.shift(4.5*RIGHT+2.5*DOWN) + bottomText6.shift(4.5*RIGHT+2.5*DOWN) + bottomText7.shift(4.5*RIGHT+2.5*DOWN) + bottomText8.shift(4.5*RIGHT+2.5*DOWN) + + self.play(Write(bottomText1)) + self.wait(1) + self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2)) + #change coeff in tn(x) + self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText2,bottomText3)) + self.wait(0.5) + self.play(ReplacementTransform(firstApprox[0],secondApprox[1])) + self.wait(0.5) + self.play(ReplacementTransform(secondApprox[1],secondApprox[0])) + self.wait(0.5) + self.play(ReplacementTransform(secondApprox[0],secondApprox[2])) + self.wait(1) + self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2])) + self.wait(1) + self.play(Write(firstGraph),ReplacementTransform(bottomText4,bottomText5)) + #change a1 coeff + self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText5,bottomText6)) + self.play(ReplacementTransform(firstGraph,thirdApprox[0])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[2],thirdApprox[3])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText6,bottomText7)) + self.wait(1.5) + self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],secondGraph)) + self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2])) + self.wait(2) + + textFinal=TextMobject("And so on..!") + textFinal.scale(0.7) + textFinal.shift(4.5*RIGHT+2.5*DOWN) + self.play(ReplacementTransform(bottomText8,textFinal)) + self.wait(2.5) + + finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$") + finalFormula.scale(0.8) + finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$":RED}) + + self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(secondGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2])) + self.play(Write(finalFormula)) + self.wait(2) + # self.play(ReplacementTransform(secondApprox[2],secondApprox[3])) + # self.wait(0.5) + # self.play(ReplacementTransform(secondApprox[3],secondApprox[4])) + # self.wait(0.5) + # self.play(ReplacementTransform(secondApprox[4],secondApprox[5])) + # self.wait(0.5) + # self.play(ReplacementTransform(secondApprox[0],secondApprox[0])) + # self.wait(0.5) + # self.play(ReplacementTransform(secondApprox[0],secondApprox[0])) + # self.wait(0.5) + + + + diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/script2.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/script2.py new file mode 100644 index 0000000..b5d0a53 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/script2.py @@ -0,0 +1,195 @@ +from manimlib.imports import* +import math + + +class intro(Scene): + def construct(self): + equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$") + equation.scale(2) + equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED}) + text=TextMobject("at $a=1$") + text.scale(0.7) + text.shift(DOWN) + + shiftText=TextMobject("(Here we shift the origin to the point $x=1$)") + shiftText.scale(0.6) + shiftText.shift(2.4*DOWN) + + + self.play(Write(equation)) + self.wait(0.5) + self.play(FadeIn(text)) + self.wait(0.7) + self.play(Write(shiftText)) + self.wait(0.7) + self.play(FadeOut(equation),FadeOut(text),FadeOut(shiftText)) + + +def formFormula(coeff_list,variable_list): + coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] + variable_list=[TextMobject("+"),TextMobject("${ (x-1) }$+"),TextMobject("${ (x-1) }^{ 2 }$")] + coeff_list[0].shift(2.2*UP+1.6*LEFT) + for i in range(0,3): + coeff_list[i].set_color(GOLD_A) + variable_list[i].next_to(coeff_list[i],buff=0.1) + if i!=2: + coeff_list[i+1].next_to(variable_list[i],buff=0.1) + dots=TextMobject("...") + dots.next_to(variable_list[2]) + expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) + #expansion.scale(0.7) + return expansion,coeff_list + + +class graphScene(GraphScene): + CONFIG = { + "x_min": -8, + "x_max": 8, + "y_min": -8, + "y_max": 8, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-8, 8, 1), + } + def construct(self): + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + generalized_eq_coeff=[] + variables_eq=[] + eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq) + trText1=TextMobject("let $T_{ n }(x)$:=") + eq.next_to(trText1) + trTextGrup=VGroup(trText1,eq) + trTextGrup.scale(0.5) + trTextGrup.to_corner(UP+RIGHT) + self.play(Write(trTextGrup)) + self.setup_axes(animate=True) + + fx=TextMobject("${ e }^{ -x^{ 2 } }$") + fx.scale(0.5) + fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP) + mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8) + self.play(ShowCreation(mainfunction)) + self.play(FadeIn(fx)) + self.wait(1.4) + + coeff=[TextMobject("$e^{-1}$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")] + coeff[0].shift(3.33*UP+3.65*RIGHT) + coeff[0].scale(0.45) + coeff[1].shift(3.33*UP+4.13*RIGHT) + coeff[1].scale(0.275) + coeff[2].shift(3.33*UP+5.36*RIGHT) + coeff[2].scale(0.28) + + for obj in coeff: + obj.set_color(GOLD_A) + + firstApprox=[self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)] + secondApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5), + self.get_graph(lambda x:math.exp(-1)+3*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5), + self.get_graph(lambda x:math.exp(-1)-4*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)] + thirdApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), + self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-0.1*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), + self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_max=5.5,x_min=-5.5), + self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+0.5*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), + self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5)] + + firstGraph=self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5) + secondGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5) + thirdGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5) + + bottomText1=TextMobject("Apply","$f(1)=T_{n}(1)$") + bottomText2=TextMobject("This gives","$a_{ 0 }=e^{-1}$") + bottomText3=TextMobject("Now it could be of","any slope!") + #show graphs of second approx + bottomText4=TextMobject("Hence","apply","$f'(1)=T_{n}'(1)$") + #final graph + bottomText5=TextMobject("This gives","$a_{ 1 }=-2e^{-1}$") + bottomText6=TextMobject("Since the rate of change of this slope","could vary") + #show third approx graphs + bottomText7=TextMobject("Hence also","apply","$f''(1)=T_{ n }''(1)$") + #final graph + bottomText8=TextMobject("This gives","$a_{ 2 }=e^{-1}$") + + bottomText1.set_color_by_tex_to_color_map({"Apply":YELLOW}) + bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=e^{-1}$":BLUE}) + bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW}) + bottomText4.set_color_by_tex_to_color_map({"apply":YELLOW}) + bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=-2e^{-1}$":BLUE}) + bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW}) + bottomText7.set_color_by_tex_to_color_map({"apply":YELLOW}) + bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=e^{-1}$":BLUE}) + + bottomText1.scale(0.4) + bottomText2.scale(0.5) + bottomText3.scale(0.4) + bottomText4.scale(0.4) + bottomText5.scale(0.5) + bottomText6.scale(0.4) + bottomText7.scale(0.4) + bottomText8.scale(0.5) + + bottomText1.shift(4.5*RIGHT+2.5*DOWN) + bottomText2.shift(4.5*RIGHT+2.5*DOWN) + bottomText3.shift(4.5*RIGHT+2.5*DOWN) + bottomText4.shift(4.5*RIGHT+2.5*DOWN) + bottomText5.shift(4.5*RIGHT+2.5*DOWN) + bottomText6.shift(4.5*RIGHT+2.5*DOWN) + bottomText7.shift(4.5*RIGHT+2.5*DOWN) + bottomText8.shift(4.5*RIGHT+2.5*DOWN) + + self.play(Write(bottomText1)) + self.wait(1) + self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2)) + #change coeff in tn(x) + self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText2,bottomText3)) + self.wait(0.5) + self.play(ReplacementTransform(firstApprox[0],secondApprox[1])) + self.wait(0.5) + self.play(ReplacementTransform(secondApprox[1],secondApprox[2])) + # self.wait(0.5) + # self.play(ReplacementTransform(secondApprox[2],secondApprox[0])) + self.wait(1) + self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2])) + self.wait(1) + self.play(Write(secondGraph),ReplacementTransform(bottomText4,bottomText5)) + #change a1 coeff + self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText5,bottomText6)) + self.play(ReplacementTransform(secondGraph,thirdApprox[0])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1])) + # self.wait(0.6) + # self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[1],thirdApprox[3])) + self.wait(0.6) + self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4])) + self.wait(1.5) + self.play(ReplacementTransform(bottomText6,bottomText7)) + self.wait(1.5) + self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],thirdGraph)) + self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2])) + self.wait(2) + + textFinal=TextMobject("And so on..!") + textFinal.scale(0.7) + textFinal.shift(4.5*RIGHT+2.5*DOWN) + self.play(ReplacementTransform(bottomText8,textFinal)) + self.wait(2.5) + + finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$") + finalFormula.scale(0.8) + finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$":RED}) + + self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(thirdGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2])) + self.play(Write(finalFormula)) + self.wait(2) \ No newline at end of file diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/script3.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/script3.py new file mode 100644 index 0000000..a2870d4 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/script3.py @@ -0,0 +1,111 @@ +from manimlib.imports import* +import math + + +class graphScene(GraphScene): + CONFIG = { + "x_min": -8, + "x_max": 8, + "y_min": -8, + "y_max": 8, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-8, 8, 1), + } + def construct(self): + + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + self.setup_axes(animate=True) + + lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8) + + bottomText1=TextMobject("Apply $f(x)=T_{n}(x)$") + bottomText2=TextMobject("Then apply $f'(x)=T_{n}'(x)$") + bottomText3=TextMobject("Then apply $f''(x)=T_{n}''(x)$") + bottomText4=TextMobject("and so on..") + + bottomText1.scale(0.5) + bottomText2.scale(0.5) + bottomText3.scale(0.5) + bottomText4.scale(0.5) + + bottomText1.shift(3*RIGHT+2*DOWN) + bottomText2.shift(3*RIGHT+2*DOWN) + bottomText3.shift(3*RIGHT+2*DOWN) + bottomText4.shift(3*RIGHT+2*DOWN) + + equations=[self.get_graph(lambda x:math.log2(2),color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2,color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8,color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24,color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64,color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160,color=BLUE), + self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE)] + + terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")] + for obj in terms: + obj.scale(0.5) + + terms[0].shift(3*UP+3*RIGHT) + terms[1].next_to(terms[0],buff=0.1) + terms[2].next_to(terms[1],buff=0.1) + terms[3].next_to(terms[2],buff=0.1) + terms[4].next_to(terms[3],buff=0.1) + + self.play(ShowCreation(lnx)) + self.wait(1) + self.play(Write(bottomText1)) + self.wait(0.5) + self.play(ShowCreation(equations[0]),Write(terms[0]),Write(terms[1])) + self.wait(1) + self.play(ReplacementTransform(bottomText1,bottomText2)) + self.wait(0.5) + self.play(ReplacementTransform(equations[0],equations[1]),Write(terms[2])) + self.wait(1) + self.play(ReplacementTransform(bottomText2,bottomText3)) + self.wait(0.5) + self.play(ReplacementTransform(equations[1],equations[2]),Write(terms[3])) + self.wait(1) + self.play(ReplacementTransform(bottomText3,bottomText4),Write(terms[4])) + self.wait(1.5) + + self.play(FadeOut(terms[0]),FadeOut(terms[1]),FadeOut(terms[2]),FadeOut(terms[3]),FadeOut(terms[4]),FadeOut(bottomText4)) + + dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN) + dline.shift(ORIGIN+x_each_unit*4*RIGHT) + + bottomText5=TextMobject("Here","after $x=4$",", the graph","continuously diverges away","from $ln(x)$") + bottomText5.scale(0.3) + bottomText5.shift(4.5*RIGHT+2*DOWN) + bottomText5.set_color_by_tex_to_color_map({"after $x=4$":YELLOW,"continuously diverges away":BLUE}) + + self.play(Write(bottomText5),Write(dline)) + self.wait(1) + self.play(ReplacementTransform(equations[2],equations[3])) + self.wait(0.3) + self.play(ReplacementTransform(equations[3],equations[4])) + self.wait(0.3) + self.play(ReplacementTransform(equations[4],equations[5])) + self.wait(0.3) + self.play(ReplacementTransform(equations[5],equations[6]),FadeOut(bottomText5)) + self.wait(1) + + circle=Circle(radius=ORIGIN+x_each_unit*2,color=PURPLE_E) + circle.shift(ORIGIN+RIGHT*x_each_unit*2) + radiusLine=Line(start=ORIGIN+x_each_unit*RIGHT*2,end=ORIGIN+x_each_unit*4*RIGHT,color=PURPLE_E) + radius=TextMobject("$R$") + radius.set_color(RED) + radius.scale(0.5) + radius.shift(ORIGIN+RIGHT*x_each_unit*2.45+DOWN*y_each_unit*0.6) + + self.play(FadeOut(equations[6]),Write(circle)) + self.wait(0.6) + self.play(Write(radiusLine)) + self.play(FadeIn(radius)) + self.wait(2) \ No newline at end of file diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/script4.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/script4.py new file mode 100644 index 0000000..1f41c97 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/script4.py @@ -0,0 +1,82 @@ +from manimlib.imports import* +import math + + +class graphScene(GraphScene): + CONFIG = { + "x_min": -8, + "x_max": 8, + "y_min": -8, + "y_max": 8, + "graph_origin": ORIGIN, + "function_color": RED, + "axes_color": GREEN, + "x_axis_label": "$x$", + "y_axis_label": "$y$", + "exclude_zero_label": True, + "x_labeled_nums": range(-8, 8, 1), + } + def construct(self): + + x_each_unit = self.x_axis_width / (self.x_max - self.x_min) + y_each_unit = self.y_axis_height / (self.y_max - self.y_min) + + self.setup_axes(animate=True) + lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8) + equation=self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE) + + terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")] + for obj in terms: + obj.scale(0.5) + + terms[0].shift(3*UP+3*RIGHT) + terms[1].next_to(terms[0],buff=0.1) + terms[2].next_to(terms[1],buff=0.1) + terms[3].next_to(terms[2],buff=0.1) + terms[4].next_to(terms[3],buff=0.1) + + self.play(ShowCreation(lnx)) + self.wait(1) + self.play(FadeIn(equation),FadeIn(terms[0]),FadeIn(terms[1]),FadeIn(terms[2]),FadeIn(terms[3]),FadeIn(terms[4])) + self.wait(1) + + bottomText1=TextMobject("$R_{n}(x)=\\frac { d }{ dx } ($","area bounded","$)$") + + bottomText1.set_color_by_tex_to_color_map({"area bounded":ORANGE}) + #bottomText2.set_color_by_tex_to_color_map({"area bounded":BLUE}) + arrow=TextMobject("$\downarrow$") + arrow.scale(2.5) + arrow.shift(ORIGIN+x_each_unit*RIGHT*9.5+UP*y_each_unit) + increasingText=TextMobject("Increases!") + increasingText.set_color(GREEN) + followupText=TextMobject("as n increase!") + followupText.scale(0.3) + followupText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.1) + increasingText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.6) + increasingText.scale(0.4) + + bottomText1.scale(0.5) + #bottomText2.scale(0.5) + #bottomText3.scale(0.5) + + bottomText1.shift(3.5*LEFT+2*DOWN) + #bottomText2.shift(3.5*LEFT+2.4*DOWN) + #bottomText3.shift(3.5*LEFT+2.8*DOWN) + + dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN) + dline.shift(ORIGIN+x_each_unit*4*RIGHT) + + area1=self.get_riemann_rectangles(lnx,x_max=8,x_min=4,dx=0.01,start_color=BLUE,end_color=RED,stroke_width=0,fill_opacity=0.8) + area2=self.get_riemann_rectangles(equation,x_max=5.2,x_min=4,dx=0.025,start_color=BLACK,end_color=BLACK,stroke_width=0,fill_opacity=1) + + self.play(Write(dline)) + self.wait(0.5) + self.play(ShowCreation(area1),ShowCreation(area2),Write(bottomText1)) + # self.play(Write(bottomText2)) + # self.play(FadeIn(bottomText3)) + self.play(Write(arrow)) + self.wait(0.7) + self.play(Write(increasingText)) + self.play(FadeIn(followupText)) + self.wait(2) + \ No newline at end of file diff --git a/FSF-2020/div-curl-grad-and-all-that/README.md b/FSF-2020/div-curl-grad-and-all-that/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/geometry-of-planes-and-curves/README.md b/FSF-2020/geometry-of-planes-and-curves/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/integrals-of-multivariable-functions/README.md b/FSF-2020/integrals-of-multivariable-functions/README.md deleted file mode 100644 index a321caf..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/README.md +++ /dev/null @@ -1 +0,0 @@ -FSF2020--Somnath Pandit diff --git a/FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif b/FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif deleted file mode 100644 index a2bfd9d..0000000 Binary files a/FSF-2020/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif and /dev/null differ diff --git a/FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py deleted file mode 100644 index 773840c..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/double-integrals/area_under_func.py +++ /dev/null @@ -1,73 +0,0 @@ -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/double-integrals/elementary_area.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/elementary_area.py deleted file mode 100644 index 362b6f8..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/double-integrals/elementary_area.py +++ /dev/null @@ -1,144 +0,0 @@ -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/double-integrals/non_rect_region.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/non_rect_region.py deleted file mode 100644 index 793a000..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/double-integrals/non_rect_region.py +++ /dev/null @@ -1,154 +0,0 @@ -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/double-integrals/surface.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/surface.py deleted file mode 100644 index a794f46..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/double-integrals/surface.py +++ /dev/null @@ -1,236 +0,0 @@ -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/double-integrals/y_limit_dependent_on_x.py b/FSF-2020/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py deleted file mode 100644 index 4894ebf..0000000 --- a/FSF-2020/integrals-of-multivariable-functions/double-integrals/y_limit_dependent_on_x.py +++ /dev/null @@ -1,113 +0,0 @@ -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 diff --git a/FSF-2020/intro-to-calculus/README.md b/FSF-2020/intro-to-calculus/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/linear-algebra/linear-transformations/README.md b/FSF-2020/linear-algebra/linear-transformations/README.md new file mode 100644 index 0000000..692201e --- /dev/null +++ b/FSF-2020/linear-algebra/linear-transformations/README.md @@ -0,0 +1,9 @@ +# Contributer: Archit Sangal +My Github Account : architsangal +

+## Sub-Topics Covered: ++ Vector Space Homomorphisms (Linear Maps) ++ The Four Fundamental Subspaces ++ Rank-Nullity Theorem ++ Orthonormal basis ++ Gramm-Schmidt Orthogonalization Process diff --git a/FSF-2020/linear-algebra/vector-spaces/README.md b/FSF-2020/linear-algebra/vector-spaces/README.md new file mode 100644 index 0000000..e69de29 diff --git a/FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py b/FSF-2020/linear-transformations/Linear Transformations (Linear Maps)/Animation.py deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/linear-transformations/README.md b/FSF-2020/linear-transformations/README.md deleted file mode 100644 index 692201e..0000000 --- a/FSF-2020/linear-transformations/README.md +++ /dev/null @@ -1,9 +0,0 @@ -# Contributer: Archit Sangal -My Github Account : architsangal -

-## Sub-Topics Covered: -+ Vector Space Homomorphisms (Linear Maps) -+ The Four Fundamental Subspaces -+ Rank-Nullity Theorem -+ Orthonormal basis -+ Gramm-Schmidt Orthogonalization Process diff --git a/FSF-2020/multivariable-functions-and-paritial-derivatives/README.md b/FSF-2020/multivariable-functions-and-paritial-derivatives/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/series-and-transformations/Power Series/PowerSeriesQuestions.pdf b/FSF-2020/series-and-transformations/Power Series/PowerSeriesQuestions.pdf deleted file mode 100644 index 04ed6d5..0000000 Binary files a/FSF-2020/series-and-transformations/Power Series/PowerSeriesQuestions.pdf and /dev/null differ diff --git a/FSF-2020/series-and-transformations/Power Series/script1.py b/FSF-2020/series-and-transformations/Power Series/script1.py deleted file mode 100644 index 28eb07c..0000000 --- a/FSF-2020/series-and-transformations/Power Series/script1.py +++ /dev/null @@ -1,128 +0,0 @@ -from manimlib.imports import * - - -def formFormula(coeff_list,variable_list): - coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] - variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] - coeff_list[0].shift(2.2*UP+1.6*LEFT) - for i in range(0,3): - coeff_list[i].set_color(GOLD_A) - variable_list[i].next_to(coeff_list[i],buff=0.1) - if i!=2: - coeff_list[i+1].next_to(variable_list[i],buff=0.1) - dots=TextMobject("...") - dots.next_to(variable_list[2]) - expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) - expansion.scale(0.7) - return expansion - -class pieChart(Scene): - def construct(self): - circle1=Circle(radius=3,color=BLUE) - powerText=TextMobject("Power Series") - powerText.scale(0.8) - self.play(FadeIn(powerText)) - self.play(ShowCreation(circle1)) - self.wait(1) - - powerGroup=VGroup(circle1,powerText) - - self.play(ApplyMethod(powerGroup.scale,0.5)) - self.play(ApplyMethod(powerGroup.move_to,2.2*UP)) - self.wait(0.5) - expansion_power_coeff=[] - variables_power=[] - expansion_power=formFormula(expansion_power_coeff,variables_power) - self.play(ReplacementTransform(powerText,expansion_power)) - self.wait(1) - - circle2=Circle(radius=1.5) - circle2.shift(2.2*UP) - expansion_geo_coeff=[0]*3 - variables_geo=[0]*3 - arrow1_2=Line(start=0.7*UP,end=2.5*LEFT) - expansion_geo_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] - for i in range(0,3): - expansion_geo_coeff[i].set_color(GOLD_A) - variables_geo=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] - expansion_geo_coeff[0].shift(2.2*UP+1.6*LEFT) - for i in range(0,3): - variables_geo[i].next_to(expansion_geo_coeff[i],buff=0.1) - if i!=2: - expansion_geo_coeff[i+1].next_to(variables_geo[i],buff=0.1) - dots=TextMobject("...") - dots.next_to(variables_geo[2]) - expansion_geo=VGroup(expansion_geo_coeff[0],expansion_geo_coeff[1],expansion_geo_coeff[2],variables_geo[0],variables_geo[1],variables_geo[2],dots) - expansion_geo.scale(0.7) - - self.play(ApplyMethod(circle2.shift,4*LEFT+2.5*DOWN),ApplyMethod(expansion_geo.shift,4*LEFT+2.5*DOWN)) - self.add(arrow1_2) - self.wait(1) - - ones=[TextMobject("1"),TextMobject("1"),TextMobject("1")] - for i in range(0,3): - ones[i].set_color(GOLD_A) - ones[0].shift(0.3*DOWN,5*LEFT) - ones[1].next_to(ones[0],buff=0.5) - ones[2].next_to(ones[1],buff=0.7) - self.play(ReplacementTransform(expansion_geo_coeff[0],ones[0]),ReplacementTransform(expansion_geo_coeff[1],ones[1]),ReplacementTransform(expansion_geo_coeff[2],ones[2])) - self.wait(1) - expansion_geo=VGroup(ones[0],ones[1],ones[2],variables_geo[0],variables_geo[1],variables_geo[2],dots) - - expansion_geo_final=TextMobject("$1+x+{ x }^{ 2 }..$") - expansion_geo_final.scale(0.8) - expansion_geo_final.shift(0.3*DOWN+4*LEFT) - self.play(ReplacementTransform(expansion_geo,expansion_geo_final)) - self.wait(1) - - circle3=Circle(radius=1.5,color=GREEN) - circle3.shift(2.2*UP) - expansion_taylor_coeff=[0]*3 - variables_taylor=[0]*3 - arrow1_3=Line(start=0.7*UP,end=DOWN*0.3) - expansion_taylor_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] - for i in range(0,3): - expansion_taylor_coeff[i].set_color(GOLD_A) - variables_taylor=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] - expansion_taylor_coeff[0].shift(2.2*UP+1.6*LEFT) - for i in range(0,3): - variables_taylor[i].next_to(expansion_taylor_coeff[i],buff=0.1) - if i!=2: - expansion_taylor_coeff[i+1].next_to(variables_taylor[i],buff=0.1) - dots=TextMobject("...") - dots.next_to(variables_taylor[2]) - expansion_taylor=VGroup(expansion_taylor_coeff[0],expansion_taylor_coeff[1],expansion_taylor_coeff[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots) - expansion_taylor.scale(0.7) - - self.play(ApplyMethod(circle3.shift,4*DOWN),ApplyMethod(expansion_taylor.shift,4*DOWN)) - self.add(arrow1_3) - self.wait(1) - - differentials=[TextMobject("$f(0)$"),TextMobject("${ f'\left( 0 \\right) }$"),TextMobject("$\\frac { f''\left( 0 \\right) }{ 2! }$")] - for i in range(0,3): - differentials[i].set_color(GOLD_A) - differentials[0].shift(1.8*DOWN+1.15*LEFT) - differentials[1].shift(1.8*DOWN+0.45*LEFT) - differentials[2].shift(1.8*DOWN+0.45*RIGHT) - differentials[0].scale(0.35) - differentials[1].scale(0.35) - differentials[2].scale(0.35) - self.play(ReplacementTransform(expansion_taylor_coeff[0],differentials[0]),ReplacementTransform(expansion_taylor_coeff[1],differentials[1]),ReplacementTransform(expansion_taylor_coeff[2],differentials[2])) - self.wait(2) - expansion_taylor_final=VGroup(differentials[0],differentials[1],differentials[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots) - - self.play(FadeOut(expansion_geo_final),FadeOut(expansion_taylor_final)) - geoText=TextMobject("Geometric Series") - geoText.scale(0.7) - geoText.shift(4*LEFT+0.3*DOWN) - taylorText=TextMobject("Taylor Series") - taylorText.scale(0.7) - taylorText.shift(1.8*DOWN) - self.play(FadeIn(geoText),FadeIn(taylorText)) - self.wait(1) - - soOntext=TextMobject("So on..!") - soOntext.shift(4*RIGHT) - soOntext.scale(0.8) - self.play(FadeIn(soOntext)) - self.wait(2) diff --git a/FSF-2020/series-and-transformations/Power Series/script2.py b/FSF-2020/series-and-transformations/Power Series/script2.py deleted file mode 100644 index 72356c6..0000000 --- a/FSF-2020/series-and-transformations/Power Series/script2.py +++ /dev/null @@ -1,94 +0,0 @@ -from manimlib.imports import * -import numpy as np - - -class convergence(Scene): - def construct(self): - originalFormula=TextMobject("$\sum _{ n=0 }^{ \infty }{ { a }_{ n }{ x }^{ n } }$") - originalFormula.set_color(RED) - self.play(Write(originalFormula)) - self.wait(1) - self.play(ApplyMethod(originalFormula.shift,2.7*UP)) - self.wait(1) - - terms=["$a_{ 0 }$","$a_{ 1 }x$","$a_{ 2 }x^{ 2 }$","$a_{ 3 }x^{ 3 }$","$a_{ 4 }x^{ 4 }$","$a_{ 5 }x^{ 5 }$","$a_{ 6 }x^{ 6 }$","$a_{ 7 }x^{ 7 }$","$a_{ 8 }x^{ 8 }$","$a_{ 9 }x^{ 9 }$","$a_{ 10 }x^{ 10 }$","$a_{ 11 }x^{ 11 }$"] - termsTogetherString="+".join(terms) - termsTogether=TextMobject(termsTogetherString+"...") - termsTogether.scale(0.8) - termsTogether.shift(2.7*UP) - self.play(ReplacementTransform(originalFormula,termsTogether)) - self.wait(1) - - termMobjectRect=[0]*12 - termMobject=TextMobject(terms[0]) - termMobject.shift(2.7*UP+6.2*LEFT) - for i in range(1,13): - termMobjectOld=termMobject - termMobjectOld.scale(0.8) - if(i<12): - termMobject=TextMobject(terms[i]) - termMobject.next_to(termMobjectOld) - if(i==1): - rectDefine=TextMobject("Here","each rectangle","represents the","value of the term") - rectDefine.set_color_by_tex_to_color_map({"each rectangle":BLUE,"value of the term":YELLOW}) - rectDefine.scale(0.7) - rectDefine.shift(3.2*DOWN) - self.play(Write(rectDefine)) - self.wait(1) - if(i==2): - ratio=TextMobject("If $\\frac { a_{ n+1 } }{ { a }_{ n } } < 1$") - ratio.set_color(RED) - ratio.scale(0.7) - ratio.move_to(3.2*DOWN) - inequality=TextMobject("$a_{ n+1 } < a_{ n }$") - inequality.set_color(RED) - inequality.scale(0.7) - inequality.move_to(3.2*DOWN) - self.play(FadeOut(rectDefine)) - self.play(Write(ratio)) - self.wait(1) - self.play(ReplacementTransform(ratio,inequality)) - self.wait(1) - #self.play(ApplyMethod(termMobjectOld.move_to,(2-0.3*i)*DOWN+RIGHT*0.2*i)) - termMobjectRect[i-1]=Rectangle(height=0.1,width=(5-0.4*i)) - termMobjectRect[i-1].move_to((2-0.2*i)*DOWN+RIGHT*0.2*i) - #rectangles[p] = termMobjectRect - #p+=1 - self.play(ReplacementTransform(termMobjectOld,termMobjectRect[i-1])) - - uparrow=TextMobject("$\\uparrow$") - uparrow.set_color(GREEN) - uparrow.scale(6) - uparrow.shift(4*RIGHT+0.5*DOWN) - self.play(ShowCreation(uparrow)) - self.wait(1) - - converges=TextMobject("Converges!") - converges.set_color(RED) - converges.scale(0.6) - converges.next_to(uparrow) - self.play(FadeIn(converges)) - self.wait(2) - - self.play(FadeOut(converges),FadeOut(uparrow),FadeOut(inequality)) - self.wait(0.5) - rect=VGroup(termMobjectRect[0],termMobjectRect[1],termMobjectRect[2],termMobjectRect[3],termMobjectRect[4],termMobjectRect[5],termMobjectRect[6],termMobjectRect[7],termMobjectRect[8],termMobjectRect[9],termMobjectRect[10],termMobjectRect[11]) - self.play(ApplyMethod(rect.scale,0.2)) - for i in range(0,12): - self.play(ApplyMethod(termMobjectRect[i].shift,i*0.04*DOWN+(11-(3-0.11*i)*i)*LEFT*0.3)) - func=TextMobject("$\\approx$","$f(x)$") - func.set_color_by_tex_to_color_map({"$f(x)$":RED}) - func.scale(0.8) - func.shift(DOWN+4.5*RIGHT+0.1*UP) - self.play(FadeIn(func)) - - rightarrow=TextMobject("$\\rightarrow$") - rightarrow.set_color(GREEN) - rightarrow.scale(4) - rightarrow.shift(2*DOWN) - converges=TextMobject("Hence even the","sum converges!") - converges.set_color_by_tex_to_color_map({"sum converges!":RED}) - converges.move_to(3*DOWN) - converges.scale(0.7) - self.play(Write(rightarrow),FadeIn(converges)) - self.wait(2) diff --git a/FSF-2020/series-and-transformations/Power Series/script3.py b/FSF-2020/series-and-transformations/Power Series/script3.py deleted file mode 100644 index f710f42..0000000 --- a/FSF-2020/series-and-transformations/Power Series/script3.py +++ /dev/null @@ -1,156 +0,0 @@ -from manimlib.imports import* -import math - -class intro(Scene): - def construct(self): - introText1=TextMobject("Let's analyse") - introText2=TextMobject("for") - function_main=TextMobject("$\sum { { (-1) }^{ n }{ x }^{ 2n } }$") - function_main.set_color(GREEN) - introText1.scale(1.2) - introText1.shift(2*UP) - introText2.scale(0.7) - introText2.shift(UP) - function_main.scale(2) - function_main.shift(DOWN) - function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") - function_expan.set_color(RED) - function_expan.scale(1.2) - function_expan.shift(2*UP) - - self.play(Write(introText1)) - self.play(FadeIn(introText2)) - self.wait(0.5) - self.play(Write(function_main)) - self.wait(1) - - self.play(FadeOut(introText1),FadeOut(introText2)) - self.play(ApplyMethod(function_main.shift,3*UP)) - self.wait(0.5) - self.play(ReplacementTransform(function_main,function_expan)) - self.wait(1) - self.play(ApplyMethod(function_expan.scale,0.5)) - function_expan.to_edge(UP+RIGHT) - self.play(ReplacementTransform(function_expan,function_expan)) - self.wait(1) - - -class graphScene(GraphScene): - CONFIG = { - "x_min": -8, - "x_max": 8, - "y_min": -8, - "y_max": 8, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-1, 2, 1), - "y_labeled_nums": range(0,2,1) - } - - def construct(self): - - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") - function_expan.set_color(RED) - function_expan.scale(0.6) - function_expan.to_edge(UP+RIGHT) - self.add(function_expan) - - self.setup_axes(animate=True) - - eqText=[TextMobject("$1$"),TextMobject("$1-{ x }^{ 2 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }$")] - for i in range(0,len(eqText)): - eqText[i].scale(0.6) - eqText[i].set_color(BLUE) - eqText[i].shift(ORIGIN+UP*2*y_each_unit+RIGHT*3.3*x_each_unit) - eqTextTerm=TextMobject("And so on..!") - eqTextTerm.set_color(BLUE) - eqTextTerm.scale(0.6) - eqTextTerm.shift(ORIGIN+UP*2*y_each_unit+3*RIGHT*x_each_unit) - equation1 = self.get_graph(lambda x : 1,color = RED,x_min = -8,x_max=8) - equation2 = self.get_graph(lambda x : 1-math.pow(x,2),color = RED,x_min = -1.7,x_max=1.7) - equation3 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4),color = RED,x_min = -1.6,x_max=1.6) - equation4 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6),color = RED,x_min = -1.45,x_max=1.45) - equation5 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8),color = RED,x_min = -1.35,x_max=1.35) - equation6 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10),color = RED,x_min = -1.3,x_max=1.3) - equation7 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12),color = RED,x_min = -1.25,x_max=1.25) - equation8 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14),color = RED,x_min = -1.2,x_max=1.2) - equation9 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16),color = RED,x_min = -1.15,x_max=1.15) - equation10 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.15,x_max=1.15) - - textBtwAnim1=TextMobject("Here the graph just","oscilates") - textBtwAnim1.set_color_by_tex_to_color_map({"oscilates":BLUE}) - textBtwAnim2=TextMobject("after","the","point","(as we add higher order terms)") - textBtwAnim2.set_color_by_tex_to_color_map({"after":BLUE,"point":YELLOW}) - textBtwAnim3=TextMobject("$x=1$") - textBtwAnim1.scale(0.4) - textBtwAnim2.scale(0.4) - textBtwAnim3.scale(1.2) - textBtwAnim1.shift(2.1*DOWN+4.3*RIGHT) - textBtwAnim2.shift(2.4*DOWN+4.1*RIGHT) - textBtwAnim3.shift(2.9*DOWN+4.3*RIGHT) - - self.play(ShowCreation(equation1),run_time=0.8) - self.add(eqText[0]) - self.wait(1) - self.play(ReplacementTransform(equation1,equation2),ReplacementTransform(eqText[0],eqText[1])) - self.wait(0.5) - self.play(ReplacementTransform(equation2,equation3),ReplacementTransform(eqText[1],eqText[2])) - self.wait(0.4) - self.play(ReplacementTransform(equation3,equation4),ReplacementTransform(eqText[2],eqText[3])) - self.wait(0.3) - self.play(FadeOut(eqText[3])) - self.play(FadeIn(eqTextTerm)) - self.play(Write(textBtwAnim1),Write(textBtwAnim2)) - self.play(FadeIn(textBtwAnim3)) - self.play(ReplacementTransform(equation4,equation5)) - self.wait(0.2) - self.play(ReplacementTransform(equation5,equation6)) - self.wait(0.2) - self.play(ReplacementTransform(equation6,equation7)) - self.wait(0.2) - self.play(ReplacementTransform(equation7,equation8)) - self.wait(0.2) - self.play(ReplacementTransform(equation8,equation9)) - self.wait(0.2) - self.play(ReplacementTransform(equation9,equation10)) - self.wait(1) - - self.play(FadeOut(textBtwAnim1),FadeOut(textBtwAnim2),FadeOut(textBtwAnim3),FadeOut(equation10),FadeOut(eqTextTerm)) - self.wait(1) - - convergeLine=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*RIGHT,color=WHITE) - divergeLineLeft=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*LEFT*8,color=RED) - divergeLineRight=Line(start=ORIGIN+x_each_unit*RIGHT,end=ORIGIN+x_each_unit*8*RIGHT,color=RED) - circle1=Circle(radius=0.01,color=PURPLE_E) - circle2=Circle(radius=0.01,color=PURPLE_E) - circle1.shift(ORIGIN+LEFT*x_each_unit) - circle2.shift(ORIGIN+RIGHT*x_each_unit) - convergeText=TextMobject("Converges") - divergeText1=TextMobject("Diverges") - divergeText2=TextMobject("Diverges") - convergeText.set_color(GREEN) - divergeText1.set_color(RED) - divergeText2.set_color(RED) - convergeText.scale(0.5) - divergeText1.scale(0.5) - divergeText2.scale(0.5) - convergeText.shift(1.6*UP) - divergeText1.shift(0.3*UP+1.5*LEFT) - divergeText2.shift(0.3*UP+1.5*RIGHT) - self.play(Write(divergeLineLeft),Write(divergeLineRight)) - self.play(FadeIn(convergeLine)) - self.wait(0.5) - self.play(FadeOut(self.axes)) - self.play(Write(circle1),Write(circle2)) - self.wait(0.5) - self.play(ApplyMethod(convergeLine.shift,1.3*UP),ApplyMethod(function_expan.shift,5*LEFT+DOWN)) - self.play(FadeIn(convergeText),FadeIn(divergeText1),FadeIn(divergeText2)) - self.wait(2) - diff --git a/FSF-2020/series-and-transformations/Power Series/script4.py b/FSF-2020/series-and-transformations/Power Series/script4.py deleted file mode 100644 index 412d20c..0000000 --- a/FSF-2020/series-and-transformations/Power Series/script4.py +++ /dev/null @@ -1,108 +0,0 @@ -from manimlib.imports import * -import math - -class intro(Scene): - def construct(self): - introText1=TextMobject("Consider the","above","example..") - introText1.scale(0.8) - introText1.set_color_by_tex_to_color_map({"above":YELLOW}) - self.play(Write(introText1)) - self.wait(1) - -class graphScene(GraphScene,MovingCameraScene): - CONFIG = { - "x_min": -5, - "x_max": 5, - "y_min": -5, - "y_max": 5, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-1, 2, 1), - "y_labeled_nums": range(0,2,1), - "y_axis_height":7, - "x_axis_width":7 - } - - def setup(self): - GraphScene.setup(self) - MovingCameraScene.setup(self) - - def construct(self): - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$") - function_expan.scale(0.6) - function_expan.set_color(RED) - function_expan.to_edge(UP+RIGHT) - self.add(function_expan) - - self.setup_axes() - - equation = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.1,x_max=1.1) - self.play(ShowCreation(equation)) - self.wait(1) - - dashLineLeft=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN) - dashLineRight=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN) - dashLineLeft.shift(ORIGIN+LEFT*x_each_unit) - dashLineRight.shift(ORIGIN+RIGHT*x_each_unit) - radiusLine=Line(start=ORIGIN,end=ORIGIN+RIGHT*x_each_unit) - rangeLine=Line(start=ORIGIN+LEFT*x_each_unit,end=ORIGIN+RIGHT*x_each_unit) - circle=Circle(radius=x_each_unit) - movingPoint=Circle(radius=0.025) - movingPoint.shift(ORIGIN+RIGHT*x_each_unit) - circleEq1=self.get_graph(lambda x:math.sqrt(1-x**2),color=BLUE,x_max=-1,x_min=1) - circleEq2=self.get_graph(lambda x:-math.sqrt(1-x**2),color=BLUE,x_max=1,x_min=-1) - - self.play(Write(dashLineLeft),Write(dashLineRight)) - self.wait(1) - - equation_updated=self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = GREEN,x_min = -1,x_max=1) - self.play(FadeOut(self.axes),ReplacementTransform(equation,equation_updated)) - self.wait(0.5) - self.play(Write(radiusLine)) - self.play(MoveAlongPath(movingPoint,circleEq1)) - self.play(MoveAlongPath(movingPoint,circleEq2)) - self.play(FadeIn(circle)) - self.wait(1) - - radiusText=TextMobject("Radius of convergence") - radiusText.scale(0.14) - radiusText.shift(ORIGIN+RIGHT*x_each_unit*0.45+DOWN*y_each_unit*0.2) - - self.play(Write(radiusText)) - self.wait(0.6) - - self.camera_frame.save_state() - self.camera_frame.set_width(5.5) - self.play(self.camera_frame.move_to, ORIGIN) - self.wait(1) - self.camera_frame.set_width(14) - self.wait(1.3) - - self.play(FadeOut(radiusText),FadeOut(circle),FadeOut(movingPoint)) - extendLine=Line(start=ORIGIN,end=ORIGIN+x_each_unit*LEFT) - self.play(Write(extendLine)) - doubleArrow=TextMobject("$\longleftrightarrow$") - doubleArrow.scale(1.6) - doubleArrow.set_color(BLUE) - doubleArrow.shift(ORIGIN+DOWN*y_each_unit*0.5) - self.play(FadeIn(doubleArrow)) - self.wait(1) - rangeText=TextMobject("Interval of convergence") - rangeText.scale(0.15) - rangeText.shift(ORIGIN+y_each_unit*DOWN) - self.play(Write(rangeText)) - self.wait(0.6) - - self.camera_frame.save_state() - self.camera_frame.set_width(5.5) - self.play(self.camera_frame.move_to, ORIGIN) - self.wait(1) - self.camera_frame.set_width(14) - self.wait(1.5) diff --git a/FSF-2020/series-and-transformations/Power Series/script5.py b/FSF-2020/series-and-transformations/Power Series/script5.py deleted file mode 100644 index e9681aa..0000000 --- a/FSF-2020/series-and-transformations/Power Series/script5.py +++ /dev/null @@ -1,136 +0,0 @@ -from manimlib.imports import * -import math - -class uniformlyConvergent(Scene): - def construct(self): - introText1=TextMobject("Again consider the","above","example") - introText2=TextMobject("Let","$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$","and","x=0.5 $\in$(-1,1)") - introText3=TextMobject("Lets analyse..","!") - introText1.scale(0.8) - introText2.scale(0.7) - introText3.scale(0.9) - introText3.shift(DOWN) - introText1.set_color_by_tex_to_color_map({"above":YELLOW}) - introText2.set_color_by_tex_to_color_map({"$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$":BLUE,"x=0.5 $\in$(-1,1)":YELLOW}) - introText3.set_color_by_tex_to_color_map({"!":GREEN}) - self.play(Write(introText1)) - self.wait(0.5) - self.play(FadeOut(introText1)) - self.play(Write(introText2)) - self.play(FadeIn(introText3)) - self.wait(2) - - -def gety(x,n): - ans=0 - for i in range(0,n+1): - if(i%2==0): - ans+=(math.pow(x,2*i)) - else: - ans-=(math.pow(x,2*i)) - return ans - -def makeSeries(x,points,x_each_unit,y_each_unit): - p=0 - for point in points: - y=gety(x,p) - point.shift(ORIGIN+RIGHT*x_each_unit*p+UP*y_each_unit*y) - p+=1 - -def makeLines(x,numPoints,x_each_unit,y_each_unit): - lines=[0]*numPoints - for i in range(0,numPoints-1): - y=gety(x,i) - y_next=gety(x,i+1) - lines[i]=Line(start=ORIGIN+RIGHT*x_each_unit*i+UP*y_each_unit*y,end=ORIGIN+RIGHT*x_each_unit*(i+1)+UP*y_each_unit*y_next,color=RED) - return lines - -class graphScene(GraphScene,MovingCameraScene): - CONFIG = { - "x_min": -6, - "x_max": 6, - "y_min": -5, - "y_max": 5, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$k$", - "y_axis_label": "$f(\\frac{1}{2})_k$", - "exclude_zero_label": True, - "x_axis_width":7, - "y_axis_height":7 - } - - def setup(self): - GraphScene.setup(self) - MovingCameraScene.setup(self) - - - def construct(self): - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - sequence=TextMobject("$1$ , $1-(0.5)^2$ , $1-(0.5)^2+(0.5)^4..$") - sequence.set_color(RED) - sequence.scale(0.35) - sequence.to_edge(UP+RIGHT) - formula=TextMobject("$f(x)_{ k }=\sum _{ i=0 }^{ k }{ (-1)^{ i }(x)^{ 2i } } $") - formula.set_color(PURPLE_C) - formula.scale(0.4) - formula.shift(5.3*RIGHT+3*UP) - fLine=Line(start=ORIGIN+x_each_unit*6*LEFT,end=ORIGIN+x_each_unit*6*RIGHT) - fLine.shift(ORIGIN+(4/5)*y_each_unit*UP) - fLineText=TextMobject("$g(0.5)=\\frac { 4 }{ 5 } $") - fLineText.set_color(RED) - fLineText.scale(0.3) - fLineText.shift(UP*1.2*y_each_unit+RIGHT*x_each_unit+4*LEFT) - points=[Dot(radius=0.03,color=BLUE) for i in range(0,6)] - makeSeries(0.5,points,x_each_unit,y_each_unit) - lines=makeLines(0.5,6,x_each_unit,y_each_unit) - - - self.add(sequence) - self.add(formula) - self.setup_axes(animate=True) - self.play(Write(fLine)) - self.add(fLineText) - for p in points: - self.add(p) - for p in range(0,5): - self.play(Write(lines[p])) - self.wait(0.5) - self.camera_frame.save_state() - self.camera_frame.set_width(0.6) - self.play(self.camera_frame.move_to, points[0]) - self.wait(0.4) - self.play(self.camera_frame.move_to, points[1]) - self.wait(0.4) - self.play(self.camera_frame.move_to, points[2]) - self.wait(0.3) - self.play(self.camera_frame.move_to, points[3]) - self.wait(1) - self.play(self.camera_frame.move_to,ORIGIN) - self.camera_frame.set_width(14) - self.wait(1) - - explanation1=TextMobject("Since the series","converges","to") - explanation1.set_color_by_tex_to_color_map({"converges":YELLOW}) - explanation2=TextMobject("$\\frac {4}{5}$") - explanation2.set_color(BLUE) - explanation3=TextMobject("Hence","$\\forall \epsilon>0$,","$\exists k$","such that,") - explanation3.set_color_by_tex_to_color_map({"$\\forall \epsilon>0$":BLUE,"$\exists k$":YELLOW}) - explanation4=TextMobject("$\left| { f\left( \\frac { 1 }{ 2 } \\right) }_{ k }-\\frac { 4 }{ 5 } \\right| <$","$\epsilon$") - explanation4.set_color_by_tex_to_color_map({"$\epsilon$":RED}) - explanation1.scale(0.5) - explanation3.scale(0.5) - explanation1.shift(1.8*DOWN+3.5*RIGHT) - explanation2.shift(2.4*DOWN+3.5*RIGHT) - explanation3.shift(1.8*DOWN+3.5*RIGHT) - explanation4.shift(2.4*DOWN+3.5*RIGHT) - - self.play(Write(explanation1)) - self.play(FadeIn(explanation2)) - self.wait(1) - self.play(FadeOut(explanation1),FadeOut(explanation2)) - self.play(Write(explanation3)) - self.play(Write(explanation4)) - self.wait(2) diff --git a/FSF-2020/series-and-transformations/README.md b/FSF-2020/series-and-transformations/README.md deleted file mode 100644 index 4747205..0000000 --- a/FSF-2020/series-and-transformations/README.md +++ /dev/null @@ -1,13 +0,0 @@ -Contributer: G Sri Harsha - -GitHub Handle: GSri30 - -Sub-Topics Covered: - diff --git a/FSF-2020/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf b/FSF-2020/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf deleted file mode 100644 index 2096f52..0000000 Binary files a/FSF-2020/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf and /dev/null differ diff --git a/FSF-2020/series-and-transformations/Taylor Series/script1.py b/FSF-2020/series-and-transformations/Taylor Series/script1.py deleted file mode 100644 index e83eff8..0000000 --- a/FSF-2020/series-and-transformations/Taylor Series/script1.py +++ /dev/null @@ -1,198 +0,0 @@ -from manimlib.imports import* -import math - -def formFormula(coeff_list,variable_list): - coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] - variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")] - coeff_list[0].shift(2.2*UP+1.6*LEFT) - for i in range(0,3): - coeff_list[i].set_color(GOLD_A) - variable_list[i].next_to(coeff_list[i],buff=0.1) - if i!=2: - coeff_list[i+1].next_to(variable_list[i],buff=0.1) - dots=TextMobject("...") - dots.next_to(variable_list[2]) - expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) - #expansion.scale(0.7) - return expansion,coeff_list - -class intro(Scene): - def construct(self): - equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$") - equation.scale(2) - equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED}) - text=TextMobject("let $a=0$") - text.scale(0.7) - text.shift(DOWN) - - self.play(Write(equation)) - self.wait(0.5) - self.play(FadeIn(text)) - self.wait(0.7) - self.play(FadeOut(equation),FadeOut(text)) - -class graphScene(GraphScene): - CONFIG = { - "x_min": -8, - "x_max": 8, - "y_min": -8, - "y_max": 8, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-8, 8, 1), - } - def construct(self): - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - generalized_eq_coeff=[] - variables_eq=[] - eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq) - trText1=TextMobject("let $T_{ n }(x)$:=") - eq.next_to(trText1) - trTextGrup=VGroup(trText1,eq) - trTextGrup.scale(0.5) - trTextGrup.to_corner(UP+RIGHT) - self.play(Write(trTextGrup)) - self.setup_axes(animate=True) - - fx=TextMobject("${ e }^{ -x^{ 2 } }$") - fx.scale(0.5) - fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP) - mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8) - self.play(ShowCreation(mainfunction)) - self.play(FadeIn(fx)) - self.wait(1.4) - - coeff=[TextMobject("$1$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")] - coeff[0].shift(3.39*UP+4.88*RIGHT) - coeff[0].scale(0.5) - coeff[1].shift(3.39*UP+5.3*RIGHT) - coeff[1].scale(0.275) - coeff[2].shift(3.39*UP+5.98*RIGHT) - coeff[2].scale(0.28) - - for obj in coeff: - obj.set_color(GOLD_A) - - firstApprox=[self.get_graph(lambda x:1,color=BLUE)] - secondApprox=[self.get_graph(lambda x:1,color=BLUE), - self.get_graph(lambda x:x+1,color=BLUE), - self.get_graph(lambda x:-x+1,color=BLUE)] - thirdApprox=[self.get_graph(lambda x:1-2*math.pow(x,2),color=BLUE), - self.get_graph(lambda x:1-0.1*math.pow(x,2),color=BLUE), - self.get_graph(lambda x:1,color=BLUE), - self.get_graph(lambda x:1+0.1*math.pow(x,2),color=BLUE), - self.get_graph(lambda x:1+math.pow(x,2),color=BLUE)] - - firstGraph=self.get_graph(lambda x:1,color=BLUE) - secondGraph=self.get_graph(lambda x:1-math.pow(x,2),color=BLUE) - - bottomText1=TextMobject("The polynomial should","satisfy","the function at $x=0$") - bottomText2=TextMobject("This gives","$a_{ 0 }=1$") - bottomText3=TextMobject("Now it could be of","any slope!") - #show graphs of second approx - bottomText4=TextMobject("Hence the","slopes","should","even match") - #final graph - bottomText5=TextMobject("This gives","$a_{ 1 }=0$") - bottomText6=TextMobject("Since the rate of change of this slope","could vary") - #show third approx graphs - bottomText7=TextMobject("Hence the","rate of change of these slopes","should also be","same!") - #final graph - bottomText8=TextMobject("This gives","$a_{ 2 }=-1$") - - bottomText1.set_color_by_tex_to_color_map({"satisfy":YELLOW}) - bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=1$":BLUE}) - bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW}) - bottomText4.set_color_by_tex_to_color_map({"slopes":BLUE,"even match":YELLOW}) - bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=0$":BLUE}) - bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW}) - bottomText7.set_color_by_tex_to_color_map({"rate of change of these slopes":BLUE,"same!":YELLOW}) - bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=-1$":BLUE}) - - bottomText1.scale(0.4) - bottomText2.scale(0.5) - bottomText3.scale(0.4) - bottomText4.scale(0.4) - bottomText5.scale(0.5) - bottomText6.scale(0.4) - bottomText7.scale(0.4) - bottomText8.scale(0.5) - - bottomText1.shift(4.5*RIGHT+2.5*DOWN) - bottomText2.shift(4.5*RIGHT+2.5*DOWN) - bottomText3.shift(4.5*RIGHT+2.5*DOWN) - bottomText4.shift(4.5*RIGHT+2.5*DOWN) - bottomText5.shift(4.5*RIGHT+2.5*DOWN) - bottomText6.shift(4.5*RIGHT+2.5*DOWN) - bottomText7.shift(4.5*RIGHT+2.5*DOWN) - bottomText8.shift(4.5*RIGHT+2.5*DOWN) - - self.play(Write(bottomText1)) - self.wait(1) - self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2)) - #change coeff in tn(x) - self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText2,bottomText3)) - self.wait(0.5) - self.play(ReplacementTransform(firstApprox[0],secondApprox[1])) - self.wait(0.5) - self.play(ReplacementTransform(secondApprox[1],secondApprox[0])) - self.wait(0.5) - self.play(ReplacementTransform(secondApprox[0],secondApprox[2])) - self.wait(1) - self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2])) - self.wait(1) - self.play(Write(firstGraph),ReplacementTransform(bottomText4,bottomText5)) - #change a1 coeff - self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText5,bottomText6)) - self.play(ReplacementTransform(firstGraph,thirdApprox[0])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[2],thirdApprox[3])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText6,bottomText7)) - self.wait(1.5) - self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],secondGraph)) - self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2])) - self.wait(2) - - textFinal=TextMobject("And so on..!") - textFinal.scale(0.7) - textFinal.shift(4.5*RIGHT+2.5*DOWN) - self.play(ReplacementTransform(bottomText8,textFinal)) - self.wait(2.5) - - finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$") - finalFormula.scale(0.8) - finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$":RED}) - - self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(secondGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2])) - self.play(Write(finalFormula)) - self.wait(2) - # self.play(ReplacementTransform(secondApprox[2],secondApprox[3])) - # self.wait(0.5) - # self.play(ReplacementTransform(secondApprox[3],secondApprox[4])) - # self.wait(0.5) - # self.play(ReplacementTransform(secondApprox[4],secondApprox[5])) - # self.wait(0.5) - # self.play(ReplacementTransform(secondApprox[0],secondApprox[0])) - # self.wait(0.5) - # self.play(ReplacementTransform(secondApprox[0],secondApprox[0])) - # self.wait(0.5) - - - - diff --git a/FSF-2020/series-and-transformations/Taylor Series/script2.py b/FSF-2020/series-and-transformations/Taylor Series/script2.py deleted file mode 100644 index b5d0a53..0000000 --- a/FSF-2020/series-and-transformations/Taylor Series/script2.py +++ /dev/null @@ -1,195 +0,0 @@ -from manimlib.imports import* -import math - - -class intro(Scene): - def construct(self): - equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$") - equation.scale(2) - equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED}) - text=TextMobject("at $a=1$") - text.scale(0.7) - text.shift(DOWN) - - shiftText=TextMobject("(Here we shift the origin to the point $x=1$)") - shiftText.scale(0.6) - shiftText.shift(2.4*DOWN) - - - self.play(Write(equation)) - self.wait(0.5) - self.play(FadeIn(text)) - self.wait(0.7) - self.play(Write(shiftText)) - self.wait(0.7) - self.play(FadeOut(equation),FadeOut(text),FadeOut(shiftText)) - - -def formFormula(coeff_list,variable_list): - coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")] - variable_list=[TextMobject("+"),TextMobject("${ (x-1) }$+"),TextMobject("${ (x-1) }^{ 2 }$")] - coeff_list[0].shift(2.2*UP+1.6*LEFT) - for i in range(0,3): - coeff_list[i].set_color(GOLD_A) - variable_list[i].next_to(coeff_list[i],buff=0.1) - if i!=2: - coeff_list[i+1].next_to(variable_list[i],buff=0.1) - dots=TextMobject("...") - dots.next_to(variable_list[2]) - expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots) - #expansion.scale(0.7) - return expansion,coeff_list - - -class graphScene(GraphScene): - CONFIG = { - "x_min": -8, - "x_max": 8, - "y_min": -8, - "y_max": 8, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-8, 8, 1), - } - def construct(self): - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - generalized_eq_coeff=[] - variables_eq=[] - eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq) - trText1=TextMobject("let $T_{ n }(x)$:=") - eq.next_to(trText1) - trTextGrup=VGroup(trText1,eq) - trTextGrup.scale(0.5) - trTextGrup.to_corner(UP+RIGHT) - self.play(Write(trTextGrup)) - self.setup_axes(animate=True) - - fx=TextMobject("${ e }^{ -x^{ 2 } }$") - fx.scale(0.5) - fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP) - mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8) - self.play(ShowCreation(mainfunction)) - self.play(FadeIn(fx)) - self.wait(1.4) - - coeff=[TextMobject("$e^{-1}$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")] - coeff[0].shift(3.33*UP+3.65*RIGHT) - coeff[0].scale(0.45) - coeff[1].shift(3.33*UP+4.13*RIGHT) - coeff[1].scale(0.275) - coeff[2].shift(3.33*UP+5.36*RIGHT) - coeff[2].scale(0.28) - - for obj in coeff: - obj.set_color(GOLD_A) - - firstApprox=[self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)] - secondApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5), - self.get_graph(lambda x:math.exp(-1)+3*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5), - self.get_graph(lambda x:math.exp(-1)-4*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)] - thirdApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), - self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-0.1*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), - self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_max=5.5,x_min=-5.5), - self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+0.5*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5), - self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5)] - - firstGraph=self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5) - secondGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5) - thirdGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5) - - bottomText1=TextMobject("Apply","$f(1)=T_{n}(1)$") - bottomText2=TextMobject("This gives","$a_{ 0 }=e^{-1}$") - bottomText3=TextMobject("Now it could be of","any slope!") - #show graphs of second approx - bottomText4=TextMobject("Hence","apply","$f'(1)=T_{n}'(1)$") - #final graph - bottomText5=TextMobject("This gives","$a_{ 1 }=-2e^{-1}$") - bottomText6=TextMobject("Since the rate of change of this slope","could vary") - #show third approx graphs - bottomText7=TextMobject("Hence also","apply","$f''(1)=T_{ n }''(1)$") - #final graph - bottomText8=TextMobject("This gives","$a_{ 2 }=e^{-1}$") - - bottomText1.set_color_by_tex_to_color_map({"Apply":YELLOW}) - bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=e^{-1}$":BLUE}) - bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW}) - bottomText4.set_color_by_tex_to_color_map({"apply":YELLOW}) - bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=-2e^{-1}$":BLUE}) - bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW}) - bottomText7.set_color_by_tex_to_color_map({"apply":YELLOW}) - bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=e^{-1}$":BLUE}) - - bottomText1.scale(0.4) - bottomText2.scale(0.5) - bottomText3.scale(0.4) - bottomText4.scale(0.4) - bottomText5.scale(0.5) - bottomText6.scale(0.4) - bottomText7.scale(0.4) - bottomText8.scale(0.5) - - bottomText1.shift(4.5*RIGHT+2.5*DOWN) - bottomText2.shift(4.5*RIGHT+2.5*DOWN) - bottomText3.shift(4.5*RIGHT+2.5*DOWN) - bottomText4.shift(4.5*RIGHT+2.5*DOWN) - bottomText5.shift(4.5*RIGHT+2.5*DOWN) - bottomText6.shift(4.5*RIGHT+2.5*DOWN) - bottomText7.shift(4.5*RIGHT+2.5*DOWN) - bottomText8.shift(4.5*RIGHT+2.5*DOWN) - - self.play(Write(bottomText1)) - self.wait(1) - self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2)) - #change coeff in tn(x) - self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText2,bottomText3)) - self.wait(0.5) - self.play(ReplacementTransform(firstApprox[0],secondApprox[1])) - self.wait(0.5) - self.play(ReplacementTransform(secondApprox[1],secondApprox[2])) - # self.wait(0.5) - # self.play(ReplacementTransform(secondApprox[2],secondApprox[0])) - self.wait(1) - self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2])) - self.wait(1) - self.play(Write(secondGraph),ReplacementTransform(bottomText4,bottomText5)) - #change a1 coeff - self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText5,bottomText6)) - self.play(ReplacementTransform(secondGraph,thirdApprox[0])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1])) - # self.wait(0.6) - # self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[1],thirdApprox[3])) - self.wait(0.6) - self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4])) - self.wait(1.5) - self.play(ReplacementTransform(bottomText6,bottomText7)) - self.wait(1.5) - self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],thirdGraph)) - self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2])) - self.wait(2) - - textFinal=TextMobject("And so on..!") - textFinal.scale(0.7) - textFinal.shift(4.5*RIGHT+2.5*DOWN) - self.play(ReplacementTransform(bottomText8,textFinal)) - self.wait(2.5) - - finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$") - finalFormula.scale(0.8) - finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$":RED}) - - self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(thirdGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2])) - self.play(Write(finalFormula)) - self.wait(2) \ No newline at end of file diff --git a/FSF-2020/series-and-transformations/Taylor Series/script3.py b/FSF-2020/series-and-transformations/Taylor Series/script3.py deleted file mode 100644 index a2870d4..0000000 --- a/FSF-2020/series-and-transformations/Taylor Series/script3.py +++ /dev/null @@ -1,111 +0,0 @@ -from manimlib.imports import* -import math - - -class graphScene(GraphScene): - CONFIG = { - "x_min": -8, - "x_max": 8, - "y_min": -8, - "y_max": 8, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-8, 8, 1), - } - def construct(self): - - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - self.setup_axes(animate=True) - - lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8) - - bottomText1=TextMobject("Apply $f(x)=T_{n}(x)$") - bottomText2=TextMobject("Then apply $f'(x)=T_{n}'(x)$") - bottomText3=TextMobject("Then apply $f''(x)=T_{n}''(x)$") - bottomText4=TextMobject("and so on..") - - bottomText1.scale(0.5) - bottomText2.scale(0.5) - bottomText3.scale(0.5) - bottomText4.scale(0.5) - - bottomText1.shift(3*RIGHT+2*DOWN) - bottomText2.shift(3*RIGHT+2*DOWN) - bottomText3.shift(3*RIGHT+2*DOWN) - bottomText4.shift(3*RIGHT+2*DOWN) - - equations=[self.get_graph(lambda x:math.log2(2),color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2,color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8,color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24,color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64,color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160,color=BLUE), - self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE)] - - terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")] - for obj in terms: - obj.scale(0.5) - - terms[0].shift(3*UP+3*RIGHT) - terms[1].next_to(terms[0],buff=0.1) - terms[2].next_to(terms[1],buff=0.1) - terms[3].next_to(terms[2],buff=0.1) - terms[4].next_to(terms[3],buff=0.1) - - self.play(ShowCreation(lnx)) - self.wait(1) - self.play(Write(bottomText1)) - self.wait(0.5) - self.play(ShowCreation(equations[0]),Write(terms[0]),Write(terms[1])) - self.wait(1) - self.play(ReplacementTransform(bottomText1,bottomText2)) - self.wait(0.5) - self.play(ReplacementTransform(equations[0],equations[1]),Write(terms[2])) - self.wait(1) - self.play(ReplacementTransform(bottomText2,bottomText3)) - self.wait(0.5) - self.play(ReplacementTransform(equations[1],equations[2]),Write(terms[3])) - self.wait(1) - self.play(ReplacementTransform(bottomText3,bottomText4),Write(terms[4])) - self.wait(1.5) - - self.play(FadeOut(terms[0]),FadeOut(terms[1]),FadeOut(terms[2]),FadeOut(terms[3]),FadeOut(terms[4]),FadeOut(bottomText4)) - - dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN) - dline.shift(ORIGIN+x_each_unit*4*RIGHT) - - bottomText5=TextMobject("Here","after $x=4$",", the graph","continuously diverges away","from $ln(x)$") - bottomText5.scale(0.3) - bottomText5.shift(4.5*RIGHT+2*DOWN) - bottomText5.set_color_by_tex_to_color_map({"after $x=4$":YELLOW,"continuously diverges away":BLUE}) - - self.play(Write(bottomText5),Write(dline)) - self.wait(1) - self.play(ReplacementTransform(equations[2],equations[3])) - self.wait(0.3) - self.play(ReplacementTransform(equations[3],equations[4])) - self.wait(0.3) - self.play(ReplacementTransform(equations[4],equations[5])) - self.wait(0.3) - self.play(ReplacementTransform(equations[5],equations[6]),FadeOut(bottomText5)) - self.wait(1) - - circle=Circle(radius=ORIGIN+x_each_unit*2,color=PURPLE_E) - circle.shift(ORIGIN+RIGHT*x_each_unit*2) - radiusLine=Line(start=ORIGIN+x_each_unit*RIGHT*2,end=ORIGIN+x_each_unit*4*RIGHT,color=PURPLE_E) - radius=TextMobject("$R$") - radius.set_color(RED) - radius.scale(0.5) - radius.shift(ORIGIN+RIGHT*x_each_unit*2.45+DOWN*y_each_unit*0.6) - - self.play(FadeOut(equations[6]),Write(circle)) - self.wait(0.6) - self.play(Write(radiusLine)) - self.play(FadeIn(radius)) - self.wait(2) \ No newline at end of file diff --git a/FSF-2020/series-and-transformations/Taylor Series/script4.py b/FSF-2020/series-and-transformations/Taylor Series/script4.py deleted file mode 100644 index 1f41c97..0000000 --- a/FSF-2020/series-and-transformations/Taylor Series/script4.py +++ /dev/null @@ -1,82 +0,0 @@ -from manimlib.imports import* -import math - - -class graphScene(GraphScene): - CONFIG = { - "x_min": -8, - "x_max": 8, - "y_min": -8, - "y_max": 8, - "graph_origin": ORIGIN, - "function_color": RED, - "axes_color": GREEN, - "x_axis_label": "$x$", - "y_axis_label": "$y$", - "exclude_zero_label": True, - "x_labeled_nums": range(-8, 8, 1), - } - def construct(self): - - x_each_unit = self.x_axis_width / (self.x_max - self.x_min) - y_each_unit = self.y_axis_height / (self.y_max - self.y_min) - - self.setup_axes(animate=True) - lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8) - equation=self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE) - - terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")] - for obj in terms: - obj.scale(0.5) - - terms[0].shift(3*UP+3*RIGHT) - terms[1].next_to(terms[0],buff=0.1) - terms[2].next_to(terms[1],buff=0.1) - terms[3].next_to(terms[2],buff=0.1) - terms[4].next_to(terms[3],buff=0.1) - - self.play(ShowCreation(lnx)) - self.wait(1) - self.play(FadeIn(equation),FadeIn(terms[0]),FadeIn(terms[1]),FadeIn(terms[2]),FadeIn(terms[3]),FadeIn(terms[4])) - self.wait(1) - - bottomText1=TextMobject("$R_{n}(x)=\\frac { d }{ dx } ($","area bounded","$)$") - - bottomText1.set_color_by_tex_to_color_map({"area bounded":ORANGE}) - #bottomText2.set_color_by_tex_to_color_map({"area bounded":BLUE}) - arrow=TextMobject("$\downarrow$") - arrow.scale(2.5) - arrow.shift(ORIGIN+x_each_unit*RIGHT*9.5+UP*y_each_unit) - increasingText=TextMobject("Increases!") - increasingText.set_color(GREEN) - followupText=TextMobject("as n increase!") - followupText.scale(0.3) - followupText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.1) - increasingText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.6) - increasingText.scale(0.4) - - bottomText1.scale(0.5) - #bottomText2.scale(0.5) - #bottomText3.scale(0.5) - - bottomText1.shift(3.5*LEFT+2*DOWN) - #bottomText2.shift(3.5*LEFT+2.4*DOWN) - #bottomText3.shift(3.5*LEFT+2.8*DOWN) - - dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN) - dline.shift(ORIGIN+x_each_unit*4*RIGHT) - - area1=self.get_riemann_rectangles(lnx,x_max=8,x_min=4,dx=0.01,start_color=BLUE,end_color=RED,stroke_width=0,fill_opacity=0.8) - area2=self.get_riemann_rectangles(equation,x_max=5.2,x_min=4,dx=0.025,start_color=BLACK,end_color=BLACK,stroke_width=0,fill_opacity=1) - - self.play(Write(dline)) - self.wait(0.5) - self.play(ShowCreation(area1),ShowCreation(area2),Write(bottomText1)) - # self.play(Write(bottomText2)) - # self.play(FadeIn(bottomText3)) - self.play(Write(arrow)) - self.wait(0.7) - self.play(Write(increasingText)) - self.play(FadeIn(followupText)) - self.wait(2) - \ No newline at end of file diff --git a/FSF-2020/triple-and-surface-integrals/README.md b/FSF-2020/triple-and-surface-integrals/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/vector-spaces/README.md b/FSF-2020/vector-spaces/README.md deleted file mode 100644 index e69de29..0000000 -- cgit