From d522cbd8782ba712da3acac9cb60a60edb925b1e Mon Sep 17 00:00:00 2001 From: Archit Sangal Date: Sat, 23 May 2020 20:45:28 +0530 Subject: Files added to Linear Transformations (Linear Maps) --- .../Animation.py | 0 ...1_Understand_Linear_Transformations_visually.py | 193 +++++++++++++++++++++ .../file2_Uniform_Scaling.py | 91 ++++++++++ .../file3_Horizontal_Shear.py | 53 ++++++ .../file3_Horizontal_Shear_gif.gif | Bin 0 -> 1566999 bytes .../file4_Vertical_Shear.py | 52 ++++++ .../file4_Vertical_Shear_gif.gif | Bin 0 -> 1347079 bytes 7 files changed, 389 insertions(+) delete mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file1_Understand_Linear_Transformations_visually.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file2_Uniform_Scaling.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear_gif.gif create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear.py create mode 100644 FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear_gif.gif diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/Animation.py deleted file mode 100644 index e69de29..0000000 diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file1_Understand_Linear_Transformations_visually.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file1_Understand_Linear_Transformations_visually.py new file mode 100644 index 0000000..577032d --- /dev/null +++ b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file1_Understand_Linear_Transformations_visually.py @@ -0,0 +1,193 @@ +from manimlib.imports import * + +class Rotation(GraphScene): + CONFIG = { + "x_min" : -5, + "x_max" : 5, + "y_min" : -5, + "y_max" : 5, + "graph_origin" : ORIGIN+3.5*LEFT, + "x_axis_width" : 7, + "y_axis_height" : 7 + #"x_labeled_nums" : list(range(-5,6)), + #"y_labeled_nums" : list(range(-5,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) + + introText = TextMobject("Understanding Linear Transformations") + self.play(Write(introText)) + self.wait(1) + + introText1 = TextMobject("Visually ... ") + introText1.move_to(DOWN) + self.play(Write(introText1)) + self.wait(1) + self.play(FadeOut(introText), FadeOut(introText1)) + + Text1 = TextMobject("Let $\overrightarrow{v}$ be $2\hat{i}+3\hat{j}$") + Text2 = TextMobject("$\overrightarrow{v} = 2\hat{i}+3\hat{j}$") + + Text1.move_to(4*RIGHT+2*UP) + Text2.move_to(4*RIGHT+1*UP) + self.play(Write(Text1)) + self.wait() + self.play(Transform(Text1,Text2)) + + self.setup_axes(animate=True) + arrow_v = Arrow(stroke_width = 3, start = self.graph_origin + 0.15*LEFT + 0.25*DOWN, end = self.graph_origin+2*XTD*RIGHT+3*YTD*UP+ 0.15*RIGHT + 0.25*UP) + self.play(ShowCreation(arrow_v)) + + Text_i = TextMobject("$\hat{i}$") + Text_i.move_to(self.graph_origin+0.5*XTD*RIGHT+0.5*YTD*DOWN) + Text_i.scale(0.75) + Text_j = TextMobject("$\hat{j}$") + Text_j.move_to(self.graph_origin+0.5*XTD*LEFT+0.5*YTD*UP) + Text_j.scale(0.75) + + arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+1*YTD*UP+0.25*UP) + self.play(ShowCreation(arrow_i), ShowCreation(arrow_j), Write(Text_i), Write(Text_j)) + + Text_2i = TextMobject("$2\hat{i}$") + Text_2i.move_to(self.graph_origin+1*XTD*RIGHT+1*YTD*DOWN) + Text_3j = TextMobject("$3\hat{j}$") + Text_3j.move_to(self.graph_origin+1*XTD*LEFT+1.5*YTD*UP) + + arrow_2i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+2*XTD*RIGHT+ 0.25*RIGHT) + arrow_2i.set_color(YELLOW) + arrow_3j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+3*YTD*UP+0.25*UP) + arrow_3j.set_color(RED) + self.wait(0.5) + self.play(Transform(arrow_i,arrow_2i), Transform(arrow_j,arrow_3j), Transform(Text_i,Text_2i), Transform(Text_j,Text_3j)) + self.play(ApplyMethod(arrow_j.move_to,self.graph_origin+2*XTD*RIGHT+1.5*YTD*UP) , ApplyMethod(Text_j.move_to,self.graph_origin+2.5*XTD*RIGHT+1.5*YTD*UP+ 0.15*RIGHT + 0.25*UP)) + + new_Text_v = TextMobject("$\overrightarrow{v}$") + new_Text_v.move_to(self.graph_origin+0.5*XTD*RIGHT+1.5*YTD*UP) + self.play(Write(new_Text_v)) + + new_arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + new_arrow_i.set_color(YELLOW) + new_arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+1*YTD*UP+0.25*UP) + new_arrow_j.set_color(RED) + + new_Text_i = TextMobject("$\hat{i}$") + new_Text_i.move_to(self.graph_origin+0.5*XTD*RIGHT+0.5*YTD*DOWN) + new_Text_i.scale(0.75) + new_Text_j = TextMobject("$\hat{j}$") + new_Text_j.move_to(self.graph_origin+0.5*XTD*LEFT+0.5*YTD*UP) + new_Text_j.scale(0.75) + + self.wait(1) + + self.play(FadeOut(Text_i), + FadeOut(Text_j), + FadeOut(arrow_i), + FadeOut(arrow_j), + ShowCreation(new_arrow_i), + ShowCreation(new_arrow_j), + Write(new_Text_i), + Write(new_Text_j)) + + self.play(ApplyMethod(Text1.move_to,4*RIGHT)) + Text3 = TextMobject("Let the be a linear transformation function") + Text3.scale(0.5) + Text4 = TextMobject("$T$ which rotates the vectors by angle of $90^{\circ}$") + Text4.scale(0.5) + Text3.move_to(4*RIGHT+3*UP) + Text4.move_to(4*RIGHT+2.5*UP) + self.play(Write(Text3), Write(Text4)) + self.wait(2) + + Text6 = TextMobject(r"$\begin{pmatrix} 1 \\ 0 \end{pmatrix}$") + Text6.scale(0.75) + Text6.set_color(YELLOW) + Text6.move_to(self.graph_origin+1*XTD*RIGHT+1*YTD*DOWN) + Text7 = TextMobject(r"$\begin{pmatrix} 0 \\ 1 \end{pmatrix}$") + Text7.scale(0.75) + Text7.set_color(RED) + Text7.move_to(self.graph_origin+1*XTD*LEFT+1*YTD*UP) + + self.play(Transform(new_Text_i,Text6)) + self.play(Transform(new_Text_j,Text7)) + + Text5 = TextMobject(r"$\overrightarrow{v} = 2 $", r"$\begin{pmatrix} 1 \\ 0 \end{pmatrix}$", r"+3", r"$\begin{pmatrix} 0 \\ 1 \end{pmatrix}$") + Text5[1].set_color(YELLOW) + Text5[3].set_color(RED) + Text5.move_to(4*RIGHT) + + self.play(Transform(Text1, Text5)) + self.wait() + + arrow_modified_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*UP, end = self.graph_origin-(1*YTD*UP+0.25*UP)) + arrow_modified_i.set_color(YELLOW) + arrow_modified_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + arrow_modified_j.set_color(RED) + + yellow_i = TextMobject(r"$\begin{pmatrix} 0 \\ -1 \end{pmatrix}$") + yellow_i.set_color(YELLOW).scale(0.75) + yellow_i.move_to(self.graph_origin + 1*XTD*DOWN + 1*YTD*LEFT) + + red_j = TextMobject(r"$\begin{pmatrix} 1 \\ 0 \end{pmatrix}$") + red_j.set_color(RED).scale(0.75) + red_j.move_to(self.graph_origin + 1*XTD*UP + 1*YTD*RIGHT) + + Text8 = TextMobject(r"$\overrightarrow{v}_{transformed} = 2 $", r"$\begin{pmatrix} 0 \\ -1 \end{pmatrix}$", r"+3", r"$\begin{pmatrix} 1 \\ 0 \end{pmatrix}$") + Text8[1].set_color(YELLOW) + Text8[3].set_color(RED) + Text8.move_to(4*RIGHT+1.5*DOWN) + Text8.scale(0.75) + + new_Text__v = TextMobject("$\overrightarrow{v}_{transformed}$") + new_Text__v.scale(0.75) + arrow_modified_v = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT + 0.15*UP, end = self.graph_origin+2*XTD*DOWN+3*YTD*RIGHT+ 0.15*DOWN + 0.25*RIGHT) + self.play(Transform(arrow_v, arrow_modified_v), + Transform(new_arrow_i, arrow_modified_i), + Transform(new_arrow_j, arrow_modified_j), + Transform(new_Text_i,yellow_i), + Transform(new_Text_j,red_j), + FadeOut(new_Text_v), + ApplyMethod(new_Text__v.move_to,self.graph_origin+3*XTD*RIGHT+0.5*YTD*DOWN), + Write(Text8)) + + self.play(FadeOut(Text1), FadeOut(Text3), FadeOut(Text4), ApplyMethod(Text8.move_to,4*RIGHT+3*UP)) + + Text9 = TextMobject(r"$\overrightarrow{v}_{transformed} = 2 $", r"$\hat{i}_{transformed}$", r"+3", r"$\hat{j}_{transformed}$") + Text9[1].set_color(YELLOW) + Text9[3].set_color(RED) + Text9.move_to(4*RIGHT+2*UP) + Text9.scale(0.5) + + self.play(Write(Text9)) + + v_transformed = TextMobject(r"$\overrightarrow{v}_{transformed} \equiv T(\overrightarrow{v})$") + v_transformed.scale(0.75).move_to(4*RIGHT+UP) + i_transformed = TextMobject(r"$\hat{i}_{transformed} \equiv T(\hat{i})$") + i_transformed.set_color(YELLOW).scale(0.75).move_to(4*RIGHT) + j_transformed = TextMobject(r"$\hat{v}_{transformed} \equiv T(\hat{j})$") + j_transformed.set_color(RED).scale(0.75).move_to(4*RIGHT+DOWN) + + self.play(Write(v_transformed), Write(i_transformed), Write(j_transformed)) + self.wait(3) + + Text10 = TextMobject(r"$T(\overrightarrow{v}) = $", r"$\begin{pmatrix} 3 \\ -2 \end{pmatrix}$") + Text10[1].set_color(BLUE_E) + Text10.move_to(4*RIGHT+1*UP) + Text10.scale(0.75) + + self.play(Write(Text10), ApplyMethod(v_transformed.move_to,4*RIGHT+2*UP), FadeOut(i_transformed), FadeOut(j_transformed), FadeOut(Text9)) + self.wait(1) + + self.play(FadeOut(self.axes), + FadeOut(arrow_v), + FadeOut(new_arrow_i), + FadeOut(new_arrow_j), + FadeOut(new_Text_i), + FadeOut(new_Text_i), + FadeOut(new_Text_j), + FadeOut(new_Text__v), + FadeOut(Text10), + FadeOut(v_transformed), + FadeOut(Text8)) diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file2_Uniform_Scaling.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file2_Uniform_Scaling.py new file mode 100644 index 0000000..a7856a5 --- /dev/null +++ b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file2_Uniform_Scaling.py @@ -0,0 +1,91 @@ +from manimlib.imports import * + +class Scaling(GraphScene): + CONFIG = { + "x_min" : -5, + "x_max" : 5, + "y_min" : -5, + "y_max" : 5, + "graph_origin" : ORIGIN+3.5*LEFT, + "x_axis_width" : 7, + "y_axis_height" : 7 + #"x_labeled_nums" : list(range(-5,6)), + #"y_labeled_nums" : list(range(-5,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) + + introText = TextMobject("Scaling") + self.play(Write(introText)) + self.wait(1) + self.play(FadeOut(introText)) + + introText = TextMobject("Uniform Scaling") + self.play(Write(introText)) + self.wait(1) + self.play(FadeOut(introText)) + + Text1 = TextMobject("Let $\overrightarrow{v}$ be $3\hat{i}+3\hat{j}$") + Text2 = TextMobject("$\overrightarrow{v} = 3\hat{i}+3\hat{j}$") + + Text1.move_to(4*RIGHT+2*UP) + Text2.move_to(4*RIGHT+1*UP) + self.play(Write(Text1)) + self.wait() + self.play(Transform(Text1,Text2)) + + self.setup_axes(animate=True) + arrow_v = Arrow(stroke_width = 4, start = self.graph_origin + 0.15*LEFT + 0.15*DOWN, end = self.graph_origin+3*XTD*RIGHT+3*YTD*UP+ 0.15*RIGHT + 0.15*UP) + vector_v = TextMobject(r"$\vec{v}$") + vector_v.move_to(self.graph_origin + 1*XTD*RIGHT + 2*YTD*UP ) + self.play(ShowCreation(arrow_v),Write(vector_v)) + scaling_factor = TextMobject(r"Scaling Factor = $\frac{4}{3}$") + scaling_factor.scale(0.75) + scaled_vector = TextMobject(r"$T(\vec{v}) = \frac{4}{3} \left[ \begin{array} {c} 3 \\ 3 \end{array} \right] = \left[ \begin{array} {c} 4 \\ 4 \end{array} \right]$") + scaled_vector.set_color(DARK_BLUE) + scaled_vector.scale(0.75) + scaling_factor.move_to(4*RIGHT) + scaled_vector.move_to(4*RIGHT+DOWN) + self.play(Write(scaling_factor)) + self.wait() + self.play(Write(scaled_vector)) + + transformed_arrow_v = Arrow(stroke_width = 2, start = self.graph_origin + 0.15*LEFT + 0.15*DOWN, end = self.graph_origin+4*XTD*RIGHT+4*YTD*UP+ 0.15*RIGHT + 0.15*UP) + transformed_arrow_v.set_color(DARK_BLUE) + transformed_vector_v = TextMobject(r"$T(\vec{v})$") + transformed_vector_v.move_to(self.graph_origin + 4.5*XTD*RIGHT + 4.5*YTD*UP ) + transformed_vector_v.set_color(DARK_BLUE) + self.play(ShowCreation(transformed_arrow_v), Write(transformed_vector_v)) + + self.wait() + + represent_text1 = TextMobject("Representation of scaling") + represent_text2 = TextMobject("of vectors in point form") + represent_text1.move_to(4*RIGHT+3*UP) + represent_text2.move_to(4*RIGHT+2*UP) + self.play(Write(represent_text1), Write(represent_text2)) + + dot_init = Dot(self.graph_origin+3*XTD*RIGHT+3*YTD*UP) + dot_trans = Dot(self.graph_origin+4*XTD*RIGHT+4*YTD*UP) + + self.play(ApplyMethod(vector_v.move_to,self.graph_origin+2.5*XTD*RIGHT+2.5*YTD*UP), + ApplyMethod(transformed_vector_v.move_to,self.graph_origin+4.5*XTD*RIGHT+4.5*YTD*UP), + ShowCreation(dot_init), + Transform(arrow_v,dot_init), + Transform(transformed_arrow_v,dot_trans)) + + self.wait(2) + + self.play(FadeOut(dot_init), + FadeOut(arrow_v), + FadeOut(transformed_arrow_v), + FadeOut(represent_text1), + FadeOut(represent_text2), + FadeOut(self.axes), + FadeOut(scaling_factor), + FadeOut(scaled_vector), + FadeOut(transformed_vector_v), + FadeOut(vector_v), + FadeOut(Text1)) \ No newline at end of file diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear.py new file mode 100644 index 0000000..91f098e --- /dev/null +++ b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear.py @@ -0,0 +1,53 @@ +from manimlib.imports import * + +class Hori_Shear(GraphScene): + CONFIG = { + "x_min" : -5, + "x_max" : 5, + "y_min" : -5, + "y_max" : 5, + "graph_origin" : ORIGIN+3.5*LEFT, + "x_axis_width" : 7, + "y_axis_height" : 7 + #"x_labeled_nums" : list(range(-5,6)), + #"y_labeled_nums" : list(range(-5,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) + + Text1 = TextMobject("Before"," Horizontal") + Text1[0].set_color(YELLOW) + Text2 = TextMobject("Shear Transformation") + + Text1.move_to(4*RIGHT+2*UP) + Text2.move_to(4*RIGHT+1*UP) + + self.setup_axes(animate=False) + arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+1*XTD*UP+0.25*UP) + arrow_i.set_color(YELLOW) + arrow_j.set_color(YELLOW) + + square = Polygon(self.graph_origin,self.graph_origin+2*XTD*RIGHT, self.graph_origin+2*XTD*RIGHT+2*YTD*UP, self.graph_origin+2*YTD*UP) + square.set_color(DARK_BLUE) + self.play(ShowCreation(square), Write(Text1), Write(Text2), ShowCreation(arrow_i), ShowCreation(arrow_j)) + self.wait(1) + + Text3 = TextMobject("After"," Horizontal") + Text3[0].set_color(RED) + Text4 = TextMobject("Shear Transformation") + + Text3.move_to(4*RIGHT+2*UP) + Text4.move_to(4*RIGHT+1*UP) + + trans_arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + trans_arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.15*DOWN + 0.15*LEFT, end = self.graph_origin+1*XTD*UP+1*YTD*RIGHT+0.25*UP+0.25*RIGHT) + trans_arrow_i.set_color(RED) + trans_arrow_j.set_color(RED) + + rhombus = Polygon(self.graph_origin,self.graph_origin+2*XTD*RIGHT, self.graph_origin+4*XTD*RIGHT+2*YTD*UP, self.graph_origin+2*XTD*RIGHT+2*YTD*UP) + square.set_color(DARK_BLUE) + self.play(Transform(arrow_i,trans_arrow_i), Transform(arrow_j,trans_arrow_j), Transform(square,rhombus), Transform(Text1,Text3), Transform(Text2,Text4)) + self.wait(1) \ No newline at end of file diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear_gif.gif b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear_gif.gif new file mode 100644 index 0000000..9bef1b6 Binary files /dev/null and b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file3_Horizontal_Shear_gif.gif differ diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear.py b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear.py new file mode 100644 index 0000000..718e4e0 --- /dev/null +++ b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear.py @@ -0,0 +1,52 @@ +from manimlib.imports import * + +class Ver_Shear(GraphScene): + CONFIG = { + "x_min" : -5, + "x_max" : 5, + "y_min" : -5, + "y_max" : 5, + "graph_origin" : ORIGIN+3.5*LEFT, + "x_axis_width" : 7, + "y_axis_height" : 7 + #"x_labeled_nums" : list(range(-5,6)), + #"y_labeled_nums" : list(range(-5,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) + + Text1 = TextMobject("Before"," Vertical") + Text1[0].set_color(YELLOW) + Text2 = TextMobject("Shear Transformation") + + Text1.move_to(4*RIGHT+2*UP) + Text2.move_to(4*RIGHT+1*UP) + + self.setup_axes(animate=False) + arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*LEFT, end = self.graph_origin+1*XTD*RIGHT+ 0.25*RIGHT) + arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+1*XTD*UP+0.25*UP) + arrow_i.set_color(YELLOW) + arrow_j.set_color(YELLOW) + + square = Polygon(self.graph_origin,self.graph_origin+2*XTD*RIGHT, self.graph_origin+2*XTD*RIGHT+2*YTD*UP, self.graph_origin+2*YTD*UP) + square.set_color(DARK_BLUE) + self.play(ShowCreation(square), Write(Text1), Write(Text2), ShowCreation(arrow_i), ShowCreation(arrow_j)) + self.wait(1) + + Text3 = TextMobject("After"," Vertical") + Text3[0].set_color(RED) + Text4 = TextMobject("Shear Transformation") + + Text3.move_to(4*RIGHT+2*UP) + Text4.move_to(4*RIGHT+1*UP) + + trans_arrow_i = Arrow(stroke_width = 3, start = self.graph_origin + 0.15*DOWN + 0.15*LEFT, end = self.graph_origin+1*XTD*UP+1*YTD*RIGHT+0.25*UP+0.25*RIGHT) + trans_arrow_j = Arrow(stroke_width = 3, start = self.graph_origin + 0.25*DOWN, end = self.graph_origin+1*XTD*UP+ 0.25*UP) + trans_arrow_i.set_color(RED) + trans_arrow_j.set_color(RED) + + rhombus = Polygon(self.graph_origin,self.graph_origin+2*XTD*UP, self.graph_origin+2*XTD*RIGHT+4*YTD*UP, self.graph_origin+2*XTD*RIGHT+2*YTD*UP) + self.play(Transform(arrow_i,trans_arrow_i), Transform(arrow_j,trans_arrow_j), FadeOut(square), ShowCreation(rhombus), Transform(Text1,Text3), Transform(Text2,Text4)) + self.wait(1) \ No newline at end of file diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear_gif.gif b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear_gif.gif new file mode 100644 index 0000000..7ca323f Binary files /dev/null and b/FSF-2020/linear-algebra/linear-transformations/Linear Transformations (Linear Maps)/file4_Vertical_Shear_gif.gif differ -- cgit From 29d18cfc55db1775f1c34a068ba9632bf7514d27 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:43:30 +0530 Subject: added scalar functions folder --- .../scalar_function_application.py | 129 +++++++++++++++ .../scalar_function_domain_range.py | 132 +++++++++++++++ .../scalar_function_level_curves.mp4 | Bin 0 -> 726339 bytes .../scalar_function_level_curves2.mp4 | Bin 0 -> 2088849 bytes .../scalar_function_neural_nets.py | 177 +++++++++++++++++++++ .../scalar_function_parabola_example.py | 35 ++++ 6 files changed, 473 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_application.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_domain_range.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_neural_nets.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_parabola_example.py 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_level_curves.mp4 b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 new file mode 100644 index 0000000..6af2670 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 differ diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 new file mode 100644 index 0000000..b21ae25 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 differ 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 -- cgit From 9c45f041b4702c28767117c129ce3a09ae1863ac Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:44:29 +0530 Subject: Added Multivariable Function folder --- .../multivariable_func_derivative_vectorvf.py | 247 +++++++++++++++++++++ .../multivariable_func_examples.py | 69 ++++++ .../multivariable_func_plot_sphere.py | 42 ++++ .../multivariable_func_respresntation.py | 80 +++++++ .../multivariable_func_vectorvf_sine.py | 91 ++++++++ 5 files changed, 529 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_derivative_vectorvf.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_examples.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_plot_sphere.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_respresntation.py create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/multivariable_func_vectorvf_sine.py 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) + -- cgit From bb9e15afaafe5305d27e3037530831e33a3e254c Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:45:13 +0530 Subject: Added Limits and Continuity Folder --- .../limit_approach_point.py | 66 ++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/limit_approach_point.py 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 -- cgit From ab5f5c2d48794961ace6716a1b0405c24495e9e1 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:46:00 +0530 Subject: Delete scalar_function_level_curves.mp4 --- .../Scalar Functions/scalar_function_level_curves.mp4 | Bin 726339 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 deleted file mode 100644 index 6af2670..0000000 Binary files a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves.mp4 and /dev/null differ -- cgit From d5f72078a32cd6196b34778ccc4ae8cf299b2d22 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:46:10 +0530 Subject: Delete scalar_function_level_curves2.mp4 --- .../scalar_function_level_curves2.mp4 | Bin 2088849 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 diff --git a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 deleted file mode 100644 index b21ae25..0000000 Binary files a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/scalar_function_level_curves2.mp4 and /dev/null differ -- cgit From b705303069a5fd14c5f8bde6fdb7d42454103782 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:46:53 +0530 Subject: Add files via upload --- .../Scalar Functions/Scalar_Function_Quiz.pdf | Bin 0 -> 87455 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 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/Scalar_Function_Quiz.pdf b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/Scalar_Function_Quiz.pdf new file mode 100644 index 0000000..6d94a2c Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/Scalar_Function_Quiz.pdf differ -- cgit From 00cf8aab6f8073ad4fd14cffabf90bf55a70d5eb Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:47:31 +0530 Subject: Add files via upload --- .../Multivariable_Functions_Quiz.pdf | Bin 0 -> 109631 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 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/Multivariable_Functions_Quiz.pdf b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/Multivariable_Functions_Quiz.pdf new file mode 100644 index 0000000..7895843 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/Multivariable_Functions_Quiz.pdf differ -- cgit From fed36d85239ebc725f0eabc50c67394ea32f203f Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 17:55:13 +0530 Subject: Updated Readme.md --- .../multivariable-functions-and-paritial-derivatives/README.md | 9 +++++++++ 1 file changed, 9 insertions(+) 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 : nishanpoojary +

+## Sub-Topics Covered: ++ Scalar Functions ++ Multivariable Functions ++ Limits and continuity of Multivariable Function ++ Partial Derivatives ++ Directonal Derivatives -- cgit From cf3141c14d109277d01fe7fcbd4bee5171390d1a Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 18:02:15 +0530 Subject: Add files via upload --- .../Scalar Functions/gifs/domain_range.gif | Bin 0 -> 19837 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 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/domain_range.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif new file mode 100644 index 0000000..e1ae6a5 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif differ -- cgit From aaf94154db0bcb3d2c6559c1a3f608e851ab3747 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 18:15:40 +0530 Subject: Added gifs to Scalar Function Folder --- .../Scalar Functions/gifs/domain_range.gif | Bin 19837 -> 74879 bytes .../gifs/scalar_function_application.gif | Bin 0 -> 225144 bytes .../gifs/scalar_function_level_curves.gif | Bin 0 -> 245384 bytes .../gifs/scalar_function_level_curves2.gif | Bin 0 -> 893426 bytes .../gifs/scalar_function_neural_nets.gif | Bin 0 -> 95828 bytes .../gifs/scalar_function_parabola_example.gif | Bin 0 -> 905534 bytes 6 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_application.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves2.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_neural_nets.gif create mode 100644 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/gifs/domain_range.gif b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif index e1ae6a5..d0351e5 100644 Binary files a/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/domain_range.gif differ 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 new file mode 100644 index 0000000..831ec8e Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_application.gif differ 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 new file mode 100644 index 0000000..2df2fde Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves.gif differ 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 new file mode 100644 index 0000000..724c27d Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_level_curves2.gif differ 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 new file mode 100644 index 0000000..9d24688 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_neural_nets.gif differ 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 new file mode 100644 index 0000000..3fdecf4 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Scalar Functions/gifs/scalar_function_parabola_example.gif differ -- cgit From c19477e961fe4ccfaf2c4bc3cd4707fbddcddc33 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 18:25:01 +0530 Subject: Added gifs to Multivariable Function Folder --- .../gifs/multivariable_func_derivative_vectorvf.gif | Bin 0 -> 117597 bytes .../gifs/multivariable_func_examples.gif | Bin 0 -> 57945 bytes .../gifs/multivariable_func_plot_sphere.gif | Bin 0 -> 198324 bytes .../gifs/multivariable_func_respresntation.gif | Bin 0 -> 73055 bytes .../gifs/multivariable_func_vectorvf_sine.gif | Bin 0 -> 29814 bytes 5 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_derivative_vectorvf.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_examples.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_plot_sphere.gif create mode 100644 FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_respresntation.gif create mode 100644 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/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 new file mode 100644 index 0000000..a94de90 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_derivative_vectorvf.gif differ 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 new file mode 100644 index 0000000..11f66f1 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_examples.gif differ 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 new file mode 100644 index 0000000..ad7582c Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_plot_sphere.gif differ 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 new file mode 100644 index 0000000..a173bda Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_respresntation.gif differ 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 new file mode 100644 index 0000000..4f6b931 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Multivariable Functions/gifs/multivariable_func_vectorvf_sine.gif differ -- cgit From 4e99a40878f7ba614e0c693ba22de3ae21b1ffd7 Mon Sep 17 00:00:00 2001 From: nishanpoojary Date: Sun, 24 May 2020 18:27:40 +0530 Subject: Added gif to Limits and Continuity Folder --- .../gifs/limit_approach_point.gif | Bin 0 -> 47411 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 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/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 new file mode 100644 index 0000000..830b6f1 Binary files /dev/null and b/FSF-2020/calculus-of-several-variables/multivariable-functions-and-paritial-derivatives/Limits and Continuity of Multivariable Functions/gifs/limit_approach_point.gif differ -- cgit From c36313078049f0f94fca6229b434bffefd323e95 Mon Sep 17 00:00:00 2001 From: Padmapriya Mohan Date: Mon, 25 May 2020 16:33:03 +0530 Subject: Code for subtopic one: Gradient --- .../gradient/file1_missile-example.py | 37 +++++++ .../gradient/file2_gradient-example-1.py | 43 ++++++++ .../gradient/file3_gradient-example-2.py | 39 +++++++ .../gradient/file4-multidimensional-gradient.py | 113 +++++++++++++++++++++ .../gradient/file4_gradient-example-3.py | 40 ++++++++ .../gradient/file5_steepest-ascent-analogy.py | 71 +++++++++++++ .../gradient/file6-maximum.py | 39 +++++++ 7 files changed, 382 insertions(+) create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file1_missile-example.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file2_gradient-example-1.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file3_gradient-example-2.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4-multidimensional-gradient.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file4_gradient-example-3.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file5_steepest-ascent-analogy.py create mode 100644 FSF-2020/calculus-of-several-variables/div-curl-grad-and-all-that/gradient/file6-maximum.py 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) -- cgit From 4e34d62cf2c2ae709756e0f37aeafe680e265a91 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Mon, 25 May 2020 21:58:32 +0530 Subject: Create theorem.py --- .../Critical Points/theorem.py | 55 ++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 FSF-2020/approximations-and-optimizations/Critical Points/theorem.py 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..6889a52 --- /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) -- cgit From a943082849ca96f6b0ffd7f33f919161b8bd828b Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Mon, 25 May 2020 22:27:58 +0530 Subject: Update theorem.py --- .../Critical Points/theorem.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py b/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py index 6889a52..7c82aa9 100644 --- a/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py +++ b/FSF-2020/approximations-and-optimizations/Critical Points/theorem.py @@ -11,8 +11,8 @@ class TheoremAnimation(ThreeDScene): 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) + ]),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( @@ -20,14 +20,14 @@ class TheoremAnimation(ThreeDScene): 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) + ]),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) + 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 + 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) -- cgit From 4319bd86cbce60580c118fd95aacc9ae4430ff5d Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Mon, 25 May 2020 22:30:42 +0530 Subject: Create example.py --- .../Critical Points/example.py | 33 ++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 FSF-2020/approximations-and-optimizations/Critical Points/example.py 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..0ff4c15 --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/example.py @@ -0,0 +1,33 @@ +from manimlib.imports import* + +class ExampleAnimation(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + + #----f(x,y) = (y-x)(1-2x-3y) + e = 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 = 35 * DEGREES, theta = -40* DEGREES) + + 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) + + self.add_fixed_in_frame_mobjects(f_text) + self.wait(2) + self.add(axes) + self.play(Write(e)) + self.wait(2) + self.play(ShowCreation(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) -- cgit From 9ddec26eb2dfbc1b0a9d595d43e36727b7431304 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Mon, 25 May 2020 22:31:32 +0530 Subject: Update example.py --- FSF-2020/approximations-and-optimizations/Critical Points/example.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/example.py b/FSF-2020/approximations-and-optimizations/Critical Points/example.py index 0ff4c15..46c8bd9 100644 --- a/FSF-2020/approximations-and-optimizations/Critical Points/example.py +++ b/FSF-2020/approximations-and-optimizations/Critical Points/example.py @@ -13,7 +13,7 @@ class ExampleAnimation(ThreeDScene): ]),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 = 35 * DEGREES, theta = -40* DEGREES) + self.set_camera_orientation(phi = 35 * DEGREES, theta = -40 * DEGREES) 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 -- cgit From 7f48f12dccac8b709a4e5cf77267d189d828e816 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Mon, 25 May 2020 23:25:16 +0530 Subject: Create types_of_cp.py --- .../Critical Points/types_of_cp.py | 69 ++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py 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..49f083f --- /dev/null +++ b/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py @@ -0,0 +1,69 @@ +from manimlib.imports import * + +class TypescpAnimation(ThreeDScene): + def construct(self): + axes = ThreeDAxes() + + r_text = TextMobject("Relative Maxima 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 Minima 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 ) + + self.add_fixed_in_frame_mobjects(r_text) + self.wait(1) + self.play(FadeOut(r_text)) + self.add(axes) + self.play(Write(f)) + self.add_fixed_in_frame_mobjects(f_text) + self.wait(2) + self.play(FadeOut(axes),FadeOut(f),FadeOut(f_text)) + + self.add_fixed_in_frame_mobjects(r2_text) + self.wait(1) + self.play(FadeOut(r2_text)) + self.add(axes) + self.play(Write(f2)) + self.add_fixed_in_frame_mobjects(f2_text) + self.wait(2) + self.play(FadeOut(axes),FadeOut(f2),FadeOut(f2_text)) + + self.add_fixed_in_frame_mobjects(r3_text) + self.wait(1) + self.play(FadeOut(r3_text)) + self.add(axes) + self.play(Write(f3)) + self.add_fixed_in_frame_mobjects(f3_text) + self.wait(2) -- cgit From 4e48a333ce9387cbd951e1ef108b9dc0281874da Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Tue, 26 May 2020 03:08:42 +0530 Subject: Update types_of_cp.py --- .../Critical Points/types_of_cp.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) 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 index 49f083f..f9055e6 100644 --- a/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py +++ b/FSF-2020/approximations-and-optimizations/Critical Points/types_of_cp.py @@ -4,7 +4,7 @@ class TypescpAnimation(ThreeDScene): def construct(self): axes = ThreeDAxes() - r_text = TextMobject("Relative Maxima at ORIGIN",color ='#87CEFA') + 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 @@ -28,7 +28,7 @@ class TypescpAnimation(ThreeDScene): ]),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 Minima at ORIGIN",color ='#87CEFA') + 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 @@ -41,29 +41,30 @@ class TypescpAnimation(ThreeDScene): 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)) + 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)) + 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)) + 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)) + 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)) + self.play(Write(f3),Write(d)) self.add_fixed_in_frame_mobjects(f3_text) self.wait(2) -- cgit From 42c96d26831f9b99a3f01e52e6a51b3cdce4ceb5 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Tue, 26 May 2020 03:10:09 +0530 Subject: Update example.py --- .../Critical Points/example.py | 62 +++++++++++++++++----- 1 file changed, 49 insertions(+), 13 deletions(-) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/example.py b/FSF-2020/approximations-and-optimizations/Critical Points/example.py index 46c8bd9..bdbb6ed 100644 --- a/FSF-2020/approximations-and-optimizations/Critical Points/example.py +++ b/FSF-2020/approximations-and-optimizations/Critical Points/example.py @@ -4,30 +4,66 @@ 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) - e = ParametricSurface( + 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 = 35 * DEGREES, theta = -40 * DEGREES) + resolution=(20, 20)).scale(1) - 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) + fx_text = TextMobject("$\\frac{\\partial f}{\\partial x} = 4x-1+y$").to_corner(UL) + + #----fx = 4x-1+y + fx = ParametricSurface( + lambda u, v: np.array([ + u, + v, + 4*u-1+v + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [BLUE_D, BLUE_E], + resolution = (20, 20)).scale(1) + + fy_text = TextMobject("$\\frac{\\partial f}{\\partial y} = -6y+1+x$").to_corner(UL) + + #----fy = -6y+1+x + fy = ParametricSurface( + lambda u, v: np.array([ + u, + v, + -6*v+1+u + ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [RED_D, RED_E], + resolution = (20, 20)).scale(1) + + self.set_camera_orientation(phi = 75 * DEGREES) + self.begin_ambient_camera_rotation(rate=0.2) + + group1 = VGroup(axes,f,d,d_text,r_text,f_text) + group2 = VGroup(axes,fx,fx_text) self.add_fixed_in_frame_mobjects(f_text) - self.wait(2) + self.wait(1) self.add(axes) - self.play(Write(e)) - self.wait(2) - self.play(ShowCreation(d)) + 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) + self.wait(2) + self.play(FadeOut(group1)) + self.wait(1) + self.add_fixed_in_frame_mobjects(fx_text) + self.add(axes) + self.play(Write(fx)) + self.wait(2) + self.play(FadeOut(group2)) + self.wait(1) + self.add_fixed_in_frame_mobjects(fy_text) + self.add(axes) + self.play(Write(fy)) + self.wait(2) -- cgit From c09da0b478863bfcfa05ce0a687717cbbc3445aa Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Tue, 26 May 2020 03:23:18 +0530 Subject: Update example.py --- .../Critical Points/example.py | 41 ++-------------------- 1 file changed, 2 insertions(+), 39 deletions(-) diff --git a/FSF-2020/approximations-and-optimizations/Critical Points/example.py b/FSF-2020/approximations-and-optimizations/Critical Points/example.py index bdbb6ed..3a41be7 100644 --- a/FSF-2020/approximations-and-optimizations/Critical Points/example.py +++ b/FSF-2020/approximations-and-optimizations/Critical Points/example.py @@ -18,33 +18,8 @@ class ExampleAnimation(ThreeDScene): ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [PURPLE_D, PURPLE_E], resolution=(20, 20)).scale(1) - fx_text = TextMobject("$\\frac{\\partial f}{\\partial x} = 4x-1+y$").to_corner(UL) - - #----fx = 4x-1+y - fx = ParametricSurface( - lambda u, v: np.array([ - u, - v, - 4*u-1+v - ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [BLUE_D, BLUE_E], - resolution = (20, 20)).scale(1) - - fy_text = TextMobject("$\\frac{\\partial f}{\\partial y} = -6y+1+x$").to_corner(UL) - - #----fy = -6y+1+x - fy = ParametricSurface( - lambda u, v: np.array([ - u, - v, - -6*v+1+u - ]),v_min = -1, v_max = 1, u_min = -1, u_max = 1, checkerboard_colors = [RED_D, RED_E], - resolution = (20, 20)).scale(1) - self.set_camera_orientation(phi = 75 * DEGREES) - self.begin_ambient_camera_rotation(rate=0.2) - - group1 = VGroup(axes,f,d,d_text,r_text,f_text) - group2 = VGroup(axes,fx,fx_text) + self.begin_ambient_camera_rotation(rate=0.5) self.add_fixed_in_frame_mobjects(f_text) self.wait(1) @@ -54,16 +29,4 @@ class ExampleAnimation(ThreeDScene): self.add_fixed_in_frame_mobjects(d_text) self.wait(1) self.add_fixed_in_frame_mobjects(r_text) - self.wait(2) - self.play(FadeOut(group1)) - self.wait(1) - self.add_fixed_in_frame_mobjects(fx_text) - self.add(axes) - self.play(Write(fx)) - self.wait(2) - self.play(FadeOut(group2)) - self.wait(1) - self.add_fixed_in_frame_mobjects(fy_text) - self.add(axes) - self.play(Write(fy)) - self.wait(2) + self.wait(3) -- cgit From 36e188e464bc8a3604702dee24be038be6785bb3 Mon Sep 17 00:00:00 2001 From: Vaishnavi Date: Tue, 26 May 2020 10:32:47 +0530 Subject: Create motivation.py --- .../Critical Points/motivation.py | 30 ++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 FSF-2020/approximations-and-optimizations/Critical Points/motivation.py 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)) -- cgit