diff options
32 files changed, 1951 insertions, 0 deletions
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 Binary files differnew file mode 100644 index 0000000..25c4e4d --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/Critical_Points_mcq_questions.pdf diff --git a/FSF-2020/approximations-and-optimizations/README.md b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md index f56f4e8..f56f4e8 100644 --- a/FSF-2020/approximations-and-optimizations/README.md +++ b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/README.md 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 Binary files differnew file mode 100644 index 0000000..ca60cbf --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/approximations-and-optimizations/The_Second_Derivative_Test_MCQ.pdf diff --git a/FSF-2020/div-curl-grad-and-all-that/README.md b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/README.md index e69de29..e69de29 100644 --- a/FSF-2020/div-curl-grad-and-all-that/README.md +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/README.md diff --git a/FSF-2020/geometry-of-planes-and-curves/README.md b/FSF-2020/calculus-of-several-variables/geometry-of-planes-and-curves/README.md index e69de29..e69de29 100644 --- a/FSF-2020/geometry-of-planes-and-curves/README.md +++ b/FSF-2020/calculus-of-several-variables/geometry-of-planes-and-curves/README.md 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..a321caf --- /dev/null +++ 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 Binary files differnew file mode 100644 index 0000000..a2bfd9d --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/YlimitXdependent.gif 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/integrals-of-multivariable-functions/README.md b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/README.md index e69de29..e69de29 100644 --- a/FSF-2020/integrals-of-multivariable-functions/README.md +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/README.md diff --git a/FSF-2020/intro-to-calculus/README.md b/FSF-2020/calculus-of-several-variables/triple-and-surface-integrals/README.md index e69de29..e69de29 100644 --- a/FSF-2020/intro-to-calculus/README.md +++ b/FSF-2020/calculus-of-several-variables/triple-and-surface-integrals/README.md diff --git a/FSF-2020/linear-transformations/README.md b/FSF-2020/calculus/intro-to-calculus/README.md index e69de29..e69de29 100644 --- a/FSF-2020/linear-transformations/README.md +++ b/FSF-2020/calculus/intro-to-calculus/README.md diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf Binary files differnew file mode 100644 index 0000000..04ed6d5 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf 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 new file mode 100644 index 0000000..4747205 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/README.md @@ -0,0 +1,13 @@ +Contributer: <b>G Sri Harsha</b>
+
+GitHub Handle: <a href="https://github.com/GSri30/">GSri30</a>
+
+Sub-Topics Covered:
+ <ul>
+ <li>Power Series
+ <li>Taylor Series
+ <li>Laplace Transformation
+ <li>Fourier Transformation
+ <li>z-Transform
+ <li>Constant-Q transform
+ </ul>
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf Binary files differnew file mode 100644 index 0000000..2096f52 --- /dev/null +++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf 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/multivariable-functions-and-paritial-derivatives/README.md b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py index e69de29..e69de29 100644 --- a/FSF-2020/multivariable-functions-and-paritial-derivatives/README.md +++ b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py 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 : <a href="https://github.com/architsangal">architsangal</a>
+<br/></br>
+## 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/series-and-transformations/README.md b/FSF-2020/linear-algebra/vector-spaces/README.md index e69de29..e69de29 100644 --- a/FSF-2020/series-and-transformations/README.md +++ b/FSF-2020/linear-algebra/vector-spaces/README.md 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 --- a/FSF-2020/triple-and-surface-integrals/README.md +++ /dev/null diff --git a/FSF-2020/vector-spaces/README.md b/FSF-2020/vector-spaces/README.md deleted file mode 100644 index e69de29..0000000 --- a/FSF-2020/vector-spaces/README.md +++ /dev/null |
