diff options
45 files changed, 2164 insertions, 0 deletions
diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/example.py b/FSF-2020/approximations-and-optimizations/Critical Points/example.py new file mode 100644 index 0000000..3a41be7 --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/example.py @@ -0,0 +1,32 @@ +from manimlib.imports import* + +class ExampleAnimation(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + + f_text = TextMobject("$f(x,y) = (y-x)(1-2x-3y)$").to_corner(UL) + d = Dot(np.array([0,0,0]), color = '#800000') #---- Critical Point + d_text = TextMobject("$(0.2,0.2)$",color = '#DC143C').scale(0.5).shift(0.2*UP) #----x = 0.2, y = 0.2 + r_text=TextMobject("Critical Point",color = '#00FFFF').shift(0.3*DOWN).scale(0.6) + + #----f(x,y) = (y-x)(1-2x-3y) + f = ParametricSurface( + lambda u, v: np.array([ + u, + v, + (v-u)*(1-2*u-3*v) + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [PURPLE_D, PURPLE_E], + resolution=(20, 20)).scale(1) + + self.set_camera_orientation(phi = 75 * DEGREES) + self.begin_ambient_camera_rotation(rate=0.5) + + self.add_fixed_in_frame_mobjects(f_text) + self.wait(1) + self.add(axes) + self.play(Write(f),Write(d)) + self.wait(1) + self.add_fixed_in_frame_mobjects(d_text) + self.wait(1) + self.add_fixed_in_frame_mobjects(r_text) + self.wait(3) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/motivation.py b/FSF-2020/approximations-and-optimizations/Critical Points/motivation.py new file mode 100644 index 0000000..27354ef --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/motivation.py @@ -0,0 +1,30 @@ +from manimlib.imports import* + +class MotivationAnimation(Scene): + def construct(self): + + r = Rectangle(height = 7,breadth = 2,color = BLUE, fill_opacity = 0.3).scale(0.6) #----metal strip + b = Brace(r,UP) + r_text = TextMobject("$x$ metres",color = YELLOW).shift(3*UP) + m_text = TextMobject("Metal Strip").shift(3*DOWN) + a = Arc(radius=2).rotate(1).shift(LEFT+0.5*UP) + a2 = Arc(radius=2).rotate(5).shift(0.7*LEFT+0.9*UP).scale(0.2) + START = [1,0,0] + END = [0,3,0] + l = Line(START,END,color = RED).shift(0.9*DOWN) + a2_text = TextMobject("$\\theta$",color = PINK).shift(1.6*UP+0.4*RIGHT) + + group1 = VGroup(r_text,b,a,l,a2,a2_text) + f_text = TextMobject("$A = f(x,\\theta)$").shift(2*DOWN) + + ring = Annulus(inner_radius = 0.7, outer_radius = 1, color = BLUE) #--bent metal strip + + self.play(Write(r)) + self.wait(1) + self.play(ShowCreation(m_text)) + self.wait(1) + self.play(Write(group1)) + self.wait(2) + self.play(FadeOut(group1)) + self.wait(1) + self.play(ReplacementTransform(r,ring),ShowCreation(f_text)) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py b/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py new file mode 100644 index 0000000..7c82aa9 --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py @@ -0,0 +1,55 @@ +from manimlib.imports import* + +class TheoremAnimation(ThreeDScene): + def construct(self): + + axes = ThreeDAxes() + + #----parabola: x**2+y**2 + parabola1 = ParametricSurface( + lambda u, v: np.array([ + u, + v, + u**2+v**2 + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [TEAL_E], + resolution = (20, 20)).scale(1) + + #----parabola: -x**2-y**2 + parabola2 = ParametricSurface( + lambda u, v: np.array([ + u, + v, + -u**2-v**2 + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [PURPLE_E,PURPLE_E], + resolution = (20, 20)).scale(1) + + self.set_camera_orientation(phi = 75 * DEGREES) + self.begin_ambient_camera_rotation(rate = 0.4) + + d = Dot(np.array([0,0,0]), color = '#800000') #---- critical point + r = Rectangle(fill_color = '#C0C0C0',fill_opacity = 0.3).move_to(ORIGIN) #----tangent plane + + parabola1_text = TextMobject("Maximum with horizontal tangent plane").scale(0.7).to_corner(UL) + + parabola2_text = TextMobject("Minimum with horizontal tangent plane").scale(0.7).to_corner(UL) + + self.add(axes) + self.add_fixed_in_frame_mobjects(parabola2_text) + self.wait(1) + self.play(Write(parabola1)) + self.wait(1) + self.play(ShowCreation(d)) + self.wait(1) + self.play(ShowCreation(r)) + self.wait(2) + self.play(FadeOut(parabola2_text),FadeOut(parabola1),FadeOut(r),FadeOut(d)) + + self.wait(1) + self.add_fixed_in_frame_mobjects(parabola1_text) + self.wait(1) + self.play(Write(parabola2)) + self.wait(1) + self.play(ShowCreation(d)) + self.wait(1) + self.play(ShowCreation(r)) + self.wait(2) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py b/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py new file mode 100644 index 0000000..f9055e6 --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py @@ -0,0 +1,70 @@ +from manimlib.imports import * + +class TypescpAnimation(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + + r_text = TextMobject("Relative Maximum at ORIGIN",color ='#87CEFA') + f_text = TextMobject("$f(x,y) = -x^2-y^2$").to_corner(UL) + + #----graph of first function f(x,y) = -x**2-y**2 + f = ParametricSurface( + lambda u, v: np.array([ + u, + v, + -u**2-v**2 + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [YELLOW_D, YELLOW_E], + resolution = (20, 20)).scale(1) + + r2_text = TextMobject("Saddle Point at ORIGIN",color ='#87CEFA') + f2_text = TextMobject("$f(x,y) = -x^2+y^2$").to_corner(UL) + + #----graph of second function f(x,y) = -x**2+y**2 + f2 = ParametricSurface( + lambda u, v: np.array([ + u, + v, + -u**2+v**2 + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [RED_D, RED_E], + resolution = (20, 20)).scale(1) + + r3_text = TextMobject("Relative Minimum at ORIGIN",color ='#87CEFA') + f3_text = TextMobject("$f(x,y) = x^2+y^2$").to_corner(UL) + + #----graph of third function f(x,y) = x**2+y**2 + f3 = ParametricSurface( + lambda u, v: np.array([ + u, + v, + u**2+v**2 + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [GREEN_D, GREEN_E], + resolution = (20, 20)).scale(1) + + self.set_camera_orientation(phi = 75 * DEGREES, theta = -45 * DEGREES ) + d = Dot(np.array([0,0,0]), color = '#800000') #---- critical point + + self.add_fixed_in_frame_mobjects(r_text) + self.wait(1) + self.play(FadeOut(r_text)) + self.add(axes) + self.play(Write(f),Write(d)) + self.add_fixed_in_frame_mobjects(f_text) + self.wait(2) + self.play(FadeOut(axes),FadeOut(f),FadeOut(f_text),FadeOut(d)) + + self.add_fixed_in_frame_mobjects(r2_text) + self.wait(1) + self.play(FadeOut(r2_text)) + self.add(axes) + self.play(Write(f2),Write(d)) + self.add_fixed_in_frame_mobjects(f2_text) + self.wait(2) + self.play(FadeOut(axes),FadeOut(f2),FadeOut(f2_text),FadeOut(d)) + + self.add_fixed_in_frame_mobjects(r3_text) + self.wait(1) + self.play(FadeOut(r3_text)) + self.add(axes) + self.play(Write(f3),Write(d)) + self.add_fixed_in_frame_mobjects(f3_text) + self.wait(2) diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file1_missile-example.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file1_missile-example.py new file mode 100644 index 0000000..cd754cd --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file1_missile-example.py @@ -0,0 +1,37 @@ +from manimlib.imports import * +import numpy as np + + +def function(coordinate): + x,y = coordinate[:2] + return np.array([ + np.sin(x-y), + np.exp(y), + 0 + ]) +def func(coordinate): + x,y = coordinate[:2] + return np.array([ + -2*x, + y, + 0]) + +class Missiles(GraphScene): + def construct(self): + + field = VectorField(function) + #path = ParametricFunction(lambda x: -2*x) + + dot = SVGMobject("miss").move_to(DL).scale(0.09).set_color(WHITE).rotate(PI/4 + PI) + path = ArcBetweenPoints(dot.get_center(), UP+0.2*LEFT) + + self.play(FadeIn(field)) + self.wait() + self.play(FadeIn(dot)) + self.wait() + self.play(MoveAlongPath(dot, path)) + self.play(ApplyMethod(dot.rotate, PI/4), rate = 0.2) + self.play(ApplyMethod(dot.move_to, 3.5*UP), rate = 0.3) + #self.play(ApplyMethod(dot.move_to, 3.5*UP)) + #self.add_fixed_in_frame_mobjects(text_field) + self.wait()
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file2_gradient-example-1.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file2_gradient-example-1.py new file mode 100644 index 0000000..7a95867 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file2_gradient-example-1.py @@ -0,0 +1,43 @@ +from manimlib.imports import * +import numpy as np + + +def function(coordinate): + x,y = coordinate[:2] + return np.array([ + 0.4*x, + 0.4*y, + 0.4*np.cos(np.sqrt((x**2)+(y**2)) + )]) + +class ThreeDVector(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + self.add(axes) + self.set_camera_orientation(phi=45*DEGREES,theta=60*DEGREES,distance=40) + self.begin_ambient_camera_rotation(rate=0.5) + + surface = ParametricSurface( + lambda u, v: np.array([ + 0.4*u, + 0.4*v, + 0.4*np.cos(np.sqrt((u**2)+(v**2))) + ]),u_min=-20,u_max=20, v_min=-10,v_max=10).set_color(BLUE_E).fade(0.7) + + text_func = TexMobject(r"\textbf{Input: Function}").shift(4.4*LEFT+3.3*UP).scale(0.7) + text_field = TexMobject(r"\textbf{Output: Vector Field}").shift(4.4*LEFT+3.3*UP).scale(0.7) + + + self.add_fixed_in_frame_mobjects(text_func) + self.play(ShowCreation(surface)) + self.wait(3) + + field = VectorField(function) + self.play(FadeIn(field), FadeOut(text_func)) + self.add_fixed_in_frame_mobjects(text_field) + self.wait() + self.play(FadeOut(surface)) + self.wait() + + + diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file3_gradient-example-2.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file3_gradient-example-2.py new file mode 100644 index 0000000..e37581d --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file3_gradient-example-2.py @@ -0,0 +1,39 @@ +from manimlib.imports import * +import numpy as np + + +def function(coordinate): + x,y = coordinate[:2] + return np.array([ + x, + y, + x**2 - y**2 + ]) + +class ThreeDVector_three(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + self.add(axes) + self.set_camera_orientation(phi=45*DEGREES,theta=85*DEGREES,distance=40) + self.begin_ambient_camera_rotation(rate=0.5) + + surface = ParametricSurface( + lambda x, y: np.array([ + x, + y, + x**2 - y**2 + ]),u_min=-2,u_max=2, v_min=-1.5,v_max=1.5).set_color(BLUE_E).fade(0.7).scale(1.7) + + text_func = TexMobject(r"\textbf{Input: Function}").shift(4.4*LEFT+3.3*UP).scale(0.7) + text_field = TexMobject(r"\textbf{Output: Vector Field}").shift(4.4*LEFT+3.3*UP).scale(0.7) + + self.add_fixed_in_frame_mobjects(text_func) + self.play(ShowCreation(surface)) + self.wait(3) + + field = VectorField(function) + self.play(FadeIn(field), FadeOut(text_func)) + self.add_fixed_in_frame_mobjects(text_field) + self.wait() + self.play(FadeOut(surface)) + self.wait(2)
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4-multidimensional-gradient.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4-multidimensional-gradient.py new file mode 100644 index 0000000..e9c8fd0 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4-multidimensional-gradient.py @@ -0,0 +1,113 @@ +from manimlib.imports import * +import numpy as np + + +class Hills(ThreeDScene): + def construct(self): + axes = ThreeDAxes( + number_line_config={ + "color": GREEN, + "include_tip": False, + "exclude_zero_from_default_numbers": True, + } + ) + self.add(axes) + + self.set_camera_orientation(phi=45*DEGREES,theta=45*DEGREES,distance=40) + #self.begin_ambient_camera_rotation(rate=0.5) + self.wait() + + cylinder_1 = ParametricSurface( + lambda u, v: np.array([ + u, + v, + 7*u*v/np.exp(u**2+v**2) + ]),u_min=-3,u_max=3, v_min=-1,v_max=-0.95).set_color(YELLOW_E).rotate(PI/2).shift(LEFT).fade(0.5) + cylinder = ParametricSurface( + lambda u, v: np.array([ + u, + v, + 7*u*v/np.exp(u**2+v**2) + ]),u_min=-3,u_max=3, v_min=-3,v_max=3).set_color(YELLOW_E).rotate(PI/2).shift(LEFT).fade(0.5) + text_one = TexMobject(r"\textrm{Single variable functions slope up and down}") + #name = TexMobject(r"\textrm{PROBE}").next_to(text_one, DOWN, buff = SMALL_BUFF).scale(0.7) + text_one_a = TexMobject(r"\textrm{Position }", r" \rightarrow ").next_to(text_one, DOWN, buff = SMALL_BUFF) + probe = Sphere(radius = 0.2).next_to(text_one_a, RIGHT).set_color(BLUE_E) + text_one_b = TexMobject(r" \rightarrow ", r"\textrm{ slope }").next_to(probe, RIGHT, buff = SMALL_BUFF) + name = TextMobject("PROBE").next_to(probe, DOWN, buff = SMALL_BUFF).scale(0.5) + text = VGroup(text_one, text_one_a, probe, text_one_b, name).to_edge(UP+1.5*LEFT).scale(0.5) + + text_two = TexMobject(r"\textrm{Multivariable functions slope in infinitely many directions!}") + #name_two = TexMobject(r"\textrm{PROBE2.0}").next_to(text_two, DOWN, buff = SMALL_BUFF).scale(0.7) + text_two_a = TexMobject(r"\textrm{Position, Direction }", r" \rightarrow ").next_to(text_two, DOWN, buff = SMALL_BUFF) + probe_two = Sphere(radius = 0.2).next_to(text_two_a, RIGHT).set_color(PURPLE_E) + text_two_b = TexMobject(r" \rightarrow ", r"\textrm{ slope }").next_to(probe_two, RIGHT, buff = SMALL_BUFF) + name_two = TextMobject("PROBE2.0").next_to(probe_two, DOWN, buff = SMALL_BUFF).scale(0.5) + two = VGroup(text_two, text_two_a, probe_two, text_two_b, name_two).to_edge(UP+LEFT).scale(0.5).shift(3.5*LEFT) + + + + + + + self.play(ShowCreation(cylinder_1)) + self.wait() + self.add_fixed_in_frame_mobjects(text) + self.wait(3.5) + self.play(FadeOut(text)) + self.play(ReplacementTransform(cylinder_1, cylinder)) + self.wait() + self.add_fixed_in_frame_mobjects(two) + self.begin_ambient_camera_rotation(rate=0.5) + self.wait(4) + +class OneMore(ThreeDScene, GraphScene): + def setup(self): + GraphScene.setup(self) + ThreeDScene.setup(self) + + def construct(self): + axes = ThreeDAxes( + number_line_config={ + "color": GREEN, + "include_tip": False, + "exclude_zero_from_default_numbers": True, + } + ) + self.add(axes) + + self.set_camera_orientation(phi=90*DEGREES,theta=90*DEGREES,distance=40) + #self.begin_ambient_camera_rotation(rate=0.5) + self.wait() + + shape = ParametricSurface( + lambda u, v: np.array([ + u, + v, + 2 - u**2 - v**2, + ]),u_min=0,u_max =0.01, v_min=-2,v_max=2).set_color(GREEN_C) + + shape_A = ParametricSurface( + lambda u, v: np.array([ + 0*u, + 0, + v, + ]),u_min=-2,u_max = 2, v_min=-2,v_max=2).set_color(GREEN_C) + + + ''' + path = self.get_graph(lambda u,v: np.array([ + u, + 2 - u**2 - v**2]), u_min=-2,u_max=2, v_min=-2,v_max=2) + location = np.array([-2,-2, -2]) #location: Point + dot = Dot(location) + ''' + + self.play(ShowCreation(shape)) + self.add(shape_A) + #self.play(ShowCreation(path), ShowCreation(dot)) + #self.play(MoveAlongPath(dot, path)) + #self.wait(3) + self.play(ApplyMethod(shape.fade, 0.5)) + self.begin_ambient_camera_rotation(rate = 0.5) + self.wait(3) diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4_gradient-example-3.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4_gradient-example-3.py new file mode 100644 index 0000000..7c0ef54 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4_gradient-example-3.py @@ -0,0 +1,40 @@ +from manimlib.imports import * +import numpy as np + + +def function(coordinate): + x,y = coordinate[:2] + return np.array([ + x, + y, + 1/np.cos(x*y), + ]) + +class ThreeDVector(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + self.add(axes) + self.set_camera_orientation(phi=45*DEGREES,theta=45*DEGREES,distance=40) + self.begin_ambient_camera_rotation(rate=0.5) + + surface = ParametricSurface( + lambda x, y: np.array([ + x, + y, + 1/np.cos(x*y), + ]),u_min=-1.15,u_max=1.15, v_min=-1.15,v_max=1.15).set_color(BLUE_E).fade(0.7).scale(1.4) + + text_func = TexMobject(r"\textbf{Input: Function}").shift(4.4*LEFT+3.3*UP).scale(0.3) + text_field = TexMobject(r"\textbf{Output: Vector Field}").shift(4.4*LEFT+3.3*UP).scale(0.7) + + self.add_fixed_in_frame_mobjects(text_func) + self.play(ShowCreation(surface)) + self.wait(2) + + field = VectorField(function).scale(0.7) + self.play(FadeIn(field), FadeOut(text_func)) + self.add_fixed_in_frame_mobjects(text_field) + self.wait() + + self.play(FadeOut(surface)) + self.wait(2) diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file5_steepest-ascent-analogy.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file5_steepest-ascent-analogy.py new file mode 100644 index 0000000..803ea4a --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file5_steepest-ascent-analogy.py @@ -0,0 +1,71 @@ +from manimlib.imports import * +import numpy as np + +class Rules(ThreeDScene): + + def setup(self): + ThreeDScene.setup(self) + + def construct(self): + axes = ThreeDAxes()#.scale(0.8)#.shift(2*RIGHT, 2*DOWN) + self.set_camera_orientation(phi=PI/3 + 10*DEGREES,theta=-PI/4 + 25*DEGREES,distance=60) + + plane = Polygon(np.array([4,4,0]), np.array([4, -4, 0]), np.array([-4, -4, 0]), np.array([-4, 4, 0]), color = BLACK, fill_color = YELLOW_E, fill_opacity = 0.3) + + path_one = Line(start = ORIGIN, end = np.array([3, 0, 0])).set_color(BLUE_E) + path_one_text = TexMobject(r"\textrm{3 steps in the x direction}").shift(2*DOWN+3.5*LEFT).scale(0.5).set_color(BLUE_E) + path_two_text = TexMobject(r"\textrm{2 steps in the y direction}").next_to(path_one_text, DOWN, buff = SMALL_BUFF).scale(0.5).set_color(GREEN_C) + path_three_text = TexMobject(r"\textrm{2 steps in the z direction}").next_to(path_two_text, DOWN, buff = SMALL_BUFF).scale(0.5).set_color(PURPLE_E) + obj = TextMobject("Objective: ", "Maximise points for a set number of steps").scale(0.8).to_edge(UP+LEFT) + + steps = TexMobject(r"\textrm{Total steps = 7}").to_edge(RIGHT, buff = LARGE_BUFF).set_color(YELLOW_E).scale(0.7).shift(1*UP) + points_one = TexMobject(r"\textrm{Total points = 13}").next_to(steps, DOWN, buff = SMALL_BUFF).scale(0.7).set_color(YELLOW_E) + question = TexMobject(r"\textrm{Change direction to score more points?}").shift(2*DOWN+2.5*RIGHT).scale(0.9) + + path_two = Line(start = np.array([3, 0, 0]), end = np.array([3, 2, 0])).set_color(GREEN_C) + path_three = Line(start = np.array([3, 2, 0]), end = np.array([3, 2, 2])).set_color(PURPLE_E) + total = Line(start = np.array([0, 0, 0]), end = np.array([3, 2, 2])).set_color(YELLOW_E) + projection_total = Line(start = np.array([0, 0, 0]), end = np.array([3, 2, 0])) + paths = VGroup(path_one, path_two, path_three, path_one_text, path_two_text, path_three_text) + + total_one = VGroup(total, projection_total) + + total_two = Line(start = np.array([0, 0, 0]), end = np.array([4, 1, 2])).set_color(YELLOW_E) + projection_total_two = Line(start = np.array([0, 0, 0]), end = np.array([4, 1, 0])) + points_two = TexMobject(r"\textrm{Total points = 12}").next_to(steps, DOWN, buff = SMALL_BUFF).scale(0.7).set_color(YELLOW_E) + + total_three = Line(start = np.array([0, 0, 0]), end = np.array([1, 4, 2])).set_color(YELLOW_E) + projection_total_three = Line(start = np.array([0, 0, 0]), end = np.array([1, 4, 0])) + points_three = TexMobject(r"\textrm{Total points = 15}").next_to(steps, DOWN, buff = SMALL_BUFF).scale(0.7).set_color(YELLOW_E) + + everything = VGroup(axes, plane, path_one, path_two, path_three, total, projection_total, total_two, projection_total_two, total_three, projection_total_three) + everything.scale(0.7).shift(2*LEFT+1*DOWN) + self.add_fixed_in_frame_mobjects(obj) + self.add(axes, plane) + self.wait() + self.add_fixed_in_frame_mobjects(path_one_text) + self.play(ShowCreation(path_one)) + self.wait() + self.add_fixed_in_frame_mobjects(path_two_text) + self.play(ShowCreation(path_two)) + self.wait() + self.add_fixed_in_frame_mobjects(path_three_text) + self.play(ShowCreation(path_three)) + self.add_fixed_in_frame_mobjects(steps, points_one) + self.wait() + self.play(ShowCreation(total)) + self.play(ReplacementTransform(total.copy(), projection_total)) + self.wait() + self.play(FadeOut(paths)) + self.add_fixed_in_frame_mobjects(question) + self.wait() + self.play(ReplacementTransform(total, total_two), ReplacementTransform(projection_total, projection_total_two)) + self.play(FadeOut(points_one)) + self.add_fixed_in_frame_mobjects(points_two) + self.wait() + self.play(ReplacementTransform(total_two, total_three), ReplacementTransform(projection_total_two, projection_total_three)) + self.play(FadeOut(points_two)) + self.add_fixed_in_frame_mobjects(points_three) + self.wait() + + diff --git a/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file6-maximum.py b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file6-maximum.py new file mode 100644 index 0000000..255a0eb --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file6-maximum.py @@ -0,0 +1,39 @@ +from manimlib.imports import * +import numpy as np + + +def function(coordinate): + x,y = coordinate[:2] + return np.array([ + x, + y, + 2 - x**2 - y**2 + ]) + +class ThreeDVector_one(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + self.add(axes) + self.set_camera_orientation(phi=75*DEGREES,theta=45*DEGREES,distance=40) + self.begin_ambient_camera_rotation(rate=0.5) + + surface = ParametricSurface( + lambda x, y: np.array([ + x, + y, + 2 - x**2 - y**2 + ]),u_min=-2,u_max=2, v_min=-2,v_max=2).set_color(RED_E).fade(0.7) + + probe = Sphere(radius = 0.2).set_color(PURPLE_E) + probe_one = Sphere(radius = 0.1).set_color(PURPLE_E).move_to(np.array([0,0,2.1])) + text_one_b = TexMobject(r" \textrm{ reads 0 at local maximum }").next_to(probe, RIGHT, buff = SMALL_BUFF) + name = TextMobject("PROBE2.0 ").next_to(probe, DOWN, buff = SMALL_BUFF).scale(0.5) + text = VGroup(probe, text_one_b, name).to_edge(1.5*UP+0.5*LEFT).scale(0.5) + + + self.play(ShowCreation(surface)) + self.add(probe_one) + field = VectorField(function).scale(0.8) + self.play(FadeIn(field)) + self.add_fixed_in_frame_mobjects(text) + self.wait(3) diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif Binary files differnew file mode 100644 index 0000000..223218b --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/area_Under_func.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif Binary files differnew file mode 100644 index 0000000..5c9ac03 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/elementary_area.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif Binary files differnew file mode 100644 index 0000000..c8e7c8c --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/non_rect_region.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif Binary files differnew file mode 100644 index 0000000..ae23a7b --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/double-integrals/surface.gif 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/y_limit_dependent_on_x.gif Binary files differindex a2bfd9d..a2bfd9d 100644 --- 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/y_limit_dependent_on_x.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif Binary files differnew file mode 100644 index 0000000..8c9fa0a --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py new file mode 100644 index 0000000..a590a53 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface1.py @@ -0,0 +1,232 @@ +from manimlib.imports import * + +class SurfacesAnimation(ThreeDScene): + + CONFIG = { + "axes_config": { + "x_min": 0, + "x_max": 4, + "y_min": 0, + "y_max": 4, + "z_min": -4, + "z_max": 4, + "a":0 ,"b": 4, "c":0 , "d":4, + "axes_shift":IN+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: 5*(x**2-y**2)/((1e-4+x**2+y**2)**2) + } + + + def construct(self): + + self.setup_axes() + self.set_camera_orientation(#distance=10, + phi=80 * DEGREES, + theta=35 * DEGREES, + ) + + fn_text=TextMobject("$z=\dfrac{x^2-y^2}{(x^2+y^2)^2}$").set_color(BLUE) + fn_text.to_corner(UR,buff=1) + self.add_fixed_in_frame_mobjects(fn_text) + + R=TextMobject("R").set_color(BLACK).scale(2).rotate(180*DEGREES , OUT) + 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.6, + fill_color=BLUE_E, + stroke_width=0.8, + stroke_color=WHITE, + ) + + + self.begin_ambient_camera_rotation(rate=0.2) + self.play(Write(surface)) + + self.get_lines() + self.wait(4) + + def get_surface(self,axes, func, **kwargs): + config = { + "u_min": axes.x_max, + "u_max": axes.x_min, + "v_min": axes.y_max, + "v_max": axes.y_min, + "resolution": (10,10), + } + + 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,"YELLOW")) + + 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, LEFT, + about_point=axes.c2p(0, 0, 0), + ) + axes.y_axis.rotate( + 90 * DEGREES, UP, + about_point=axes.c2p(0, 0, 0), + ) + + # Add xy-plane + input_plane = self.get_surface( + axes, lambda x, t: 0 + ) + input_plane.set_style( + fill_opacity=0.3, + fill_color=PINK, + stroke_width=.2, + stroke_color=WHITE, + ) + + axes.input_plane = input_plane + + self.region_corners=[ + input_plane.get_corner(pos) for pos in (DL,DR,UR,UL)] + + return axes + + + def setup_axes(self): + axes = self.get_three_d_axes(include_labels=True) + axes.add(axes.input_plane) + axes.scale(1) + # axes.center() + axes.shift(axes.axes_shift) + + self.add(axes) + self.axes = axes + + def add_axes_numbers(self, axes): + x_axis = axes.x_axis + y_axis = axes.y_axis + tex_vals_x = [ + ("a", axes.a+.4), + ("b", axes.b), + ] + tex_vals_y=[ + ("c", axes.c+.4), + ("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) + label.rotate(180 * DEGREES) + x_labels.add(label) + x_axis.add(x_labels) + x_axis.numbers = x_labels + + for tex, val in tex_vals_y: + label = TexMobject(tex) + label.scale(1) + label.next_to(y_axis.n2p(val), LEFT) + label.rotate(90 * DEGREES) + y_labels.add(label) + + y_axis.add(y_labels) + y_axis.numbers = y_labels + + return axes + + def add_axes_labels(self, axes): + x_label = TexMobject("x") + x_label.next_to(axes.x_axis.get_end(), RIGHT) + axes.x_axis.label = x_label + + y_label = TextMobject("y") + y_label.rotate(90 * DEGREES, OUT) + y_label.next_to(axes.y_axis.get_end(), UP) + axes.y_axis.label = y_label + + z_label = TextMobject("z") + z_label.rotate(90 * DEGREES, LEFT) + z_label.next_to(axes.z_axis.get_zenith(), LEFT) + axes.z_axis.label = z_label + for axis in axes: + axis.add(axis.label) + return axes + +#uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem + + diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif Binary files differnew file mode 100644 index 0000000..ac13f21 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.gif diff --git a/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py new file mode 100644 index 0000000..c998f3b --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/integrals-of-multivariable-functions/fubini's_theorem/surface2.py @@ -0,0 +1,286 @@ +from manimlib.imports import * + +class SurfacesAnimation(ThreeDScene): + + CONFIG = { + "axes_config": { + "x_min": 0, + "x_max": 4, + "y_min": 0, + "y_max": 4, + "z_min": -2, + "z_max": 4, + "a":0 ,"b": 4, "c":0 , "d":4, + "axes_shift":IN+2*LEFT+2*DOWN, + "x_axis_config": { + "tick_frequency": 1, + "include_tip": False, + }, + "y_axis_config": { + "tick_frequency": 1, + "include_tip": False, + }, + "z_axis_config": { + "tick_frequency": 1, + # "include_tip": False, + }, + "num_axis_pieces": 1, + }, + "default_graph_style": { + "stroke_width": 2, + "stroke_color": WHITE, + }, + "default_surface_config": { + "fill_opacity": 0.5, + "checkerboard_colors": [LIGHT_GREY], + "stroke_width": 0.5, + "stroke_color": WHITE, + "stroke_opacity": 0.5, + }, + "Func": lambda x,y: x*y/4 + } + + + def construct(self): + + self.setup_axes() + self.set_camera_orientation( + distance=30, + phi=75 * DEGREES, + theta=20 * DEGREES, + ) + + fn_text=TextMobject("$z=xy$").set_color(BLUE).scale(1.5) + fn_text.to_corner(UR,buff=2) + self.add_fixed_in_frame_mobjects(fn_text) + + + #get the surface + surface= self.get_surface( + self.axes, lambda x , y: + self.Func(x,y) + ) + surface.set_style( + fill_opacity=.5, + fill_color=BLUE_E, + stroke_width=0.2, + stroke_color=WHITE, + ) + #get boundary curves + c1=self.get_curve( + self.axes, lambda x: x**2/4 + ) + c1_label=TextMobject("$y=x^2$").next_to(c1,IN+OUT).shift(DOWN+RIGHT) + c1_label.rotate(PI) + c1_group=VGroup(c1,c1_label).set_color(ORANGE) + + c2=self.get_curve( + self.axes, lambda x: x + ).set_color(PINK) + c2_label=TextMobject("$y=x$").next_to(c2,IN+OUT) + c2_label.rotate(PI/2,about_point=(c2_label.get_corner(UL))) + c2_group=VGroup(c2,c2_label).set_color(YELLOW_E) + + + + self.add(c1,c2,c1_label,c2_label) + + self.begin_ambient_camera_rotation(rate=0.4) + self.get_region(self.axes,c1,c2) + self.play(Write(surface)) + self.get_lines() + self.wait(1) + self.stop_ambient_camera_rotation() + self.move_camera( + distance=20, + phi=10 * DEGREES, + theta=80 * DEGREES, + run_time=2.5 + ) + self.wait(2) + + + + def get_curve(self,axes, func, **kwargs): + config = { + "t_min": axes.x_min, + "t_max": axes.x_max, + } + config.update(kwargs) + return ParametricFunction( + lambda x : axes.c2p( + x, func(x),0 + ), + **config + ) + + def get_region(self,axes,curve1,curve2,**kwargs): + x_vals=np.arange(axes.x_min,axes.x_max,.1) + c1_points=[curve1.get_point_from_function(x) for x in x_vals] + c2_points=[curve2.get_point_from_function(x) for x in x_vals] + c2_points.reverse() + points=c1_points+c2_points + region=Polygon(*points, + stroke_width=0, + fill_color=PINK, + fill_opacity=.5 + ) + R=TextMobject("R").set_color(PINK).scale(2).rotate(180*DEGREES , OUT) + R.move_to(region,IN+RIGHT) + + self.play(Write(region)) + self.add(R) + + def get_surface(self,axes, func, **kwargs): + config = { + "u_min": axes.x_max, + "u_max": axes.x_min, + "v_min": axes.y_max, + "v_max": axes.y_min, + "resolution": (10,10), + } + + 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,"YELLOW")) + + 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 + + #customize 3D axes + def get_three_d_axes(self, include_labels=True, include_numbers=True, **kwargs): + config = dict(self.axes_config) + config.update(kwargs) + axes = ThreeDAxes(**config) + axes.set_stroke(width=2) + + if include_numbers: + self.add_axes_numbers(axes) + + if include_labels: + self.add_axes_labels(axes) + + # Adjust axis orientation + axes.x_axis.rotate( + 90 * DEGREES, LEFT, + about_point=axes.c2p(0, 0, 0), + ) + axes.y_axis.rotate( + 90 * DEGREES, UP, + about_point=axes.c2p(0, 0, 0), + ) + + # Add xy-plane + input_plane = self.get_surface( + axes, lambda x, t: 0 + ) + input_plane.set_style( + fill_opacity=0.3, + fill_color=PINK, + stroke_width=.2, + stroke_color=WHITE, + ) + + axes.input_plane = input_plane + + self.region_corners=[ + input_plane.get_corner(pos) for pos in (DL,DR,UR,UL)] + + return axes + + + def setup_axes(self): + axes = self.get_three_d_axes(include_labels=True) + # axes.add(axes.input_plane) + axes.scale(1) + # axes.center() + axes.shift(axes.axes_shift) + + self.add(axes) + self.axes = axes + + def add_axes_numbers(self, axes): + x_axis = axes.x_axis + y_axis = axes.y_axis + tex_vals_x = [ + ("1", axes.b), + ] + tex_vals_y=[ + ("1", axes.d) + ] + x_labels = VGroup() + y_labels = VGroup() + for tex, val in tex_vals_x: + label = TexMobject(tex) + label.scale(1) + label.next_to(x_axis.n2p(val), DOWN) + label.rotate(180 * DEGREES) + x_labels.add(label) + x_axis.add(x_labels) + x_axis.numbers = x_labels + + for tex, val in tex_vals_y: + label = TexMobject(tex) + label.scale(1) + label.next_to(y_axis.n2p(val), LEFT) + label.rotate(90 * DEGREES) + y_labels.add(label) + + y_axis.add(y_labels) + y_axis.numbers = y_labels + + return axes + + def add_axes_labels(self, axes): + x_label = TexMobject("x") + x_label.next_to(axes.x_axis.get_end(), RIGHT) + axes.x_axis.label = x_label + + y_label = TextMobject("y") + y_label.rotate(90 * DEGREES, OUT) + y_label.next_to(axes.y_axis.get_end(), UP) + axes.y_axis.label = y_label + + z_label = TextMobject("z") + z_label.rotate(90 * DEGREES, LEFT) + z_label.next_to(axes.z_axis.get_zenith(), LEFT) + axes.z_axis.label = z_label + for axis in axes: + axis.add(axis.label) + return axes + + #uploaded by Somnath Pandit.FSF2020_Fubini's_Theorem + + diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/gifs/limit_approach_point.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/gifs/limit_approach_point.gif Binary files differnew file mode 100644 index 0000000..830b6f1 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/gifs/limit_approach_point.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/limit_approach_point.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/limit_approach_point.py new file mode 100644 index 0000000..57d1d45 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/limit_approach_point.py @@ -0,0 +1,66 @@ +from manimlib.imports import *
+
+class Limit(GraphScene):
+ CONFIG = {
+ "x_min": 0,
+ "x_max": 4,
+ "y_min": 0,
+ "y_max": 4,
+ "graph_origin": ORIGIN + 3* DOWN+4*LEFT,
+ "x_labeled_nums": list(range(0, 4)),
+ "y_labeled_nums": list(range(0, 5)),
+ }
+ def construct(self):
+ topic = TextMobject("Different paths of approach to limit point")
+ topic.scale(1.5)
+ topic.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ self.play(Write(topic))
+ self.wait(1)
+ self.play(FadeOut(topic))
+
+
+
+ XTD = self.x_axis_width/(self.x_max- self.x_min)
+ YTD = self.y_axis_height/(self.y_max- self.y_min)
+
+ self.setup_axes(animate = True)
+
+ y_x = self.get_graph(lambda x : x, x_min = -1, x_max = 4)
+ y_x_lab = self.get_graph_label(y_x, label = r"y = x")
+
+ y_xsquare = self.get_graph(lambda x : x*x, x_min = -1, x_max = 4)
+ y_xsquare_lab = self.get_graph_label(y_xsquare, label = r"y = x^2")
+
+ y_1 = self.get_graph(lambda x : 1, x_min = -1, x_max = 4)
+ y_1_lab = self.get_graph_label(y_1, label = r"y = 1")
+
+ y_2minusx = self.get_graph(lambda x : 2 - x, x_min = -1, x_max = 4, color = RED)
+ y_2minusx_lab = self.get_graph_label(y_2minusx, label = r"y = 2 - x")
+
+ limit_point = Dot().shift(self.graph_origin+1*XTD*RIGHT+1*YTD*UP)
+ limit_point_lab = TextMobject(r"(1,1)")
+ limit_point_lab.next_to(limit_point, DOWN)
+
+ self.play(ShowCreation(limit_point))
+ self.play(Write(limit_point_lab))
+ self.wait(1)
+
+ self.play(ShowCreation(y_x))
+ self.play(Write(y_x_lab))
+ self.wait(1)
+
+ self.play(ShowCreation(y_xsquare))
+ self.play(Write(y_xsquare_lab))
+ self.wait(1)
+
+ self.play(ShowCreation(y_1))
+ self.play(Write(y_1_lab))
+ self.wait(1)
+
+ self.play(ShowCreation(y_2minusx))
+ self.play(Write(y_2minusx_lab))
+ self.wait(1)
+
+
+
+
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/Multivariable_Functions_Quiz.pdf b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/Multivariable_Functions_Quiz.pdf Binary files differnew file mode 100644 index 0000000..7895843 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/Multivariable_Functions_Quiz.pdf diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_derivative_vectorvf.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_derivative_vectorvf.gif Binary files differnew file mode 100644 index 0000000..a94de90 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_derivative_vectorvf.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_examples.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_examples.gif Binary files differnew file mode 100644 index 0000000..11f66f1 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_examples.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_plot_sphere.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_plot_sphere.gif Binary files differnew file mode 100644 index 0000000..ad7582c --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_plot_sphere.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_respresntation.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_respresntation.gif Binary files differnew file mode 100644 index 0000000..a173bda --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_respresntation.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_vectorvf_sine.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_vectorvf_sine.gif Binary files differnew file mode 100644 index 0000000..4f6b931 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_vectorvf_sine.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_derivative_vectorvf.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_derivative_vectorvf.py new file mode 100644 index 0000000..466e389 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_derivative_vectorvf.py @@ -0,0 +1,247 @@ +from manimlib.imports import *
+
+class Derivative(GraphScene):
+ CONFIG = {
+ "x_min": 0,
+ "x_max": 3,
+ "y_min": 0,
+ "y_max": 5,
+ "graph_origin": ORIGIN+6*LEFT+3*DOWN,
+ "x_axis_width": 6,
+ "x_labeled_nums": list(range(0, 4)),
+ "y_labeled_nums": list(range(0, 6)),
+ }
+ def construct(self):
+
+ XTD = self.x_axis_width/(self.x_max - self.x_min)
+ YTD = self.y_axis_height/(self.y_max - self.y_min)
+
+ self.setup_axes(animate = True)
+
+ graph = self.get_graph(lambda x : x*x, x_min = 0.5, x_max = 2, color = GREEN)
+
+ point1 = Dot().shift(self.graph_origin+0.25*YTD*UP + 0.5*XTD*RIGHT)
+ point1_lab = TextMobject(r"$t = a$")
+ point1_lab.scale(0.7)
+ point1_lab.next_to(point1, RIGHT)
+
+ point2 = Dot().shift(self.graph_origin+2*XTD*RIGHT+4*YTD*UP)
+ point2_lab = TextMobject(r"$t = b$")
+ point2_lab.scale(0.7)
+ point2_lab.next_to(point2, RIGHT)
+
+
+ vector1 = Arrow(self.graph_origin, self.graph_origin+1*YTD*UP + 1*XTD*RIGHT, buff=0.02, color = RED)
+ vector1_lab = TextMobject(r"$\vec r(t)$", color = RED)
+ vector1_lab.move_to(self.graph_origin+1.2*XTD*RIGHT+ 0.75*YTD*UP)
+ vector1_lab.scale(0.8)
+
+ vector2 = Arrow(self.graph_origin, self.graph_origin+2.25*YTD*UP + 1.5*XTD*RIGHT, buff=0.02, color = YELLOW_C)
+ vector2_lab = TextMobject(r"$\vec r(t + h)$", color = YELLOW_C)
+ vector2_lab.move_to(self.graph_origin+0.5*XTD*RIGHT+ 2*YTD*UP)
+ vector2_lab.scale(0.8)
+
+ vector3 = Arrow(self.graph_origin+1*YTD*UP + 1*XTD*RIGHT, self.graph_origin+2.25*YTD*UP + 1.5*XTD*RIGHT, buff=0.02, color = PINK)
+ vector3_lab = TextMobject(r"$\vec r(t + h) - \vec r(t)$", color = PINK)
+ vector3_lab.move_to(self.graph_origin+2*XTD*RIGHT+ 1.5*YTD*UP)
+ vector3_lab.scale(0.8)
+
+
+ self.play(ShowCreation(graph))
+ self.play(ShowCreation(point1), Write(point1_lab))
+ self.play(ShowCreation(point2), Write(point2_lab))
+
+ self.play(GrowArrow(vector1),Write(vector1_lab))
+ self.play(GrowArrow(vector2),Write(vector2_lab))
+ self.play(GrowArrow(vector3),Write(vector3_lab))
+ self.wait(1)
+
+ self.display_text()
+
+ self.play(ApplyMethod(vector3_lab.move_to,(self.graph_origin+2.3*XTD*RIGHT+ 2.2*YTD*UP)))
+
+ vector4 = Arrow(self.graph_origin+1*YTD*UP + 1*XTD*RIGHT, self.graph_origin+1*YTD*UP + 1.5*XTD*RIGHT, buff=0.02, color = PURPLE)
+ vector4_lab = TextMobject(r"$dx$", color = PURPLE)
+ vector4_lab.move_to(self.graph_origin+1.7*XTD*RIGHT+ 0.8*YTD*UP)
+ vector4_lab.scale(0.7)
+
+ vector5 = Arrow(self.graph_origin+1*YTD*UP + 1.5*XTD*RIGHT, self.graph_origin+2.25*YTD*UP + 1.5*XTD*RIGHT, buff=0.02, color = ORANGE)
+ vector5_lab = TextMobject(r"$dy$", color = ORANGE)
+ vector5_lab.move_to(self.graph_origin+1.7*XTD*RIGHT+ 1.4*YTD*UP)
+ vector5_lab.scale(0.7)
+
+ self.play(GrowArrow(vector4),Write(vector4_lab))
+ self.play(GrowArrow(vector5),Write(vector5_lab))
+ self.wait(2)
+
+
+
+ def display_text(self):
+ text1 = TextMobject(r"$\vec r(t)$",r"+", r"$\vec r(t + h) - \vec r(t)$")
+ text1[0].set_color(RED)
+ text1[2].set_color(PINK)
+ text1.scale(0.7)
+
+ text2 = TextMobject(r"$\vec r(t + h)$", color = YELLOW_C)
+ text2.scale(0.7)
+
+ text3 = TextMobject(r"$ \vec r(t + h) - \vec r(t)$", color = PINK)
+ text3.scale(0.7)
+
+ text4 = TextMobject(r"[", r"$x(t+h)$", r"$\vec i$", r"+", r"$y(t+h)$", r"$\vec j$", r"$] - [$", r"$x(t)$", r"$\vec i$", r"+", r"y(t)", r"$\vec j$", r"]")
+ text4.set_color_by_tex(r"\vec i", BLUE)
+ text4.set_color_by_tex(r"\vec j", GREEN)
+ text4[1].set_color(YELLOW_C)
+ text4[4].set_color(YELLOW_C)
+ text4[-6].set_color(RED)
+ text4[-3].set_color(RED)
+ text4.scale(0.7)
+
+ text5 = TextMobject(r"$[x(t+h) - x(t)]$", r"$\vec i$", r"+", r"$[y(t+h) + y(t)]$", r"$\vec j$")
+ text5.set_color_by_tex(r"\vec i", BLUE)
+ text5.set_color_by_tex(r"\vec j", GREEN)
+ text5[0].set_color(PURPLE)
+ text5[3].set_color(ORANGE)
+ text5.scale(0.7)
+
+ text6 = TextMobject(r"$\frac{[\vec r(t + h) - \vec r(t)]}{h}$", r"=", r"$\frac{[x(t+h) - x(t)]}{h}$", r"$\vec i$", r"+", r"$\frac{[y(t+h) + y(t)]}{h}$", r"$\vec j$")
+ text6.set_color_by_tex(r"\vec i", BLUE)
+ text6.set_color_by_tex(r"\vec j", GREEN)
+ text6[0].set_color(PINK)
+ text6[2].set_color(PURPLE)
+ text6[-2].set_color(ORANGE)
+ text6.scale(0.8)
+
+ text7 = TextMobject(r"$\lim_{h \rightarrow 0}$", r"$\frac{[\vec r(t + h) - \vec r(t)]}{h}$", r"=", r"$\lim_{h \rightarrow 0}$", r"$\frac{[x(t+h) - x(t)]}{h}$", r"$\vec i$", r"+", r"$\lim_{h \rightarrow 0}$", r"$\frac{[y(t+h) + y(t)]}{h}$", r"$\vec j$")
+ text7.set_color_by_tex(r"\vec i", BLUE)
+ text7.set_color_by_tex(r"\vec j", GREEN)
+ text7[1].set_color(PINK)
+ text7[4].set_color(PURPLE)
+ text7[-2].set_color(ORANGE)
+ text7.scale(0.6)
+
+ text8 = TextMobject(r"$\vec r'(t)$", r"=",r"$\vec x'(t)$", r"$\vec i$", r"+", r"$\vec y'(t)$", r"$\vec j$")
+ text8.set_color_by_tex(r"\vec i", BLUE)
+ text8.set_color_by_tex(r"\vec j", GREEN)
+ text8[0].set_color(PINK)
+ text8[2].set_color(PURPLE)
+ text8[5].set_color(ORANGE)
+ text8.scale(0.7)
+
+ text9 = TextMobject(r"$\frac{d \vec r}{dt}$", r"=", r"$\frac{d \vec x}{dt}$", r"$\vec i$", r"+", r"$\frac{d \vec y}{dt}$", r"$\vec j$")
+ text9.set_color_by_tex(r"\vec i", BLUE)
+ text9.set_color_by_tex(r"\vec j", GREEN)
+ text9[0].set_color(PINK)
+ text9[2].set_color(PURPLE)
+ text9[5].set_color(ORANGE)
+ text9.scale(0.7)
+
+
+ text10 = TextMobject(r"$d \vec r$", r"=", r"$\frac{d \vec x}{dt}dt$", r"$\vec i$", r"+", r"$\frac{d \vec y}{dt}dt$", r"$\vec j$")
+ text10.set_color_by_tex(r"\vec i", BLUE)
+ text10.set_color_by_tex(r"\vec j", GREEN)
+ text10[0].set_color(PINK)
+ text10[2].set_color(PURPLE)
+ text10[5].set_color(ORANGE)
+ text10.scale(0.7)
+
+ text11 = TextMobject(r"$d \vec r$", r"=", r"$x'(t)dt$", r"$\vec i$", r"+", r"$y'(t)dt$", r"$\vec j$")
+ text11.set_color_by_tex(r"\vec i", BLUE)
+ text11.set_color_by_tex(r"\vec j", GREEN)
+ text11[0].set_color(PINK)
+ text11[2].set_color(PURPLE)
+ text11[5].set_color(ORANGE)
+ text11.scale(0.7)
+
+ text12 = TextMobject(r"$d \vec r$", r"=", r"$dx$", r"$\vec i$", r"+", r"$dy$", r"$\vec j$")
+ text12.set_color_by_tex(r"\vec i", BLUE)
+ text12.set_color_by_tex(r"\vec j", GREEN)
+ text12[0].set_color(PINK)
+ text12[2].set_color(PURPLE)
+ text12[5].set_color(ORANGE)
+ text12.scale(0.7)
+
+
+ text1.move_to(1*UP+2.7*RIGHT)
+ text2.move_to(1*UP+2.7*RIGHT)
+ text3.move_to(1*UP+2.7*RIGHT)
+ text4.move_to(1*UP+2.7*RIGHT)
+ text5.move_to(1*UP+2.7*RIGHT)
+ text6.move_to(1*UP+2.7*RIGHT)
+ text7.move_to(1*UP+2.5*RIGHT)
+ text8.move_to(1*UP+2.7*RIGHT)
+ text9.move_to(1*UP+2.7*RIGHT)
+ text10.move_to(1*UP+2.7*RIGHT)
+ text11.move_to(1*UP+2.7*RIGHT)
+ text12.move_to(1*UP+2.7*RIGHT)
+
+ brace1 = Brace(text7[0:2], DOWN, buff = SMALL_BUFF)
+ brace2 = Brace(text7[3:6], UP, buff = SMALL_BUFF)
+ brace3 = Brace(text7[7:], DOWN, buff = SMALL_BUFF)
+ t1 = brace1.get_text(r"$\vec r'(t)$")
+ t1.set_color(PINK)
+
+ t2 = brace2.get_text(r"$\vec x'(t)$")
+ t2.set_color(PURPLE)
+
+ t3 = brace3.get_text(r"$\vec y'(t)$")
+ t3.set_color(ORANGE)
+
+
+ self.play(Write(text1))
+ self.play(Transform(text1, text2))
+ self.wait(1)
+
+ self.play(Transform(text1, text3))
+ self.wait(1)
+
+ self.play(Transform(text1, text4))
+ self.wait(1)
+
+ self.play(Transform(text1, text5))
+ self.wait(1)
+
+ self.play(Transform(text1, text6))
+ self.wait(1)
+
+ self.play(Transform(text1, text7))
+ self.wait(1)
+
+ self.play(
+ GrowFromCenter(brace1),
+ FadeIn(t1),
+ )
+ self.wait()
+ self.play(
+ ReplacementTransform(brace1.copy(),brace2),
+ ReplacementTransform(t1.copy(),t2)
+ )
+ self.wait()
+ self.play(
+ ReplacementTransform(brace2.copy(),brace3),
+ ReplacementTransform(t2.copy(),t3)
+ )
+ self.wait()
+
+ self.play(FadeOut(brace1), FadeOut(t1), FadeOut(brace2), FadeOut(t2), FadeOut(brace3), FadeOut(t3),)
+ self.wait()
+
+ self.play(Transform(text1, text8))
+ self.wait(1)
+
+ self.play(Transform(text1, text9))
+ self.wait(1)
+
+ self.play(Transform(text1, text10))
+ self.wait(1)
+
+ self.play(Transform(text1, text11))
+ self.wait(1)
+
+ self.play(Transform(text1, text12))
+ self.wait(1)
+
+
+
+
+
diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_examples.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_examples.py new file mode 100644 index 0000000..7322e47 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_examples.py @@ -0,0 +1,69 @@ +from manimlib.imports import *
+
+class Examples(GraphScene):
+ def construct(self):
+
+ rectangle = Rectangle(height = 3, width = 4, color = GREEN)
+ square = Square(side_length = 5, color = PURPLE)
+ circle = Circle(radius = 2, color = PINK)
+ radius = Line(ORIGIN,2*RIGHT)
+
+ radius.set_color(RED)
+
+ rectangle_area_func = TextMobject(r"$Area = f(Length, Breadth)$")
+ rectangle_area_func.scale(0.6)
+ square_area_func = TextMobject(r"$Area = f(Length)$")
+ circle_area_func = TextMobject(r"$Area = f(r)$")
+
+
+ rectangle_area = TextMobject(r"$Area = Length \times Breadth$")
+ rectangle_area.scale(0.6)
+ square_area = TextMobject(r"$Area = Length^2$")
+ circle_area = TextMobject(r"$Area = \pi r^2$")
+
+ braces_rect1 = Brace(rectangle, LEFT)
+ eq_text1 = braces_rect1.get_text("Length")
+ braces_rect2 = Brace(rectangle, UP)
+ eq_text2 = braces_rect2.get_text("Breadth")
+
+ braces_square = Brace(square, LEFT)
+ braces_square_text = braces_square.get_text("Length")
+
+ radius_text = TextMobject("r")
+ radius_text.next_to(radius,UP)
+
+
+
+ self.play(ShowCreation(rectangle))
+ self.wait(1)
+ self.play(GrowFromCenter(braces_rect1),Write(eq_text1),GrowFromCenter(braces_rect2),Write(eq_text2))
+ self.wait(1)
+ self.play(Write(rectangle_area_func))
+ self.wait(1)
+ self.play(Transform(rectangle_area_func, rectangle_area))
+ self.wait(1)
+ self.play(FadeOut(braces_rect1),FadeOut(eq_text1),FadeOut(braces_rect2),FadeOut(eq_text2),FadeOut(rectangle_area_func))
+
+
+ self.play(Transform(rectangle, square))
+ self.wait(1)
+ self.play(GrowFromCenter(braces_square),Write(braces_square_text))
+ self.wait(1)
+ self.play(Write(square_area_func))
+ self.wait(1)
+ self.play(Transform(square_area_func, square_area))
+ self.wait(1)
+ self.play(FadeOut(braces_square),FadeOut(braces_square_text),FadeOut(square_area_func))
+
+
+ self.play(Transform(rectangle, circle))
+ self.wait(1)
+ self.play(ShowCreation(radius),Write(radius_text))
+ self.wait(1)
+ self.play(FadeOut(radius_text),FadeOut(radius))
+ self.wait(1)
+ self.play(Write(circle_area_func))
+ self.wait(1)
+ self.play(Transform(circle_area_func, circle_area))
+ self.wait(1)
+ self.play(FadeOut(circle_area_func))
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_plot_sphere.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_plot_sphere.py new file mode 100644 index 0000000..baf08b1 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_plot_sphere.py @@ -0,0 +1,42 @@ +from manimlib.imports import *
+
+class Sphere(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes() # creates a 3D Axis
+
+ sphere = ParametricSurface(
+ lambda u, v: np.array([
+ np.sin(u)*np.cos(v),
+ np.sin(u)*np.sin(v),
+ np.cos(u)
+ ]),u_min=0,u_max=PI,v_min=0,v_max=2*PI,checkerboard_colors=[RED_D, RED_E],
+ resolution=(15, 32)).scale(2)
+
+
+
+ #self.set_camera_orientation(phi=0 * DEGREES,theta=270*DEGREES)
+
+ text3d = TextMobject(r"$f(x,y) \rightarrow Point(x,y,z)$")
+ text3d1 = TextMobject(r"$f(x,y) \rightarrow Point(x,y, 1 - x^2 - y^2)$")
+ self.add_fixed_in_frame_mobjects(text3d)
+ text3d.scale(0.7)
+ text3d1.scale(0.7)
+ text3d.to_corner(UL)
+ text3d1.to_corner(UL)
+ text3d.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ text3d1.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ self.play(Write(text3d))
+ self.wait(1)
+
+ self.play(Transform(text3d,text3d1))
+ self.add_fixed_in_frame_mobjects(text3d1)
+ self.play(FadeOut(text3d))
+
+
+ self.set_camera_orientation(phi=75 * DEGREES)
+ self.begin_ambient_camera_rotation(rate=0.3)
+
+
+ self.add(axes)
+ self.play(Write(sphere))
+ self.wait(5)
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_respresntation.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_respresntation.py new file mode 100644 index 0000000..4bfcf21 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_respresntation.py @@ -0,0 +1,80 @@ +from manimlib.imports import *
+
+class MultivariableFunc(Scene):
+ def construct(self):
+
+ topic = TextMobject("Multivariable Functions")
+ topic.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ topic.scale(2)
+
+ self.play(Write(topic))
+ self.wait(1)
+ self.play(FadeOut(topic))
+
+
+ circle = Circle()
+ circle.scale(3)
+
+ eqn1 = TextMobject(r"f(x,y) = $x^2y$")
+ eqn1.set_color(YELLOW)
+
+
+
+ number1 = TextMobject("(2,1)")
+ number1.move_to(3*UP+ 3*LEFT)
+ number1.scale(1.2)
+ number1.set_color(GREEN)
+
+ output1 = TextMobject("4")
+ output1.scale(1.5)
+ output1.set_color(BLUE)
+
+ eqn1_1 = TextMobject(r"f(2,1) = $2^2(1)$")
+ eqn1_1.set_color(YELLOW)
+
+
+ self.play(ShowCreation(circle),Write(eqn1))
+ self.wait(1)
+ self.play(ApplyMethod(number1.move_to, 0.6*LEFT))
+ self.play(FadeOut(number1))
+ self.play(Transform(eqn1, eqn1_1))
+ self.wait(1)
+ self.play(ApplyMethod(output1.move_to, 3*DOWN+4*RIGHT))
+ self.wait(1)
+ self.play(FadeOut(output1))
+
+
+ eqn2 = TextMobject(r"f(x,y,z) = $x^2y+2yz$")
+ eqn2.set_color(YELLOW)
+
+ number2 = TextMobject("(2,1,3)")
+ number2.move_to(3*UP+ 3*LEFT)
+ number2.scale(1.2)
+ number2.set_color(GREEN)
+
+ output2 = TextMobject("8")
+ output2.scale(1.5)
+ output2.set_color(BLUE)
+
+ eqn2_1 = TextMobject(r"f(2,1,3) = $2^2(1) + 2(1)(3)$")
+ eqn2_1.set_color(YELLOW)
+
+ eqn2_2 = TextMobject(r"f(2,1,3) = $2 + 6$")
+ eqn2_2.set_color(YELLOW)
+
+
+
+ self.play(FadeOut(eqn1))
+ self.play(Write(eqn2))
+
+ self.wait(1)
+ self.play(ApplyMethod(number2.move_to, 1.2*LEFT))
+ self.play(FadeOut(number2))
+ self.play(Transform(eqn2, eqn2_1))
+ self.wait(1)
+ self.play(Transform(eqn2, eqn2_2))
+ self.wait(1)
+ self.play(ApplyMethod(output2.move_to, 3*DOWN+4*RIGHT))
+ self.wait(1)
+ self.play(FadeOut(output2),FadeOut(eqn2),FadeOut(circle))
+ self.wait(2)
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_vectorvf_sine.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_vectorvf_sine.py new file mode 100644 index 0000000..06e225e --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_vectorvf_sine.py @@ -0,0 +1,91 @@ +from manimlib.imports import *
+
+class SineVectors(GraphScene):
+ CONFIG = {
+ "x_min": 0,
+ "x_max": 10,
+ "y_min": -1,
+ "y_max": 1,
+ "graph_origin": ORIGIN+4*LEFT,
+ #"x_labeled_nums": list(range(-5, 6)),
+ #"y_labeled_nums": list(range(0, 5)),
+ }
+ def construct(self):
+
+
+
+
+
+ XTD = self.x_axis_width/(self.x_max - self.x_min)
+ YTD = self.y_axis_height/(self.y_max - self.y_min)
+
+ self.setup_axes(animate = True)
+
+
+ sine1 = self.get_graph(lambda x : np.sin(x), x_min = 0, x_max = 1.575, color = GREEN)
+
+ point1 = Dot().shift(self.graph_origin+1*YTD*UP + 1.575*XTD*RIGHT)
+ point1_lab = TextMobject(r"$t = (\frac{\pi}{2})$")
+ point1_lab.scale(0.7)
+ point1_lab.next_to(point1, UP)
+
+ vector1 = Arrow(self.graph_origin, self.graph_origin+1*YTD*UP + 1.575*XTD*RIGHT, buff=0.1, color = RED)
+ vector1_lab = TextMobject(r"$r(\frac{\pi}{2})$", color = RED)
+ vector1_lab.move_to(self.graph_origin+1.5*XTD*RIGHT+ 0.5*YTD*UP)
+
+ self.play(GrowArrow(vector1),Write(vector1_lab))
+ self.play(ShowCreation(point1), Write(point1_lab))
+ self.play(ShowCreation(sine1))
+ self.wait(1)
+
+
+ sine2 = self.get_graph(lambda x : np.sin(x), x_min = 1.575, x_max = 3.15, color = GREEN)
+
+ point2 = Dot().shift(self.graph_origin+3.15*XTD*RIGHT)
+ point2_lab = TextMobject(r"$t = (\pi)$")
+ point2_lab.scale(0.7)
+ point2_lab.next_to(point2, UP+RIGHT)
+
+ vector2 = Arrow(self.graph_origin, self.graph_origin+3.15*XTD*RIGHT, buff=0.1, color = BLUE)
+ vector2_lab = TextMobject(r"$r(\pi)$", color = BLUE)
+ vector2_lab.move_to(self.graph_origin+1.5*XTD*RIGHT+ 0.15*YTD*UP)
+
+ self.play(GrowArrow(vector2),Write(vector2_lab))
+ self.play(ShowCreation(point2), Write(point2_lab))
+ self.play(ShowCreation(sine2))
+ self.wait(1)
+
+
+ sine3 = self.get_graph(lambda x : np.sin(x), x_min = 3.15, x_max = 4.725, color = GREEN)
+
+ point3 = Dot().shift(self.graph_origin+1*YTD*DOWN + 4.725*XTD*RIGHT)
+ point3_lab = TextMobject(r"$t = (\frac{3\pi}{2})$")
+ point3_lab.scale(0.7)
+ point3_lab.next_to(point3, DOWN)
+
+ vector3 = Arrow(self.graph_origin, self.graph_origin+1*YTD*DOWN + 4.725*XTD*RIGHT, buff=0.1, color = YELLOW_C)
+ vector3_lab = TextMobject(r"$r(\frac{3\pi}{2})$", color = YELLOW_C)
+ vector3_lab.move_to(self.graph_origin+2*XTD*RIGHT+ 0.7*YTD*DOWN)
+
+ self.play(GrowArrow(vector3),Write(vector3_lab))
+ self.play(ShowCreation(point3), Write(point3_lab))
+ self.play(ShowCreation(sine3))
+ self.wait(1)
+
+
+ sine4 = self.get_graph(lambda x : np.sin(x), x_min = 4.725, x_max = 6.3, color = GREEN)
+
+ point4 = Dot().shift(self.graph_origin+6.3*XTD*RIGHT)
+ point4_lab = TextMobject(r"$t = (2\pi)$")
+ point4_lab.scale(0.7)
+ point4_lab.next_to(point4, UP+RIGHT)
+
+ vector4 = Arrow(self.graph_origin, self.graph_origin+6.3*XTD*RIGHT, buff=0.1, color = PURPLE)
+ vector4_lab = TextMobject(r"$r(2\pi)$", color = PURPLE)
+ vector4_lab.move_to(self.graph_origin+4.5*XTD*RIGHT+ 0.15*YTD*DOWN)
+
+ self.play(GrowArrow(vector4),Write(vector4_lab))
+ self.play(ShowCreation(point4), Write(point4_lab))
+ self.play(ShowCreation(sine4))
+ self.wait(3)
+
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 index e69de29..b50200d 100644 --- 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 @@ -0,0 +1,9 @@ +# Contributer: Nishan Poojary
+Github Account : <a href="https://github.com/nishanpoojary">nishanpoojary</a>
+<br/></br>
+## Sub-Topics Covered:
++ Scalar Functions
++ Multivariable Functions
++ Limits and continuity of Multivariable Function
++ Partial Derivatives
++ Directonal Derivatives
diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/Scalar_Function_Quiz.pdf b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/Scalar_Function_Quiz.pdf Binary files differnew file mode 100644 index 0000000..6d94a2c --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/Scalar_Function_Quiz.pdf diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif Binary files differnew file mode 100644 index 0000000..d0351e5 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_application.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_application.gif Binary files differnew file mode 100644 index 0000000..831ec8e --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_application.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves.gif Binary files differnew file mode 100644 index 0000000..2df2fde --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves2.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves2.gif Binary files differnew file mode 100644 index 0000000..724c27d --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves2.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_neural_nets.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_neural_nets.gif Binary files differnew file mode 100644 index 0000000..9d24688 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_neural_nets.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_parabola_example.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_parabola_example.gif Binary files differnew file mode 100644 index 0000000..3fdecf4 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_parabola_example.gif diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_application.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_application.py new file mode 100644 index 0000000..56b3e53 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_application.py @@ -0,0 +1,129 @@ +from manimlib.imports import *
+
+class ScalarApplication(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes() # creates a 3D Axis
+
+ cube = Cube()
+ cube.set_fill(YELLOW_E, opacity = 0.1)
+ cube.scale(2)
+ self.set_camera_orientation(phi=0 * DEGREES,theta=270*DEGREES)
+ self.play(ShowCreation(cube),ShowCreation(axes))
+
+ dot = Sphere()
+ dot.scale(0.1)
+ dot.move_to(np.array([1,0.5,1]))
+ dot.set_fill(RED)
+
+ #dot = Dot(np.array([1,0.5,1]), color = RED)
+ temp_func = TextMobject("T(x,y,z)")
+ temp_func.next_to(dot,RIGHT)
+ temp_func.set_color(RED)
+ temp_func_trans = TextMobject("T(1,0.5,1)")
+ temp_func_trans.next_to(dot,RIGHT)
+ temp_func_trans.set_color(RED)
+ temp = TextMobject(r"$36 ^\circ$")
+ temp.next_to(dot,RIGHT)
+ temp.set_color(RED_E)
+
+
+ self.play(ShowCreation(dot))
+ self.play(ShowCreation(temp_func))
+ self.play(Transform(temp_func, temp_func_trans))
+ self.wait(1)
+ self.play(Transform(temp_func, temp))
+
+
+
+
+ dot1 = Sphere()
+ dot1.scale(0.1)
+ dot1.move_to(np.array([-1,-0.8,-1.5]))
+ dot1.set_fill(BLUE_E)
+ #dot1 = Dot(np.array([-1,-0.8,-1.5]), color = BLUE)
+ temp_func1 = TextMobject("T(x,y,z)")
+ temp_func1.next_to(dot1,LEFT)
+ temp_func1.set_color(BLUE)
+ temp_func_trans1 = TextMobject("T(-1,-0.8,-1.5)")
+ temp_func_trans1.next_to(dot1,LEFT)
+ temp_func_trans1.set_color(BLUE)
+ temp1 = TextMobject(r"$24 ^\circ$")
+ temp1.next_to(dot1,LEFT)
+ temp1.set_color(BLUE)
+
+ self.play(ShowCreation(dot1))
+ self.play(ShowCreation(temp_func1))
+ self.play(Transform(temp_func1, temp_func_trans1))
+ self.wait(1)
+ self.play(Transform(temp_func1, temp1))
+
+ self.play(FadeOut(temp_func))
+ self.play(FadeOut(temp_func1))
+
+
+ self.move_camera(phi=80* DEGREES,theta=45*DEGREES,run_time=3)
+
+ self.begin_ambient_camera_rotation(rate=0.2)
+ self.wait(4)
+ self.stop_ambient_camera_rotation()
+ self.wait(2)
+
+
+
+
+class AddTempScale(Scene):
+ def construct(self):
+ temp_scale = ImageMobject("tempscale.png")
+ temp_scale.scale(4)
+ temp_scale.move_to(2*RIGHT)
+ self.play(ShowCreation(temp_scale))
+
+
+ temp_func = TextMobject("T(x,y,z)")
+ temp_func.move_to(3*UP +2*LEFT)
+ temp_func.set_color(RED)
+ temp_func_trans = TextMobject("T(1,0.5,1)")
+ temp_func_trans.move_to(3*UP +2*LEFT)
+ temp_func_trans.set_color(RED)
+ temp = TextMobject(r"$36 ^\circ$")
+ temp.set_color(RED)
+ temp.move_to(3*UP +2*LEFT)
+ temp.scale(0.7)
+
+ self.play(ShowCreation(temp_func))
+ self.play(Transform(temp_func, temp_func_trans))
+ self.wait(1)
+ self.play(Transform(temp_func, temp))
+ self.play(ApplyMethod(temp_func.move_to, 1.8*UP +1.8*RIGHT))
+
+
+ temp_func1 = TextMobject("T(x,y,z)")
+ temp_func1.move_to(2*UP +2*LEFT)
+ temp_func1.set_color(BLUE)
+ temp_func_trans1 = TextMobject("T(-1,-0.8,-1.5)")
+ temp_func_trans1.move_to(2*UP +2*LEFT)
+ temp_func_trans1.set_color(BLUE)
+ temp1 = TextMobject(r"$24 ^\circ$")
+ temp1.set_color(BLUE)
+ temp1.move_to(2*UP +2*LEFT)
+ temp1.scale(0.7)
+
+ self.play(ShowCreation(temp_func1))
+ self.play(Transform(temp_func1, temp_func_trans1))
+ self.wait(1)
+ self.play(Transform(temp_func1, temp1))
+ self.play(ApplyMethod(temp_func1.move_to, 0.6*UP +1.8*RIGHT))
+
+
+
+ transtext = TextMobject("Scalar Function Transform:")
+ transtext.set_color(GREEN)
+ transtext1 = TextMobject(r"$\mathbb{R}^3 \rightarrow \mathbb{R}$")
+ transtext1.set_color(YELLOW_E)
+ transtext.move_to(3*UP +3*LEFT)
+ transtext1.next_to(transtext,DOWN)
+ self.play(Write(transtext))
+ self.play(Write(transtext1))
+ self.wait(2)
+
+
diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_domain_range.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_domain_range.py new file mode 100644 index 0000000..9b1ca7b --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_domain_range.py @@ -0,0 +1,132 @@ +# Plotting Graphs
+from manimlib.imports import *
+
+class PlotGraphs(GraphScene):
+ CONFIG = {
+ "x_min": -5,
+ "x_max": 5,
+ "y_min": 0,
+ "y_max": 4,
+ "graph_origin": ORIGIN + 2.5* DOWN,
+ "x_labeled_nums": list(range(-5, 6)),
+ "y_labeled_nums": list(range(0, 5)),
+ }
+ def construct(self):
+
+ topic = TextMobject("Domain and Range")
+ topic.scale(2)
+ topic.set_color(YELLOW)
+ self.play(Write(topic))
+ self.play(FadeOut(topic))
+ self.wait(1)
+
+
+ XTD = self.x_axis_width/(self.x_max- self.x_min)
+ YTD = self.y_axis_height/(self.y_max- self.y_min)
+
+ self.setup_axes(animate = True)
+
+ graphobj = self.get_graph(lambda x : np.sqrt(x + 4), x_min = -4, x_max = 5)
+ graph_lab = self.get_graph_label(graphobj, label = r"\sqrt{x + 4}")
+
+
+ rangeline1 = Arrow(self.graph_origin+2.2*YTD*UP+5*XTD*LEFT, self.graph_origin+4.1*YTD*UP+5*XTD*LEFT)
+ rangeline2 = Arrow(self.graph_origin+1.7*YTD*UP+5*XTD*LEFT, self.graph_origin+5*XTD*LEFT)
+ rangeline1.set_color(RED)
+ rangeline2.set_color(RED)
+
+ rangeMsg = TextMobject(r"Range: $y \geq 0$")
+ rangeMsg.move_to(self.graph_origin+2*YTD*UP+5*XTD*LEFT)
+ rangeMsg.scale(0.5)
+ rangeMsg.set_color(YELLOW)
+
+ domainline1 = Line(self.graph_origin+0.6*YTD*DOWN+1.2*XTD*LEFT, self.graph_origin+0.6*YTD*DOWN + 4*XTD*LEFT)
+ domainline2 = Arrow(self.graph_origin+0.6*YTD*DOWN+1.1*XTD*RIGHT, self.graph_origin+0.6*YTD*DOWN + 5.3*XTD*RIGHT)
+ domainline1.set_color(PINK)
+ domainline2.set_color(PINK)
+
+ domainMsg = TextMobject(r"Domain: $x \geq -4$")
+ domainMsg.move_to(self.graph_origin+0.6*YTD*DOWN)
+ domainMsg.scale(0.5)
+ domainMsg.set_color(GREEN)
+
+
+
+
+ self.play(ShowCreation(graphobj))
+ self.play(ShowCreation(graph_lab))
+ self.wait(1)
+ self.play(GrowArrow(rangeline1))
+ self.play(GrowArrow(rangeline2))
+ self.play(Write(rangeMsg))
+ self.wait(1)
+ self.play(GrowArrow(domainline1))
+ self.play(GrowArrow(domainline2))
+ self.play(Write(domainMsg))
+ self.wait(3)
+
+ self.wait(2)
+
+
+
+
+class PlotSineGraphs(GraphScene):
+ CONFIG = {
+ "x_min": -8,
+ "x_max": 8,
+ "y_min": -1,
+ "y_max": 1,
+ "graph_origin": ORIGIN,
+ "x_labeled_nums": list(range(-8, 9)),
+ "y_labeled_nums": list(range(-1, 2)),
+ }
+ def construct(self):
+
+
+
+ XTD = self.x_axis_width/(self.x_max- self.x_min)
+ YTD = self.y_axis_height/(self.y_max- self.y_min)
+
+ self.setup_axes(animate = True)
+
+ sineobj = self.get_graph(lambda x : np.sin(x), x_min = -7, x_max = 8)
+ sine_lab = self.get_graph_label(sineobj, label = "\\sin(x)")
+
+
+ rangeline1 = Line(8*XTD*LEFT,1*YTD*UP+8*XTD*LEFT)
+ rangeline2 = Line(8*XTD*LEFT,1*YTD*DOWN+8*XTD*LEFT)
+ rangeline1.set_color(RED)
+ rangeline2.set_color(RED)
+
+ rangeMsg = TextMobject(r"Range: $-1 \leq y \leq 1$")
+ rangeMsg.move_to(1.1*YTD*UP+8.5*XTD*LEFT)
+ rangeMsg.scale(0.5)
+ rangeMsg.set_color(YELLOW)
+
+
+ domainline1 = Arrow(1.1*YTD*DOWN+2*XTD*LEFT, 1.1*YTD*DOWN + 8.5*XTD*LEFT)
+ domainline2 = Arrow(1.1*YTD*DOWN+2*XTD*RIGHT, 1.1*YTD*DOWN + 8.5*XTD*RIGHT)
+ domainline1.set_color(PINK)
+ domainline2.set_color(PINK)
+
+ domainMsg = TextMobject(r"Domain: $[-\infty, \infty]$")
+ domainMsg.move_to(1.1*YTD*DOWN)
+ domainMsg.scale(0.5)
+ domainMsg.set_color(GREEN)
+
+
+
+ self.play(ShowCreation(sineobj))
+ self.play(ShowCreation(sine_lab))
+ self.wait(1)
+ self.play(GrowArrow(rangeline1))
+ self.play(GrowArrow(rangeline2))
+ self.play(Write(rangeMsg))
+ self.wait(1)
+ self.play(GrowArrow(domainline1))
+ self.play(GrowArrow(domainline2))
+ self.play(Write(domainMsg))
+ self.wait(3)
+
+
+
\ No newline at end of file diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_neural_nets.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_neural_nets.py new file mode 100644 index 0000000..eb6bf45 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_neural_nets.py @@ -0,0 +1,177 @@ +from manimlib.imports import *
+
+class SigmoidFunc(GraphScene):
+ CONFIG = {
+ "x_min": -4,
+ "x_max": 4,
+ "y_min": -1,
+ "y_max": 1,
+ "graph_origin": ORIGIN + 0.8*DOWN,
+ "x_labeled_nums": list(range(-4, 5)),
+ "y_labeled_nums": list(range(-1, 2)),
+ "y_axis_height": 4.5,
+ }
+ def construct(self):
+ XTD = self.x_axis_width/(self.x_max- self.x_min)
+ YTD = self.y_axis_height/(self.y_max- self.y_min)
+
+ topic = TextMobject("Sigmoid Function")
+ topic.move_to(3.2*UP)
+ topic.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+
+ self.setup_axes(animate = True)
+ sigmoid_func = self.get_graph(lambda x : (1/(1 + np.exp(-x))), x_min = -4, x_max = 4)
+ sigmoid_lab = self.get_graph_label(sigmoid_func, label = r"\frac{1}{1 + e^{-z}}")
+
+
+
+
+ self.play(ShowCreation(sigmoid_func),Write(sigmoid_lab))
+ self.play(Write(topic))
+ self.wait(2)
+ self.play(FadeOut(sigmoid_func), FadeOut(sigmoid_lab))
+ self.wait(1)
+
+
+
+class NeuralNet(GraphScene):
+ def construct(self):
+
+ sigmoid_exp = TextMobject(r"g(z) = g($\theta^T$ X) = $\frac{1}{1 + e^{-z}}$")
+ sigmoid_exp.move_to(3*UP + 4*LEFT)
+ sigmoid_exp.scale(0.8)
+ sigmoid_exp.set_color(BLUE)
+ sigmoid_exp1 = TextMobject(r"Predict: 'y = 1'",r"When g(z) $\geq$ 0.5, z $\geq$ 0, $\theta^T$ X $\geq$ 0")
+ sigmoid_exp2 = TextMobject(r"Predict: 'y = 0'", r"When g(z) $\leq$ 0.5, z $\leq$ 0, $\theta^T$ X $\leq$ 0")
+ sigmoid_exp1.scale(0.5)
+ sigmoid_exp2.scale(0.5)
+ sigmoid_exp1.set_color(PURPLE)
+ sigmoid_exp2.set_color(PURPLE)
+
+ sigmoid_exp1[0].next_to(sigmoid_exp, 1.5*DOWN)
+ sigmoid_exp1[1].next_to(sigmoid_exp1[0], DOWN)
+ sigmoid_exp2[0].next_to(sigmoid_exp1[1], 1.5*DOWN)
+ sigmoid_exp2[1].next_to(sigmoid_exp2[0], DOWN)
+
+
+ self.play(Write(sigmoid_exp))
+ self.play(Write(sigmoid_exp1[0]), Write(sigmoid_exp1[1]))
+ self.play(Write(sigmoid_exp2[0]), Write(sigmoid_exp2[1]))
+ self.wait(2)
+
+
+ neuron1 = Circle()
+ neuron1.set_fill(YELLOW_A, opacity = 0.5)
+
+ neuron2 = Circle()
+ neuron2.set_fill(ORANGE, opacity = 0.5)
+
+ neuron3 = Circle()
+ neuron3.set_fill(GREEN_E, opacity = 0.5)
+
+ neuron1.move_to(2*UP+RIGHT)
+ neuron2.move_to(2*DOWN+RIGHT)
+ neuron3.move_to(4*RIGHT)
+
+ arrow1 = Arrow(neuron1.get_right(),neuron3.get_left(),buff=0.1)
+ arrow1.set_color(RED)
+ arrow2 = Arrow(neuron2.get_right(),neuron3.get_left(),buff=0.1)
+ arrow2.set_color(RED)
+
+ arrow3 = Arrow(neuron3.get_right(),7*RIGHT,buff=0.1)
+ arrow3.set_color(RED)
+
+
+ sign1 = TextMobject("+1")
+ sign1.move_to(2*UP+RIGHT)
+ sign1.scale(2)
+ sign2 = TextMobject(r"$x_1$")
+ sign2.move_to(2*DOWN+RIGHT)
+ sign2.scale(2)
+ sign3 = TextMobject(r"$h_{\theta}(x)$")
+ sign3.move_to(6*RIGHT+0.4*DOWN)
+ sign3.scale(0.7)
+ sign4 = TextMobject(r"$= g(10 - 20x_1)$")
+ sign4.next_to(sign3,DOWN)
+ sign4.scale(0.5)
+ sign5 = TextMobject(r"$= g(10 - 20x_1)$")
+ sign5.next_to(sign3,DOWN)
+ sign5.scale(0.5)
+ sign6 = TextMobject(r"$= g(10 - 20x_1)$")
+ sign6.next_to(sign3,DOWN)
+ sign6.scale(0.5)
+
+
+ weight1 = TextMobject("10")
+ weight1.next_to(arrow1,UP)
+ weight2 = TextMobject("-20")
+ weight2.next_to(arrow2,DOWN)
+
+ gate = TextMobject("NOT GATE")
+ gate.set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ gate.scale(1.5)
+ gate.move_to(3*RIGHT+3.5*UP)
+
+
+
+ truth_table = TextMobject(r"\begin{displaymath}\begin{array}{|c|c|} x & y\\ \hline 1 & 0 \\0 & 1 \\\end{array}\end{displaymath}")
+ truth_table.next_to(sigmoid_exp2[1], 3*DOWN)
+
+ values = TextMobject("1", "0")
+ values.scale(2)
+
+ sign4_trans1 = TextMobject(r"$= g(10 - 20(1))$")
+ sign4_trans2 = TextMobject(r"$= g(10 - 20(0))$")
+ sign4_trans1.next_to(sign3,DOWN)
+ sign4_trans2.next_to(sign3,DOWN)
+ sign4_trans1.scale(0.5)
+ sign4_trans2.scale(0.5)
+
+
+
+ output1 = TextMobject("y = 0")
+ output2 = TextMobject("y = 1")
+ output1.next_to(sign4,DOWN)
+ output2.next_to(sign4,DOWN)
+ output1.scale(1.5)
+ output2.scale(1.5)
+
+
+
+ self.play(ShowCreation(neuron1),ShowCreation(neuron2))
+ self.play(ShowCreation(neuron3))
+ self.play(ShowCreation(sign1),ShowCreation(sign2))
+ self.wait(1)
+
+ self.play(GrowArrow(arrow1))
+ self.play(GrowArrow(arrow2))
+ self.play(ShowCreation(weight1),ShowCreation(weight2))
+
+
+
+ self.play(GrowArrow(arrow3))
+ self.play(Write(sign3),Write(sign4))
+
+ self.play(Write(gate))
+ self.play(ShowCreation(truth_table))
+
+ self.play(ApplyMethod(values[0].move_to, 2*DOWN+RIGHT))
+ self.play(FadeOut(values[0]))
+ self.play(Transform(sign4,sign4_trans1))
+ self.play(Write(output1))
+ self.wait(1)
+ self.play(FadeOut(output1))
+ self.play(Transform(sign4, sign5))
+
+
+ self.play(ApplyMethod(values[1].move_to, 2*DOWN+RIGHT))
+ self.play(FadeOut(values[1]))
+ self.play(Transform(sign4,sign4_trans2))
+ self.play(Write(output2))
+ self.wait(1)
+ self.play(FadeOut(output2))
+ self.play(Transform(sign4, sign6))
+
+ self.wait(2)
+
+
diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_parabola_example.py b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_parabola_example.py new file mode 100644 index 0000000..74dc063 --- /dev/null +++ b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_parabola_example.py @@ -0,0 +1,35 @@ +from manimlib.imports import *
+
+class Parabola(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes() # creates a 3D Axis
+
+ paraboloid = ParametricSurface(
+ lambda u, v: np.array([
+ 2*np.cosh(u)*np.cos(v),
+ 2*np.cosh(u)*np.sin(v),
+ 2*np.sinh(u)
+ ]),v_min=0,v_max=TAU,u_min=0,u_max=2,checkerboard_colors=[YELLOW_D, YELLOW_E],
+ resolution=(15, 32))
+
+ text3d = TextMobject(r"Plot of $f: \mathbb{R}^2 \rightarrow \mathbb{R}$", "z = f(x,y)")
+ self.add_fixed_in_frame_mobjects(text3d)
+ text3d[0].move_to(4*LEFT+2*DOWN)
+ text3d[1].next_to(text3d[0], DOWN)
+ text3d[0].set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE)
+ text3d[1].set_color_by_gradient(RED, ORANGE, YELLOW, GREEN, BLUE)
+
+ #self.set_camera_orientation(phi=0 * DEGREES,theta=270*DEGREES)
+ self.move_camera(phi=110* DEGREES,theta=45*DEGREES)
+ self.add(axes)
+ self.play(ShowCreation(paraboloid))
+ self.play(Write(text3d[0]))
+ self.play(Write(text3d[1]))
+ self.begin_ambient_camera_rotation(rate=0.2)
+ self.wait(3)
+ self.move_camera(phi=0 * DEGREES,theta=180*DEGREES,run_time=3)
+ self.wait(3)
+ self.move_camera(phi=110* DEGREES,theta=90*DEGREES,run_time=3)
+ self.wait(3)
+
+
\ No newline at end of file |
