summaryrefslogtreecommitdiff
path: root/FSF-2020/linear-algebra
diff options
context:
space:
mode:
Diffstat (limited to 'FSF-2020/linear-algebra')
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file.txt3
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file1_transformations.py45
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file2_Understand_Linear_Transformations_visually.py193
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file3_Uniform_Scaling.py91
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_Horizontal_Shear.py53
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_Horizontal_Shear_gif.gifbin0 -> 1566999 bytes
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear.py52
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear_gif.gifbin0 -> 1347079 bytes
-rwxr-xr-xFSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file6_linear_transformation.py27
-rwxr-xr-xFSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file1_orthogonal.py34
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file2_OrthonormalBasis.py82
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/README.md9
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.gifbin0 -> 1182328 bytes
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.py30
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file2_Row_Space.py145
-rw-r--r--FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file.txt3
-rwxr-xr-xFSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file1_RN_Theorem.py97
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/README.md9
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Straight_Line_through_Origin.py48
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Subspace_Example.py82
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Unit_Circle.py68
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Straight_Line_Through_Origin.gifbin0 -> 314823 bytes
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Subspace_Example.gifbin0 -> 647405 bytes
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Unit_Circle.gifbin0 -> 149852 bytes
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/3D_Vector_Space.py14
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Addition_and_Scaling.py137
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Space_As_Functions.py62
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/3D_Vector_Space.gifbin0 -> 1976679 bytes
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Function_Vector_Space_Example.gifbin0 -> 634786 bytes
-rw-r--r--FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Vector_Addition_and_Scalar_Multiplication.gifbin0 -> 4954730 bytes
30 files changed, 1284 insertions, 0 deletions
diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file.txt b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file.txt
new file mode 100644
index 0000000..cae98ce
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file.txt
@@ -0,0 +1,3 @@
+file 'text.mp4'
+file 'LinearTransformation.mp4'
+file 'NonLinearTransformation.mp4'
diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file1_transformations.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file1_transformations.py
new file mode 100644
index 0000000..677f890
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file1_transformations.py
@@ -0,0 +1,45 @@
+from manimlib.imports import *
+
+class text(Scene):
+ def construct(self):
+ text1 = TextMobject("For a grid, undergoing a linear transformation, all it's straight lines")
+ text1.scale(0.9)
+ text2 = TextMobject("must either remain straight lines or sends to a point in the grid formed")
+ text2.scale(0.9)
+ text1.move_to(ORIGIN+UP)
+ text2.move_to(ORIGIN)
+ self.play(Write(text1))
+ self.play(Write(text2))
+ self.wait()
+ self.play(FadeOut(text1),FadeOut(text2))
+
+class LinearTransformation(LinearTransformationScene):
+ CONFIG = {
+ "basis_vector_stroke_width": 3,
+ "leave_ghost_vectors": True,
+ }
+
+ def construct(self):
+ self.setup()
+ matrix = [[0.866,-0.5],[0.5,0.866]]
+ self.apply_matrix(matrix)
+ text = TextMobject("This is a Linear","Trasformation")
+ text[0].move_to(DOWN+4*LEFT)
+ text[1].move_to(1.5*DOWN+4*LEFT)
+ text.add_background_rectangle()
+ self.play(Write(text))
+ self.wait()
+
+class NonLinearTransformation(Scene):
+ def construct(self):
+ grid = NumberPlane()
+ self.play(ShowCreation(grid),run_time =2)
+ NonLinearTrans = lambda coordinates : coordinates + np.array([np.sin(coordinates[1]),np.sin(coordinates[0]),0,])
+ grid.prepare_for_nonlinear_transform()
+ self.play(grid.apply_function,NonLinearTrans)
+ text = TextMobject("While, this is not a","Linear Trasformation")
+ text[0].move_to(DOWN+4*LEFT)
+ text[1].move_to(1.5*DOWN+4*LEFT)
+ text.add_background_rectangle()
+ self.play(Write(text))
+ self.wait() \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file2_Understand_Linear_Transformations_visually.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file2_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)/file2_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)/file3_Uniform_Scaling.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file3_Uniform_Scaling.py
new file mode 100644
index 0000000..a7856a5
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file3_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)/file4_Horizontal_Shear.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_Horizontal_Shear.py
new file mode 100644
index 0000000..91f098e
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_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)/file4_Horizontal_Shear_gif.gif b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_Horizontal_Shear_gif.gif
new file mode 100644
index 0000000..9bef1b6
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file4_Horizontal_Shear_gif.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear.py
new file mode 100644
index 0000000..718e4e0
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_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)/file5_Vertical_Shear_gif.gif b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear_gif.gif
new file mode 100644
index 0000000..7ca323f
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file5_Vertical_Shear_gif.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file6_linear_transformation.py b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file6_linear_transformation.py
new file mode 100755
index 0000000..01a0cef
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Linear-Transformations-(Linear-Maps)/file6_linear_transformation.py
@@ -0,0 +1,27 @@
+from manimlib.imports import *
+class LinearTrans(LinearTransformationScene,MovingCameraScene):
+ CONFIG = {
+ "basis_vector_stroke_width": 1,
+ "leave_ghost_vectors": True,
+ }
+
+ def setup(self):
+ LinearTransformationScene.setup(self)
+ MovingCameraScene.setup(self)
+
+ def construct(self):
+ self.setup()
+ self.camera_frame.save_state()
+ self.play(self.camera_frame.set_width, 7)
+ matrix = [[0.866,-0.5],[0.5,0.866]]
+ self.apply_matrix(matrix)
+ arc1 = Arc(radius = 0.25,angle=TAU/12)
+ arc2 = Arc(radius = 0.25,angle=TAU/12,start_angle=TAU/4)
+ text1 = TextMobject(r"$\theta$")
+ text1.scale(0.5)
+ text1.move_to(0.5*UP+0.125*LEFT)
+ text2 = TextMobject(r"$\theta$")
+ text2.scale(0.5)
+ text2.move_to(0.5*RIGHT+0.125*UP)
+ self.play(ShowCreation(arc1),ShowCreation(arc2),Write(text1),Write(text2),run_time=1)
+ self.wait()
diff --git a/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file1_orthogonal.py b/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file1_orthogonal.py
new file mode 100755
index 0000000..b400f93
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file1_orthogonal.py
@@ -0,0 +1,34 @@
+from manimlib.imports import *
+
+class Orthogonal(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ self.play(ShowCreation(axes))
+ self.move_camera(phi=30*DEGREES,theta=-45*DEGREES,run_time=3)
+ line1 = Line(start = ORIGIN,end = -3*LEFT)
+ line1.set_color(DARK_BLUE)
+ tip1 = Polygon(-LEFT,-0.8*LEFT-0.2*DOWN,-0.8*LEFT-0.2*UP)
+ tip1.move_to(-3*LEFT)
+ tip1.set_opacity(1)
+ tip1.set_fill(DARK_BLUE)
+ tip1.set_color(DARK_BLUE)
+
+ arrow2 = Line(start = ORIGIN,end = -3*UP)
+ arrow2.set_color(DARK_BLUE)
+ tip2 = Polygon(DOWN,0.8*DOWN-0.2*RIGHT,0.8*DOWN-0.2*LEFT)
+ tip2.move_to(3*DOWN)
+ tip2.set_opacity(1)
+ tip2.set_fill(DARK_BLUE)
+ tip2.set_color(DARK_BLUE)
+ arrow2.set_color(DARK_BLUE)
+
+ arrow3 = Line(start = ORIGIN,end = [0,0,3])
+ arrow3.set_color(DARK_BLUE)
+ tip3 = Polygon([0,0,3],[0,0,2.8]-0.2*RIGHT,[0,0,2.8]-0.2*LEFT)
+ tip3.set_opacity(1)
+ tip3.set_fill(DARK_BLUE)
+ tip3.set_color(DARK_BLUE)
+
+ self.play(ShowCreation(line1), ShowCreation(tip1), ShowCreation(arrow2), ShowCreation(tip2), ShowCreation(arrow3), ShowCreation(tip3))
+
+ self.wait() \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file2_OrthonormalBasis.py b/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file2_OrthonormalBasis.py
new file mode 100644
index 0000000..0a28f22
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/Orthonormal Basis/file2_OrthonormalBasis.py
@@ -0,0 +1,82 @@
+from manimlib.imports import *
+class OrthonormalBasis(GraphScene):
+ CONFIG = {
+ "x_min" : -6,
+ "x_max" : 6,
+ "y_min" : -4,
+ "y_max" : 4,
+ "graph_origin" : ORIGIN ,
+}
+
+ def construct(self):
+ self.setup_axes(animate=True)
+
+ XTD = self.x_axis_width/(self.x_max-self.x_min)
+ YTD = self.y_axis_height/(self.y_max-self.y_min)
+
+ arrow1 = Arrow(start = ORIGIN,end = 0.707*YTD*UP+0.707*XTD*RIGHT)
+ arrow1.scale(2.25)
+ arrow1.set_color(DARK_BLUE)
+
+ arrow2 = Arrow(start = ORIGIN,end = 0.707*YTD*UP+0.707*XTD*LEFT)
+ arrow2.scale(2.25)
+ arrow2.set_color(DARK_BLUE)
+
+ square = Polygon(UP*0.4*YTD,0.2*(YTD*UP+XTD*RIGHT),ORIGIN,0.2*(YTD*UP+XTD*LEFT))
+ square.set_color(DARK_BLUE)
+ self.play(ShowCreation(arrow2), ShowCreation(arrow1), ShowCreation(square))
+
+ ortho = TextMobject("Orthonormal Vectors")
+ ortho.scale(0.75)
+ ortho.move_to(DOWN+3*RIGHT)
+ self.play(Write(ortho))
+ self.wait()
+ self.play(FadeOut(ortho))
+
+ arrow3 = Arrow(start = ORIGIN,end = YTD*3*UP+XTD*LEFT)
+ arrow3.scale(1.25)
+ arrow3.set_color(GOLD_E)
+ self.play(ShowCreation(arrow3))
+
+ arrow4 = Arrow(start = ORIGIN,end = YTD*UP+XTD*RIGHT)
+ arrow4.scale(1.8)
+ arrow4.set_color(GOLD_A)
+
+ arrow5 = Arrow(start = ORIGIN,end = 2*YTD*UP-2*XTD*RIGHT)
+ arrow5.scale(1.3)
+ arrow5.set_color(GOLD_A)
+
+ self.play(ShowCreation(arrow5), ShowCreation(arrow4))
+
+ self.wait()
+
+ self.play(FadeOut(arrow1), FadeOut(arrow2), FadeOut(square))
+
+ self.wait()
+
+ text1 = TextMobject(r"$<v,v_1> v_1$")
+ text1.move_to(UP+2*RIGHT)
+ text1.scale(0.75)
+ text2 = TextMobject(r"$<v,v_2> v_2$")
+ text2.move_to(UP+3*LEFT)
+ text2.scale(0.75)
+
+ text3 = TextMobject("v")
+ text3.move_to(YTD*3.5*UP+XTD*1.5*LEFT)
+
+ self.play(Write(text1), Write(text2), Write(text3))
+ self.wait()
+
+ line1 = DashedLine(start = YTD*UP+XTD*RIGHT, end = YTD*3*UP+XTD*1*LEFT)
+ line2 = DashedLine(start = YTD*2*UP+XTD*2*LEFT, end = YTD*3*UP+XTD*1*LEFT)
+ self.play(ShowCreation(line1),ShowCreation(line2))
+
+ self.wait()
+
+ text = TextMobject(r"$v$ is the sum of projections","on the orthonormal vectors")
+ text[0].move_to(DOWN+3.2*RIGHT)
+ text[1].move_to(1.5*DOWN+3.2*RIGHT)
+ self.play(Write(text))
+ self.wait(2)
+ self.play(FadeOut(arrow3), FadeOut(arrow4), FadeOut(arrow5), FadeOut(text1), FadeOut(text2), FadeOut(text3), FadeOut(self.axes), FadeOut(line1), FadeOut(line2))
+ self.play(FadeOut(text))
diff --git a/FSF-2020/linear-algebra/linear-transformations/README.md b/FSF-2020/linear-algebra/linear-transformations/README.md
new file mode 100644
index 0000000..692201e
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/README.md
@@ -0,0 +1,9 @@
+# Contributer: Archit Sangal
+My Github Account : <a href="https://github.com/architsangal">architsangal</a>
+<br/></br>
+## Sub-Topics Covered:
++ Vector Space Homomorphisms (Linear Maps)
++ The Four Fundamental Subspaces
++ Rank-Nullity Theorem
++ Orthonormal basis
++ Gramm-Schmidt Orthogonalization Process
diff --git a/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.gif b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.gif
new file mode 100644
index 0000000..7d8d2e1
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.py b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.py
new file mode 100644
index 0000000..afe4f9a
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file1_Column_Space.py
@@ -0,0 +1,30 @@
+from manimlib.imports import *
+
+class Column_Space(Scene):
+ def construct(self):
+
+ A = TextMobject(r"$A = $",r"$\left( \begin{array}{c c c} 1 & 2 & 1 \\ 1 & 3 & 1 \\ 2 & 1 & 4 \\ 3 & 2 & 3 \end{array} \right)$")
+ A.move_to(2*UP)
+ A[1].set_color(color = DARK_BLUE)
+ A.scale(0.75)
+
+ self.play(Write(A),run_time = 1)
+
+ CS_A = TextMobject(r"Column Space of $A = x_{1}$",r"$\left( \begin{array}{c} 1 \\ 1 \\ 2 \\ 3 \end{array} \right)$",r"$+x_{2}$",r"$ \left( \begin{array}{c} 2 \\ 3 \\ 1 \\ 2 \end{array} \right)$",r"$ + x_{3}$",r"$\left( \begin{array}{c} 1 \\ 1 \\ 4 \\ 3 \end{array} \right)$")
+ CS_A.move_to(1.5*LEFT+1*DOWN)
+ CS_A[1].set_color(color = DARK_BLUE)
+ CS_A[3].set_color(color = DARK_BLUE)
+ CS_A[5].set_color(color = DARK_BLUE)
+ CS_A.scale(0.75)
+
+ self.play(Write(CS_A),run_time = 2)
+
+ arrow1 = Arrow(start = 1.25*UP,end = 0.25*DOWN+1.75*LEFT)
+ arrow2 = Arrow(start = 1.35*UP+0.5*RIGHT,end = 0.25*DOWN+0.5*RIGHT)
+ arrow3 = Arrow(start = 1.25*UP+0.75*RIGHT,end = 0.25*DOWN+2.9*RIGHT)
+
+ Defn = TextMobject("Linear Combination of Columns of Matrix")
+ Defn.move_to(3*DOWN)
+
+ self.play(Write(Defn), ShowCreation(arrow1), ShowCreation(arrow2), ShowCreation(arrow3),run_time = 1)
+ self.wait(1) \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file2_Row_Space.py b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file2_Row_Space.py
new file mode 100644
index 0000000..b16a32a
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/The-Four-Fundamental-Subspaces/file2_Row_Space.py
@@ -0,0 +1,145 @@
+from manimlib.imports import *
+
+class Row_Space(Scene):
+ def construct(self):
+
+ Heading = TextMobject("Row Space")
+ defn1 = TextMobject("Definition 1: Row Space of a matrix is the linear combination of the rows of that matrix.")
+ defn2 = TextMobject("Definition 2: It is a vector space generated by a linear combination of the columns of $A^{T}$.")
+ equivalent = TextMobject(r"Definition 1 $\equiv$ Definition 2")
+
+ Heading.move_to(2*UP)
+ Heading.set_color(color = DARK_BLUE)
+
+ defn1.move_to(UP)
+ defn1.scale(0.75)
+
+ defn2.scale(0.75)
+
+ equivalent.move_to(DOWN)
+
+ self.play(Write(Heading))
+ self.play(Write(defn1))
+ self.play(Write(defn2))
+ self.play(Write(equivalent))
+
+ self.wait(2)
+ self.play(FadeOut(Heading),FadeOut(defn1),FadeOut(defn2),ApplyMethod(equivalent.move_to,2*UP))
+
+ how = TextMobject("Let us see, How?")
+ how.move_to(UP)
+ self.play(Write(how))
+ self.play(FadeOut(equivalent),FadeOut(how))
+
+ A = TextMobject(r"$A = $",r"$\left( \begin{array}{c c c} 1 & 2 & 1 \\ 1 & 3 & 1 \\ 2 & 1 & 4 \\ 3 & 2 & 3 \end{array} \right)$")
+ A.move_to(2*UP+3*LEFT)
+ A[1].set_color(color = DARK_BLUE)
+ A.scale(0.80)
+
+ self.play(Write(A))
+
+ rows = TextMobject(r"Rows of A $\rightarrow$",
+ r"$\left( \begin{array}{c c c} 1 & 2 & 1 \end{array} \right)$,",
+ r"$ \left( \begin{array}{c c c} 1 & 3 & 1 \end{array} \right)$,",
+ r"$\left( \begin{array}{c c c} 2 & 1 & 4 \end{array} \right)$,",
+ r"$ \left( \begin{array}{c c c} 3 & 2 & 3 \end{array} \right)$")
+ rows.scale(0.75)
+ rows[1:5].set_color(DARK_BLUE)
+ self.play(Write(rows))
+
+ ac_defn1 = TextMobject("According to Definition 1 : ")
+ ac_defn1.move_to(DOWN)
+
+ RS_A = TextMobject(r"Row Space of $A = x_{1}$",
+ r"$\left( \begin{array}{c c c} 1 & 2 & 1 \end{array} \right)$",
+ r"$+x_{2}$",
+ r"$ \left( \begin{array}{c c c} 1 & 3 & 1 \end{array} \right)$",
+ r"$ + x_{3}$",
+ r"$\left( \begin{array}{c c c} 2 & 1 & 4 \end{array} \right)$",
+ r"$+x_{4}$",
+ r"$ \left( \begin{array}{c c c} 3 & 2 & 3 \end{array} \right)$")
+ RS_A.move_to(DOWN+DOWN)
+ RS_A[6].move_to(2*DOWN+DOWN)
+ RS_A[7].move_to(2*DOWN+2*RIGHT+DOWN)
+ RS_A[1].set_color(color = DARK_BLUE)
+ RS_A[3].set_color(color = DARK_BLUE)
+ RS_A[5].set_color(color = DARK_BLUE)
+ RS_A[7].set_color(color = DARK_BLUE)
+ RS_A.scale(0.75)
+
+ self.play(FadeOut(rows[0]),Transform(rows[1],RS_A[1]),Transform(rows[2],RS_A[3]),Transform(rows[3],RS_A[5]),Transform(rows[4],RS_A[7]))
+ self.play(FadeIn(ac_defn1), Write(RS_A))
+ self.wait(1)
+
+ self.play(FadeOut(rows[1]), FadeOut(rows[2]), FadeOut(rows[3]), FadeOut(rows[4]), FadeOut(RS_A), FadeOut(ac_defn1))
+
+ A_T = TextMobject(r"$A^{T} = $",r"$\left( \begin{array}{c c c c} 1 & 1 & 2 & 3 \\ 2 & 3 & 1 & 2 \\ 1 & 1 & 4 & 3 \end{array} \right)$")
+ A_T.move_to(2*UP+3*RIGHT)
+ A_T[1].set_color(color = DARK_BLUE)
+ A_T.scale(0.80)
+
+ self.play(Write(A_T))
+
+ change1 = TextMobject(r"Rows of $A\equiv$ Columns of $A^{T}$")
+ change2 = TextMobject(r"Columns of $A\equiv$ Rows of $A^{T}$")
+ change2.move_to(DOWN)
+
+ change3 = TextMobject(r"Row Space of $A$ = Linear Combination of",r"Rows","of",r"A")
+ change3.move_to(2*DOWN)
+ change3[1].set_color(DARK_BLUE)
+ change3[3].set_color(DARK_BLUE)
+
+ self.play(Write(change1))
+ self.play(Write(change2))
+ self.play(Write(change3))
+
+ columns = TextMobject("Columns")
+ columns.scale(0.6)
+ columns.set_color(DARK_BLUE)
+ columns.move_to(2*DOWN+4.1*RIGHT)
+
+ a = TextMobject(r"$A^{T}$")
+ a.set_color(DARK_BLUE)
+ a.move_to(1.95*DOWN+5.6*RIGHT)
+
+ self.wait(0.5)
+
+ self.play(Transform(change3[1],columns), Transform(change3[3],a))
+
+ equal = TextMobject(r"= Column Space($A^{T}$)")
+ equal.move_to(3*DOWN+0.5*RIGHT)
+
+ self.play(Write(equal))
+
+ self.play(FadeOut(A_T), FadeOut(change1), FadeOut(change2), FadeOut(change3), FadeOut(A), FadeOut(equal))
+
+ ac_defn1.move_to(3*UP)
+ RS_A.move_to(1.5*UP)
+ RS_A[6].move_to(UP)
+ RS_A[7].move_to(UP+1.5*RIGHT)
+
+ self.play(Write(RS_A),FadeIn(ac_defn1))
+
+ CS_AT = TextMobject(r"Row Space of $A = x_{1}$",
+ r"$\left( \begin{array}{c} 1 \\ 2 \\ 1 \end{array} \right)$",
+ r"$+x_{2}$",
+ r"$ \left( \begin{array}{c} 1 \\ 3 \\ 1 \end{array} \right)$",
+ r"$ + x_{3}$",
+ r"$\left( \begin{array}{c} 2 \\ 1 \\ 4 \end{array} \right)$",
+ r"$+x_{4}$",
+ r"$ \left( \begin{array}{c} 3 \\ 2 \\ 3 \end{array} \right)$")
+ CS_AT.move_to(1.5*DOWN)
+ CS_AT[1].set_color(color = DARK_BLUE)
+ CS_AT[3].set_color(color = DARK_BLUE)
+ CS_AT[5].set_color(color = DARK_BLUE)
+ CS_AT[7].set_color(color = DARK_BLUE)
+ CS_AT.scale(0.75)
+
+ ac_defn2 = TextMobject("According to Definition 2 : ")
+ equivalent = TextMobject(r"Hence, Definition 1 $\equiv$ Definition 2")
+ equivalent.move_to(3*DOWN)
+
+ self.play(Write(CS_AT),FadeIn(ac_defn2))
+ self.play(Write(equivalent))
+
+ self.wait()
diff --git a/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file.txt b/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file.txt
new file mode 100644
index 0000000..5c48a13
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file.txt
@@ -0,0 +1,3 @@
+file 'RN_Line.mp4'
+file 'RN_Point.mp4'
+file 'RN_SameDim.mp4'
diff --git a/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file1_RN_Theorem.py b/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file1_RN_Theorem.py
new file mode 100755
index 0000000..e54276c
--- /dev/null
+++ b/FSF-2020/linear-algebra/linear-transformations/The-Rank-Nullity-Theorem/file1_RN_Theorem.py
@@ -0,0 +1,97 @@
+from manimlib.imports import *
+class RN_Line(LinearTransformationScene):
+ def construct(self):
+
+ self.setup()
+ self.wait()
+
+ predim = TextMobject("Dimension of this vector space is 2")
+ predim.move_to(DOWN+4*LEFT)
+ predim.scale(0.75)
+ predim.add_background_rectangle()
+ self.play(Write(predim))
+ self.wait()
+ self.play(FadeOut(predim))
+
+ afterlt = TextMobject("After Linear transformation")
+ afterlt.move_to(DOWN+4*LEFT)
+ afterlt.scale(0.75)
+ afterlt.add_background_rectangle()
+
+ afterlt2 = TextMobject("Dimension of the vector space","changes to 1")
+ afterlt2[0].move_to(1.5*DOWN+4*LEFT)
+ afterlt2[1].move_to(2*DOWN+4*LEFT)
+ afterlt2.scale(0.75)
+ afterlt2.add_background_rectangle()
+ matrix = [[1,1],[1,1]]
+ self.apply_matrix(matrix)
+ self.play(Write(afterlt))
+ self.play(Write(afterlt2))
+ self.wait()
+ nullity = TextMobject("Hence, nullity = 1")
+ nullity.move_to(DOWN+4*LEFT)
+ self.play(FadeOut(afterlt),FadeOut(afterlt2),Write(nullity))
+ self.wait(1)
+ self.play(FadeOut(nullity))
+
+class RN_Point(LinearTransformationScene):
+ def construct(self):
+ self.setup()
+ self.wait()
+ predim = TextMobject("Another One")
+ predim.move_to(DOWN+4*LEFT)
+ predim.scale(0.75)
+ predim.add_background_rectangle()
+ self.play(Write(predim))
+ self.wait()
+ self.play(FadeOut(predim))
+ afterlt = TextMobject("After Linear transformation")
+ afterlt.move_to(DOWN+4*LEFT)
+ afterlt.scale(0.75)
+ afterlt.add_background_rectangle()
+ afterlt2 = TextMobject("Dimension of the vector space","changes to 0")
+ afterlt2[0].move_to(1.5*DOWN+4*LEFT)
+ afterlt2[1].move_to(2*DOWN+4*LEFT)
+ afterlt2.scale(0.75)
+ afterlt2.add_background_rectangle()
+ matrix = [[0,0],[0,0]]
+ self.apply_matrix(matrix)
+ self.play(Write(afterlt))
+ self.play(Write(afterlt2))
+ self.wait()
+ nullity = TextMobject("Hence, nullity = 2")
+ nullity.move_to(DOWN+4*LEFT)
+ self.play(FadeOut(afterlt),FadeOut(afterlt2),Write(nullity))
+ self.wait(1)
+ self.play(FadeOut(nullity))
+
+class RN_SameDim(LinearTransformationScene):
+ def construct(self):
+ self.setup()
+ self.wait()
+ predim = TextMobject("Let us look at another example")
+ predim.add_background_rectangle()
+ predim.move_to(DOWN+4*LEFT)
+ predim.scale(0.75)
+ self.play(Write(predim))
+ self.wait()
+ self.play(FadeOut(predim))
+ afterlt = TextMobject("After Linear transformation")
+ afterlt.move_to(DOWN+4*LEFT)
+ afterlt.scale(0.75)
+ afterlt.add_background_rectangle()
+ afterlt2 = TextMobject("Dimension of the vector space","remains to be 2")
+ afterlt2[0].move_to(1.5*DOWN+4*LEFT)
+ afterlt2[1].move_to(2*DOWN+4*LEFT)
+ afterlt2.scale(0.75)
+ afterlt2.add_background_rectangle()
+ matrix = [[1,1],[0,1]]
+ self.apply_matrix(matrix)
+ self.play(Write(afterlt))
+ self.play(Write(afterlt2))
+ self.wait()
+ nullity = TextMobject("Hence, nullity = 0")
+ nullity.move_to(DOWN+4*LEFT)
+ self.play(FadeOut(afterlt),FadeOut(afterlt2),Write(nullity))
+ self.wait(1)
+ self.play(FadeOut(nullity)) \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/vector-spaces/README.md b/FSF-2020/linear-algebra/vector-spaces/README.md
new file mode 100644
index 0000000..03f6a03
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/README.md
@@ -0,0 +1,9 @@
+# Contributer: Simran Chhattani
+My Github Account : <a href="https://github.com/simranchhattani">simranchhattani</a>
+<br/></br>
+## Sub-Topics Covered:
++ Vector Spaces
++ Basis of a Vector Space and Subspace
++ Polynomial and Function Vector Space
++ Inner Product Spaces
++ Dual of a Vector Space
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Straight_Line_through_Origin.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Straight_Line_through_Origin.py
new file mode 100644
index 0000000..5790d2e
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Straight_Line_through_Origin.py
@@ -0,0 +1,48 @@
+from manimlib.imports import *
+from scipy import exp, sin, log,tan,cos
+class Straight_Line(GraphScene):
+ CONFIG = {
+ "x_min" : -4,
+ "x_max" : 4,
+ "y_min" : -4,
+ "y_max" : 4,
+ "y_tick_frequency" : 1,
+ "x_tick_frequency" : 1,
+ "x_labeled_nums" : list(np.arange(-4,5,1)),
+ "y_labeled_nums" : list(np.arange(-4,5,1)),
+ "graph_origin" : ORIGIN+0.7*DOWN,
+ "axes_color" : GREY,
+ "x_axis_width": 6,
+ "y_axis_height":6,
+ }
+ def construct(self):
+ self.setup_axes(animate=True)
+ line_1 = self.get_graph(lambda x : x, x_min=-3,x_max=3,color=YELLOW)
+ self.play(ShowCreation(line_1))
+ text1 = TextMobject("ax + by = 0",color=BLUE_B)
+ text1.shift(3*RIGHT+2*UP)
+ text1.scale(0.65)
+ dot = Dot(color=BLUE_B).shift(0.7*DOWN)
+ dot.scale(1.3)
+ self.play(ShowCreation(dot))
+ text2 = TextMobject("Line passing through the origin")
+ text2.scale(0.7)
+ text2.shift(3.5*UP)
+ self.play(ShowCreation(text1),ShowCreation(text2))
+ self.wait(1)
+ self.play(FadeOut(line_1),FadeOut(text2),FadeOut(text1))
+ text4=TextMobject("Line not passing through the origin")
+ text4.scale(0.7)
+ text4.shift(3.5*UP)
+ self.play(ShowCreation(text4))
+
+ line_2 = self.get_graph(lambda x : 2.5*x +1, x_min = -2, x_max=1, color = RED)
+ text3 = TextMobject(r"ax + by $\neq 0$",color=BLUE_B)
+ text3.scale(0.65)
+ self.play(ShowCreation(line_2))
+ text3.shift(1.5*RIGHT+2.2*UP)
+ self.play(ShowCreation(text3))
+ self.wait(1)
+
+
+ \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Subspace_Example.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Subspace_Example.py
new file mode 100644
index 0000000..ada173e
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Subspace_Example.py
@@ -0,0 +1,82 @@
+from manimlib.imports import *
+class Subspace_Example(Scene):
+ def construct(self):
+ sq = Square(side = 2, color=BLACK).shift(2*LEFT)
+ sq.set_fill(color=RED,opacity=350)
+ line1=Line(color=BLACK).shift(2*LEFT)
+ line1.rotate(np.pi/2)
+ line2=Line(color=BLACK).shift(2.5*LEFT+0.5*UP)
+ line2.scale(0.5)
+ line3=Line(color=BLACK).shift(+1.5*LEFT)
+ line3.scale(0.5)
+ a1=TextMobject(r"$a_1$",color=BLACK).scale(0.5).shift(3.4*LEFT+0.7*UP)
+ a2=TextMobject(r"$a_2$",color=BLACK).scale(0.5).shift(3.4*LEFT+0.3*DOWN)
+ a3=TextMobject(r"$a_3$",color=BLACK).scale(0.5).shift(0.7*LEFT+0.5*DOWN)
+ a4=TextMobject(r"$a_4$",color=BLACK).scale(0.5).shift(0.7*LEFT+0.5*UP)
+ big_rect=Rectangle().scale(3).shift(0.5*DOWN)
+ big_rect.set_fill(color=GREY,opacity=350)
+ vec_space=TextMobject("$Vector Space$").scale(0.77).shift(4.5*RIGHT+3.5*UP)
+ sub=TextMobject(r"$Subspace$",color=BLACK).scale(0.77).shift(3.8*RIGHT+2*UP)
+ self.play(ShowCreation(vec_space))
+ self.play(ShowCreation(big_rect),ShowCreation(sub))
+ self.play(ShowCreation(sq),ShowCreation(line1),ShowCreation(line2),ShowCreation(line3),ShowCreation(a1),ShowCreation(a2),ShowCreation(a3),ShowCreation(a4))
+ rec = Rectangle(color=BLACK).scale(0.5).shift(1*RIGHT)
+ rec.rotate(np.pi/2)
+ rec.set_fill(color=BLUE,opacity=350)
+ line4=Line(color=BLACK).shift(1*RIGHT).rotate(np.pi/2)
+ line5=Line(color=BLACK).scale(0.25).shift(0.75*RIGHT)
+ line6=Line(color=BLACK).scale(0.25).shift(0.5*DOWN+1.25*RIGHT)
+ b1=TextMobject(r"$b_1$",color=BLACK).scale(0.5).shift(0.3*RIGHT+0.5*UP)
+ b2=TextMobject(r"$b_2$",color=BLACK).scale(0.5).shift(0.3*RIGHT+0.5*DOWN)
+ b3=TextMobject(r"$b_3$",color=BLACK).scale(0.5).shift(1.67*RIGHT+0.8*DOWN)
+ b4=TextMobject(r"$b_4$",color=BLACK).scale(0.5).shift(1.67*RIGHT+0.5*UP)
+ self.play(ShowCreation(rec),ShowCreation(line4),ShowCreation(line5),ShowCreation(line6),ShowCreation(b1),ShowCreation(b2),ShowCreation(b3),ShowCreation(b4))
+ self.wait(1)
+ text1=TextMobject(r"$a_1 + a_2 = a_3 + a_4$",color=BLACK).scale(0.5).shift(2*LEFT+1.5*DOWN)
+ text2=TextMobject(r"$b_1 + b_2 = b_3 + b_4$",color=BLACK).scale(0.5).shift(1.5*RIGHT+1.5*DOWN)
+ self.play(ShowCreation(text1),ShowCreation(text2))
+ self.wait(3)
+ self.play(FadeOut(text1),FadeOut(text2))
+ rec.shift(3*LEFT+2.01*DOWN)
+ line4.shift(3*LEFT+2*DOWN)
+ line5.shift(3*LEFT+2*DOWN)
+ line6.shift(3*LEFT+2*DOWN)
+ b1.shift(3.1*LEFT+2.1*DOWN)
+ b2.shift(3.1*LEFT+2.1*DOWN)
+ b3.shift(2.9*LEFT+2*DOWN)
+ b4.shift(2.9*LEFT+2.3*DOWN)
+ self.play(ShowCreation(rec),ShowCreation(line4),ShowCreation(line5),ShowCreation(line6),ShowCreation(b1),ShowCreation(b2),ShowCreation(b3),ShowCreation(b4))
+ self.wait(2)
+
+ text3=TextMobject(r"$(a_1 + a_2) + (b_1 + b_2) = (a_3 + a_4) + (b_3 + b_4)$",color=BLACK).scale(0.5).shift(2.5*RIGHT+0.5*DOWN)
+ text3=TextMobject(r"$(a_1 + a_2) + (b_1 + b_2) = (a_3 + a_4) + (b_3 + b_4)$",color=BLACK).scale(0.5).shift(2.5*RIGHT+0.5*DOWN)
+ text4=TextMobject("Vector Addition",color=BLACK).scale(0.8).shift(2.5*RIGHT+0.5*UP)
+ self.play(ShowCreation(text3),ShowCreation(text4))
+ self.wait(3)
+ rec.set_fill(color=GREY,opacity=350)
+ self.play(FadeOut(text3),FadeOut(text4),FadeOut(line4),FadeOut(line5),FadeOut(line6),FadeOut(rec),FadeOut(b4),FadeOut(b3),FadeOut(b2),FadeOut(b1))
+ sq1=Square(color=BLACK).scale(0.5).shift(1.5*LEFT+1.5*UP)
+ sq1.set_fill(color=RED,opacity=350)
+ sq2=Square(color=BLACK).scale(0.5).shift(1.5*LEFT+1.5*DOWN)
+ sq2.set_fill(color=RED,opacity=350)
+ rec1=Rectangle(height=0.5,width=1,color=BLACK).shift(2.5*LEFT+1.2*UP)
+ rec1.set_fill(color=RED,opacity=350)
+ rec2=Rectangle(height=1.5,width=1,color=BLACK)
+ rec2.set_fill(color=RED,opacity=350).shift(2.5*LEFT+1.5*DOWN)
+ self.play(ShowCreation(sq1),ShowCreation(sq2),ShowCreation(rec1),ShowCreation(rec2))
+ a=TextMobject(r"$a_1$",color=BLACK).scale(0.5).shift(3.4*LEFT+1.2*UP)
+ b=TextMobject(r"$a_2$",color=BLACK).scale(0.5).shift(3.4*LEFT+1.4*DOWN)
+ c=TextMobject(r"$a_3$",color=BLACK).scale(0.5).shift(0.7*LEFT+1.4*DOWN)
+ d=TextMobject(r"$a_4$",color=BLACK).scale(0.5).shift(0.7*LEFT+1.4*UP)
+ self.play(ShowCreation(a),ShowCreation(b),ShowCreation(c),ShowCreation(d))
+ self.wait(2.3)
+ text4=TextMobject("Scalar Multiplication",color=BLACK).scale(0.8).shift(2.5*RIGHT+0.5*UP)
+ text5=TextMobject(r"$\implies 2(a_1 + a_2) = 2(a_3 + a_4)$",color=BLACK).scale(0.5).shift(2*RIGHT+0.5*DOWN)
+ text6=TextMobject(r"$(a_1 + a_1) + (a_2 + a_2) = (a_3 + a_3) + (a_4 +a_4)$",color=BLACK).scale(0.5).shift(2.5*RIGHT)
+ self.play(ShowCreation(text4),ShowCreation(text5),ShowCreation(text6))
+ self.wait(3)
+
+
+
+
+
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Unit_Circle.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Unit_Circle.py
new file mode 100644
index 0000000..2973f08
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/Unit_Circle.py
@@ -0,0 +1,68 @@
+from manimlib.imports import *
+import numpy as np
+import math
+
+class Unit_Circle(GraphScene):
+ CONFIG = {
+ "x_min" : -3,
+ "x_max" : 3,
+ "y_min" : -3,
+ "y_max" : 3,
+ "y_tick_frequency" : 1,
+ "x_tick_frequency" : 1,
+ "x_labeled_nums" : list(np.arange(-3,4,1)),
+ "y_labeled_nums" : list(np.arange(-3,4,1)),
+ "graph_origin" : ORIGIN,
+ "axes_color" : GREY,
+ "x_axis_width": 6,
+ "y_axis_height":6,
+ }
+
+ def construct(self):
+ self.setup_axes(animate = True)
+ circle = Circle(radius=1,color=BLUE)
+ self.play(ShowCreation(circle))
+ dot1 = Dot(color=RED).scale(0.7)
+ dot1.shift(1*UP)
+ dot2 = Dot(color=RED).scale(0.7)
+ dot2.shift(1*LEFT)
+ dot3 = Dot(color=RED).scale(0.7)
+ dot3.shift(1*DOWN)
+ dot4 = Dot(color=RED).scale(0.7)
+ dot4.shift(1*RIGHT)
+ dot5= Dot(color=RED).scale(0.7)
+ dot6 = Dot(color=RED).scale(0.7)
+ dot5.shift(0.5*RIGHT+(math.sqrt(3)/2)*UP)
+ dot6.shift(0.5*LEFT+(math.sqrt(3)/2)*DOWN)
+ dot7 = Dot(color=RED).scale(0.7)
+ dot7.shift(math.sqrt(2)/2*RIGHT+math.sqrt(2)/2*UP)
+ dot8 = Dot(color=RED).scale(0.7)
+ dot8.shift(math.sqrt(2)/2*LEFT+math.sqrt(2)/2*UP)
+ dot9 = Dot(color=RED).scale(0.7)
+ dot9.shift(0.5*LEFT+(math.sqrt(3)/2)*UP)
+ dot10 = Dot(color=RED).scale(0.7)
+ dot10.shift(math.sqrt(3)/2*LEFT+0.5*UP)
+ dot11=Dot(color=RED).scale(0.7)
+ dot11.shift(math.sqrt(3)/2*RIGHT+0.5*UP)
+ dot12= Dot(color=RED).scale(0.7)
+ dot12.shift(math.sqrt(3)/2*LEFT+0.5*DOWN)
+ dot13=Dot(color=RED).scale(0.7)
+ dot13.shift(math.sqrt(2)/2*RIGHT+math.sqrt(2)/2*DOWN)
+ dot14=Dot(color=RED).scale(0.7)
+ dot14.shift(math.sqrt(2)/2*LEFT+math.sqrt(2)/2*DOWN)
+ dot15=Dot(color=RED).scale(0.7)
+ dot15.shift(math.sqrt(3)/2*RIGHT+0.5*DOWN)
+ dot16=Dot(color=RED).scale(0.7)
+ dot16.shift(0.5*RIGHT+(math.sqrt(3)/2)*DOWN)
+ self.play(ShowCreation(dot1),ShowCreation(dot2))
+ self.play(ShowCreation(dot3),ShowCreation(dot4))
+ self.play(ShowCreation(dot5),ShowCreation(dot6))
+ self.play(ShowCreation(dot7),ShowCreation(dot8))
+ self.play(ShowCreation(dot9),ShowCreation(dot10))
+ self.play(ShowCreation(dot11),ShowCreation(dot12))
+ self.play(ShowCreation(dot13),ShowCreation(dot14))
+ self.play(ShowCreation(dot15),ShowCreation(dot16))
+ self.wait(4)
+
+
+
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Straight_Line_Through_Origin.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Straight_Line_Through_Origin.gif
new file mode 100644
index 0000000..b7695a4
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Straight_Line_Through_Origin.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Subspace_Example.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Subspace_Example.gif
new file mode 100644
index 0000000..32b02be
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Subspace_Example.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Unit_Circle.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Unit_Circle.gif
new file mode 100644
index 0000000..165d040
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Subspaces/gifs/Unit_Circle.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/3D_Vector_Space.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/3D_Vector_Space.py
new file mode 100644
index 0000000..70913eb
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/3D_Vector_Space.py
@@ -0,0 +1,14 @@
+from manimlib.imports import *
+class ThreeDSpace(ThreeDScene):
+ def construct(self):
+ curve = ParametricFunction(
+ lambda x: np.array([
+ 0, -x , x]), color = YELLOW, t_min = -2, t_max = 2)
+ axes = ThreeDAxes()
+ axes.set_stroke(width=1,color=GOLD)
+ self.add(axes)
+ self.set_camera_orientation(phi = 70*DEGREES,theta =60*DEGREES)
+ self.begin_ambient_camera_rotation(rate=0.3)
+ self.play(ShowCreation(curve))
+ self.wait(6)
+
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Addition_and_Scaling.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Addition_and_Scaling.py
new file mode 100644
index 0000000..70af123
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Addition_and_Scaling.py
@@ -0,0 +1,137 @@
+from manimlib.imports import *
+import numpy as np
+
+class vectorspace(GraphScene):
+ CONFIG={
+ "x_min": -7,
+ "x_max": 7,
+ "y_min": -7,
+ "y_max": 7,
+ "graph_origin": ORIGIN,
+ "x_axis_label":"$X$",
+ "y_axis_label":"$Y$",
+ "x_labeled_nums": list(np.arange(-7, 8,1)),
+ "y_labeled_nums": list(np.arange(-7, 8,1)),
+ "x_axis_width": 8,
+ "y_axis_height": 7,
+ "x_tick_frequency":1,
+ "axes_color": GREY,
+ "area_opacity": 3,
+ "num_rects": 10,
+ }
+ def construct(self):
+ XD = self.x_axis_width/(self.x_max- self.x_min)
+ YD = self.y_axis_height/(self.y_max- self.y_min)
+ a1=1*XD*RIGHT+2*YD*UP
+ a2=1*XD*RIGHT+1*YD*UP
+ vec1=Vector(direction=a1).set_color(RED_E)
+ vec1.shift(self.graph_origin)
+ vec2=Vector(direction=a2).set_color(YELLOW_E)
+ vec2.shift(self.graph_origin)
+ vec1_text=TextMobject(r"$\vec{a}$")
+ vec2_text=TextMobject(r"$\vec{b}$")
+ vec1_text=(vec1_text.shift(self.graph_origin+a1+0.2)).scale(.7)
+ vec2_text=(vec2_text.shift(self.graph_origin+a2+0.2)).scale(.7)
+ self.setup_axes(animate=True)
+ self.wait(2)
+ self.play(ShowCreation(vec1))
+ self.play(ShowCreation(vec1_text))
+ self.wait(.7)
+ self.play(ShowCreation(vec2))
+ self.play(ShowCreation(vec2_text))
+ self.wait(.7)
+ a=TextMobject(r"$\vec{a} = (1,2)$",color=RED_B).scale(.6)
+ a.shift(3*LEFT+2.7*UP)
+ b=TextMobject(r"$\vec{b} = (1,1)$",color=YELLOW_E).scale(.6)
+ b.shift(3*LEFT+2*UP)
+ self.play(ShowCreation(a))
+ self.play(ShowCreation(b))
+ self.wait(.5)
+ c=TextMobject(r"$2\cdot\vec{a} = 2\cdot(1,2) = (2,4)$",color=RED_B)
+ c.shift(3*LEFT+2.7*UP)
+ c.scale(.6)
+ self.play(Transform(a,c))
+ scaling1=TextMobject(r"Scaling vector $\vec{a}$ by 2 units",color=GOLD).scale(.5)
+ scaling1.shift(3.4*RIGHT+2.4*UP)
+ self.play(ShowCreation(scaling1))
+ a1=2*XD*RIGHT+4*YD*UP
+ self.play(FadeOut(vec1_text))
+ vec1_scaled=Vector(direction=a1).set_color(RED_E)
+ vec1_scaled.shift(self.graph_origin)
+ self.play(ShowCreation(vec1_scaled))
+ self.play(FadeOut(vec1))
+ vec1_scaled_text=TextMobject(r"$2\vec{a}$").scale(.7)
+ vec1_scaled_text.shift(self.graph_origin+a1+0.2)
+ self.play(ShowCreation(vec1_scaled_text))
+ self.play(FadeOut(scaling1))
+ d=TextMobject(r"$3\cdot\vec{b} = 3\cdot(1,1) = (3,3)$",color=YELLOW_E).scale(.6)
+ d.shift(3*LEFT+2*UP)
+ self.play(Transform(b,d))
+ scaling2=TextMobject(r"Scaling vector $\vec{b}$ by 3 units",color=GOLD).scale(.5)
+ scaling2.shift(3.4*RIGHT+2.4*UP)
+ self.play(ShowCreation(scaling2))
+ a2=3*XD*RIGHT+3*YD*UP
+ self.play(FadeOut(vec2_text))
+ vec2_2=Vector
+ vec2_scaled=Vector(direction=a2).set_color(YELLOW_E)
+ vec2_scaled.shift(self.graph_origin)
+ self.play(ShowCreation(vec2_scaled))
+ self.play(FadeOut(vec2))
+ vec2_scaled_text=TextMobject(r"$3\vec{b}$").scale(.7)
+ vec2_scaled_text.shift(self.graph_origin+a2+0.2)
+ self.play(ShowCreation(vec2_scaled_text))
+ self.wait(.7)
+ self.play(FadeOut(scaling2))
+ add = TextMobject("+").scale(.7)
+ add.shift(4.8*LEFT+2*UP)
+ self.play(ShowCreation(add))
+ self.wait(.5)
+ line = Line()
+ line.shift(3*LEFT+1.6*UP)
+ line.scale(1.8)
+ self.play(ShowCreation(line))
+ self.wait(1)
+ e = TextMobject(r"$\vec{c} = 2\cdot\vec{a} + 3\cdot\vec{b} = (5,7)$",color=GREEN_D).scale(.6)
+ e.shift(3*LEFT+1.3*UP)
+ self.play(ShowCreation(e))
+ self.wait(.5)
+ add1=TextMobject("Addition of the scaled vectors",color=GOLD).scale(.5)
+ add1.shift(4.1*RIGHT+2.4*UP)
+ self.play(ShowCreation(add1))
+ self.wait(.5)
+ self.play(FadeOut(vec1_scaled_text))
+ self.play(FadeOut(vec2_scaled_text))
+ self.play(FadeOut(vec1_scaled))
+ vec1_scaled2=Vector(direction=a1).set_color(RED_E)
+ vec1_scaled2.shift(self.graph_origin+3*RIGHT*XD+3*UP*YD)
+ self.play(ShowCreation(vec1_scaled2))
+ a3=5*XD*RIGHT+7*YD*UP
+ vec3=Vector(direction=a3).set_color(GREEN_C)
+ vec3.shift(self.graph_origin)
+ vec3_text=TextMobject(r"$\vec{c}$").scale(.7)
+ vec3_text.shift(self.graph_origin+a3+0.2)
+ self.play(ShowCreation(vec3))
+ self.wait(.5)
+ self.play(ShowCreation(vec3_text))
+ self.wait(1)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Space_As_Functions.py b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Space_As_Functions.py
new file mode 100644
index 0000000..4f5614d
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/Vector_Space_As_Functions.py
@@ -0,0 +1,62 @@
+from manimlib.imports import *
+from scipy import sin,cos
+class FunctionalVectorSpace(GraphScene):
+ CONFIG = {
+ "x_min": -5,
+ "x_max": 5,
+ "y_min": -5,
+ "y_max": 5,
+ "graph_origin": ORIGIN,
+ }
+ def construct(self):
+ self.setup_axes(animate = True)
+ curve1 = self.get_graph(lambda x : sin(x), x_min=-5,x_max=5,color=YELLOW_E)
+ curve2 = self.get_graph(lambda x : cos(x), x_min=-5,x_max=5,color=RED)
+ self.play(ShowCreation(curve1))
+ fx=TextMobject(r"$f(x)$",color=YELLOW_E).scale(0.7)
+ fx.shift(5*LEFT+0.7*UP)
+ self.play(ShowCreation(fx))
+ self.play(ShowCreation(curve2))
+ gx=TextMobject(r"$g(x)$",color=RED).scale(0.7)
+ gx.shift(5*LEFT+0.2*UP)
+ self.play(ShowCreation(gx))
+ self.wait(2)
+ scaling=TextMobject("Scaling f(x) by 2 units",color=GOLD).scale(0.65)
+ scaling.shift(3*LEFT+2.4*UP)
+ curve3 = self.get_graph(lambda x : 2*sin(x), x_min=-5,x_max=5,color=BLUE)
+ fx2=TextMobject(r"$2f(x)$",color=BLUE).scale(0.7)
+ fx2.shift(5*LEFT+1*UP)
+ self.play(Transform(curve1,curve3),FadeOut(fx),ShowCreation(fx2),ShowCreation(scaling))
+ self.wait(3)
+ hx = TextMobject(r"$h(x)$",color=PURPLE).scale(0.7)
+ hx.shift(4.9*LEFT+1.5*UP)
+ curve4 = self.get_graph(lambda x : 2*sin(x) + cos(x), x_min=-5,x_max=5,color=PURPLE)
+ self.play(ShowCreation(curve4),ShowCreation(hx))
+ self.play(FadeOut(curve2),FadeOut(curve1),FadeOut(fx2),FadeOut(gx),FadeOut(scaling))
+ hxn=TextMobject(r"$h(x)$",color=PURPLE).scale(0.7)
+ hxn.shift(3*RIGHT+2.4*UP)
+ equal = TextMobject("=").scale(0.7)
+ equal.shift(3.5*RIGHT+2.4*UP)
+ fx2n=TextMobject(r"$2f(x)$",color=BLUE).scale(0.7)
+ fx2n.shift(4.2*RIGHT+2.4*UP)
+ add=TextMobject("+").scale(0.7)
+ add.shift(4.8*RIGHT+2.4*UP)
+ gxn=TextMobject(r"$g(x)$",color=RED).scale(0.7)
+ gxn.shift(5.3*RIGHT+2.4*UP)
+ vector_add=TextMobject("Vector Addition",color=GOLD).scale(0.65)
+ vector_add.shift(3*UP+3*RIGHT)
+ self.play(ShowCreation(hxn),ShowCreation(equal),ShowCreation(fx2n),ShowCreation(add),ShowCreation(gxn),ShowCreation(vector_add))
+ self.wait(2)
+
+
+
+
+
+
+
+
+
+
+
+
+ \ No newline at end of file
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/3D_Vector_Space.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/3D_Vector_Space.gif
new file mode 100644
index 0000000..137546a
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/3D_Vector_Space.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Function_Vector_Space_Example.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Function_Vector_Space_Example.gif
new file mode 100644
index 0000000..d9edf46
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Function_Vector_Space_Example.gif
Binary files differ
diff --git a/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Vector_Addition_and_Scalar_Multiplication.gif b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Vector_Addition_and_Scalar_Multiplication.gif
new file mode 100644
index 0000000..ed65f8a
--- /dev/null
+++ b/FSF-2020/linear-algebra/vector-spaces/Vector-Spaces/Vector-Spaces/gifs/Vector_Addition_and_Scalar_Multiplication.gif
Binary files differ
generated by cgit (git 2.34.1) at 2025-05-23 01:50:46 +0000