Merge pull request #1 from FOSSEE/master

update fork. DONE

38 files changed, 1791 insertions, 0 deletions

diff --git a/FSF-2020/calculus/intro-to-calculus/README.md b/FSF-2020/calculus/intro-to-calculus/README.md
new file mode 100644
index 0000000..a417361
--- /dev/null
+++ b/FSF-2020/calculus/intro-to-calculus/README.md
@@ -0,0 +1,8 @@
+Contributor: Aryan Singh

+Subtopics covered

+ - When do limits exist?

+ - How Fast am I going?-An intro to derivatives

+ - Infinte sums in a nutshell(Riemann integrals)

+ - Fundamental Theorem of calculus

+ - Volume and surface area of Gabriel's Horn

+ - Infinite sequences and series

diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/README.md b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/README.md
new file mode 100644
index 0000000..d4cd8bc
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/README.md
@@ -0,0 +1,21 @@
+### Basic Intuition
+![GIF1](gifs/basicIntuition.gif)
+
+### Solving D.E.intuition
+![GIF2](gifs/solvingDEintuition.gif)
+
+### Unit Step Function
+#### Part1
+![GIF3](gifs/unitStepFunction.gif)
+#### Part2
+![GIF4](gifs/UnitStepFunctionExample.gif)
+#### Part3
+![GIF5](gifs/LtransformUnitStepFunction.gif)
+
+### Dirac Delta Function
+#### Part1
+![GIF6](gifs/DiracFunction.gif)
+#### Part2
+![GIF7](gifs/DiracFunctionFormation.gif)
+#### Part3
+![GIF8](gifs/LtransformDiracFunction.gif)
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file1_laplaceTransformBasic.py b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file1_laplaceTransformBasic.py
new file mode 100644
index 0000000..7a37ae8
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file1_laplaceTransformBasic.py
@@ -0,0 +1,67 @@
+from manimlib.imports import *
+import pylatex
+
+class depict(Scene):
+    def construct(self):
+        square=Square(side_length=2,fill_color=GREEN,fill_opacity=0.7)
+        inputText=TextMobject("$t$")
+        squareText=TextMobject("$f$")
+        outputText=TextMobject("$f($","$t$","$)$")
+
+        inputText.scale(0.8)
+        outputText.scale(0.8)
+        inputText.shift(2.1*LEFT)
+        outputText.shift(1.5*RIGHT)
+        squareText.scale(1.2)
+
+        outputText.set_color_by_tex_to_color_map({"$t$":RED})
+
+        self.play(ShowCreation(square))
+        self.play(FadeIn(squareText))
+        self.add(inputText)
+        self.wait(0.5)
+        self.play(ApplyMethod(inputText.shift,0.9*RIGHT))
+        self.play(FadeOut(inputText),FadeIn(outputText))
+        self.play(ApplyMethod(outputText.shift,1.5*RIGHT))
+        self.wait(1)
+
+        fOutGroup=VGroup(outputText,square,squareText)
+        self.play(ApplyMethod(fOutGroup.scale,0.6))
+        self.play(ApplyMethod(fOutGroup.shift,5*LEFT))
+        self.wait(0.8)
+        laplaceSquare=Square(side_length=3,fill_color=BLUE,fill_opacity=0.6)
+        laplaceText=TextMobject("$\mathscr{L}$")
+        outText=TextMobject("$F($","$s$","$)$")
+        outText.scale(0.8)
+        outText.set_color_by_tex_to_color_map({"$s$":RED})
+        laplaceText.scale(1.5)
+        outText.shift(2*RIGHT)
+        self.play(ShowCreation(laplaceSquare))
+        self.play(FadeIn(laplaceText))
+        self.wait(0.5)
+        self.play(ApplyMethod(outputText.shift,RIGHT))
+        self.play(FadeOut(outputText),FadeIn(outText))
+        self.play(ApplyMethod(outText.shift,2*RIGHT))
+        self.wait(1)
+
+        updatedOutputText=TextMobject("$f($","$t$","$)$")
+        updatedOutputText.shift(2.5*LEFT)
+        updatedOutputText.set_color_by_tex_to_color_map({"$t$":RED})
+        updatedInputText=TextMobject("$t$")
+        updatedInputText.shift(6*LEFT)
+        updatedInputText.scale(0.7)
+        updatedOutputText.scale(0.7)
+
+        self.play(FadeIn(updatedInputText),FadeIn(updatedOutputText))
+        self.wait(0.5)
+
+        timeText=TextMobject("Time Domain")
+        frequencyText=TextMobject("Frequency Domain")
+        timeText.set_color(RED)
+        frequencyText.set_color(RED)
+        timeText.scale(0.35)
+        frequencyText.scale(0.35)
+        timeText.shift(2.5*LEFT+0.5*DOWN)
+        frequencyText.shift(4*RIGHT+0.5*DOWN)
+        self.play(Write(frequencyText),Write(timeText))
+        self.wait(2)
\ No newline at end of file
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file2_differentialEqSimplification.py b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file2_differentialEqSimplification.py
new file mode 100644
index 0000000..33e9173
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file2_differentialEqSimplification.py
@@ -0,0 +1,78 @@
+from manimlib.imports import *
+import pylatex
+
+class scene(Scene):
+    def construct(self):
+        normalSq=Square(side_length=2,fill_color=BLUE,fill_opacity=0.6)
+        normalSqText=TextMobject("$\mathscr{L}$")
+        inputText=TextMobject("$f($","$y'(t)$","$)$")
+        outputText=TextMobject("$F($","$s$","$)$")
+        
+        inputText.scale(0.7)
+        outputText.scale(0.7)
+        inputText.shift(2.5*LEFT)
+        outputText.shift(1.7*RIGHT)
+        normalSq.scale(1.2)
+
+        inputText.set_color_by_tex_to_color_map({"$y'(t)$":RED})
+        outputText.set_color_by_tex_to_color_map({"$s$":RED})
+
+        self.play(ShowCreation(normalSq))
+        self.play(FadeIn(normalSqText))
+        self.add(inputText)
+        self.wait(0.5)
+        self.play(ApplyMethod(inputText.shift,0.7*RIGHT))
+        self.play(FadeOut(inputText),FadeIn(outputText))
+        self.play(ApplyMethod(outputText.shift,RIGHT))
+        self.wait(1)
+
+        group1=VGroup(outputText,normalSq,normalSqText)
+        self.play(ApplyMethod(group1.scale,0.6))
+        self.play(ApplyMethod(group1.shift,4.7*LEFT))
+        self.wait(0.6)
+
+        inverseSq=Square(side_length=3,fill_color=GREEN,fill_opacity=0.6)
+        inverseSqText=TextMobject("$\mathscr{L}^{ -1 }$")
+        outText=TextMobject("$f($","$y(t)$","$)$")
+        inverseSqText.scale(0.7)
+        outText.scale(0.7)
+        outText.set_color_by_tex_to_color_map({"$y(t)$":RED})
+        self.play(ShowCreation(inverseSq))
+        self.play(FadeIn(inverseSqText))
+        self.wait(0.5)
+        outText.shift(2*RIGHT)
+        self.play(ApplyMethod(outputText.shift,RIGHT))
+        self.play(FadeOut(outputText),FadeIn(outText))
+        self.play(ApplyMethod(outText.shift,2*RIGHT))
+        self.wait(1)
+
+        updatedOutputText=TextMobject("$F($","$s$","$)$")
+        updatedOutputText.shift(2.5*LEFT)
+        updatedInputText=TextMobject("$f($","$y'(t)$","$)$")
+        updatedInputText.shift(6*LEFT)
+        updatedInputText.scale(0.7)
+        updatedOutputText.scale(0.7)
+        updatedOutputText.set_color_by_tex_to_color_map({"$s$":RED})
+        updatedInputText.set_color_by_tex_to_color_map({"$y'(t)$":RED})
+
+        self.play(FadeIn(updatedInputText),FadeIn(updatedOutputText))
+        self.wait(0.5)
+
+        deText=TextMobject("Differential Equation")
+        deinterTexta=TextMobject("Transformed D.E")
+        deinterTextb=TextMobject("(Easy to simplify)!")
+        deOutText=TextMobject("Solution of D.E")
+        deText.set_color(RED)
+        deinterTexta.set_color(RED)
+        deOutText.set_color(RED)
+        deinterTextb.set_color(PURPLE_C)
+        deText.scale(0.35)
+        deinterTexta.scale(0.35)
+        deinterTextb.scale(0.35)
+        deOutText.scale(0.35)
+        deText.shift(6*LEFT+0.5*DOWN)
+        deinterTexta.shift(2.6*LEFT+0.5*DOWN)
+        deinterTextb.shift(2.6*LEFT+0.8*DOWN)
+        deOutText.shift(4*RIGHT+0.5*DOWN)
+        self.play(Write(deText),Write(deinterTexta),Write(deinterTextb),Write(deOutText))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file3_unitStepFunction.py b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file3_unitStepFunction.py
new file mode 100644
index 0000000..53c5f14
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file3_unitStepFunction.py
@@ -0,0 +1,168 @@
+from manimlib.imports import *
+import math
+import pylatex
+
+class intro(GraphScene,Scene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -5,
+        "y_max": 5,
+        "graph_origin": ORIGIN+DOWN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$t$",
+        "y_axis_label": "$\mu_{c}(t)$",
+        "exclude_zero_label": True,
+        "y_axis_height":4,
+        "x_axis_width":7
+    }
+    def setup(self):
+        GraphScene.setup(self)
+        Scene.setup(self)
+    def construct(self):
+        introText=TextMobject("Unit","Step","Function")
+        introText.set_color_by_tex_to_color_map({"Unit":BLUE,"Step":YELLOW})
+        introText.scale(0.8)
+        self.play(Write(introText))
+        self.wait(0.5)
+        self.play(ApplyMethod(introText.shift,3*UP))
+        formulaa=TextMobject("$\mu _{ c }(t)=0\quad$","$t<c$")
+        formulab=TextMobject("$\mu _{ c }(t)=1\quad$","$t\ge c$")
+        formulaa.set_color_by_tex_to_color_map({"$t<c$":RED})
+        formulab.set_color_by_tex_to_color_map({"$t\ge c$":RED})
+        formulaa.scale(0.8)
+        formulab.scale(0.8)
+        formulab.shift(0.5*DOWN)
+        self.play(FadeIn(formulaa),FadeIn(formulab))
+        self.wait(1)
+
+        self.play(FadeOut(formulaa),FadeOut(formulab))
+
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        self.setup_axes(animate=True)
+        self.wait(0.8)
+        
+        c=TextMobject("c")
+        c.scale(0.5)
+        c.set_color(RED)
+        c.shift(self.graph_origin+3*x_each_unit*RIGHT+y_each_unit*0.4*DOWN)
+        self.play(Write(c))
+        smallCircle=Circle(radius=0.03,fill_color=WHITE,color=WHITE)
+        smallCircle.shift(self.graph_origin+3*x_each_unit*RIGHT)
+        downLine=Line(start=self.graph_origin,end=self.graph_origin+RIGHT*3*x_each_unit,color=BLUE)
+        upLine=Line(start=self.graph_origin+3*x_each_unit*RIGHT+y_each_unit*UP,end=self.graph_origin+8*x_each_unit*RIGHT+y_each_unit*UP,color=BLUE)
+        
+        self.play(Write(downLine))
+        self.play(Write(smallCircle))
+        self.play(Write(upLine))
+        self.wait(1.5)
+        self.play(FadeOut(self.axes),FadeOut(smallCircle),FadeOut(c),FadeOut(upLine),FadeOut(downLine),FadeOut(introText))
+        self.wait(0.5)
+
+
+class example(GraphScene):
+    CONFIG = {
+        "x_min": -3,
+        "x_max": 8,
+        "y_min": -4,
+        "y_max": 5,
+        "graph_origin": ORIGIN+LEFT+DOWN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$t$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "y_axis_height":4,
+        "x_axis_width":6
+    }
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        text1=TextMobject("Consider the","formation","of","following graph!"," (a part of $f(t))$")
+        text1.set_color_by_tex_to_color_map({"following graph!":BLUE,"formation":YELLOW})
+        text1.scale(0.6)
+        ft=TextMobject("$f(t)$")
+        ftminusc=TextMobject("$f(t-c)$")
+        final=TextMobject("$\mu_{c}(t)f(t-c)$")
+        ft.set_color(PURPLE_C)
+        ftminusc.set_color(PURPLE_C)
+        final.set_color(PURPLE_C)
+        c=TextMobject("c")
+        c.scale(0.5)
+        c.set_color(RED)
+        c.shift(self.graph_origin+RIGHT*x_each_unit*3+DOWN*y_each_unit*0.5)
+        ft.scale(0.5)
+        ftminusc.scale(0.5)
+        final.scale(0.5)
+
+        self.play(Write(text1))
+        self.play(ApplyMethod(text1.shift,3*UP))
+
+        self.setup_axes(animate=True)
+        y=self.get_graph(lambda x:(math.pow((x-3),3)/3)-math.pow((x-3),2)-(x-3)+3,x_min=3,x_max=7,color=RED)
+        f=self.get_graph(lambda x:(math.pow(x,3)/3)-math.pow(x,2)-x+3,x_min=-2,x_max=4,color=RED)
+        yFull=self.get_graph(lambda x:(math.pow((x-3),3)/3)-math.pow((x-3),2)-(x-3)+3,x_min=1,x_max=7,color=RED)
+
+        self.play(Write(c))
+        self.play(ShowCreation(y))
+        self.wait(1)
+        self.play(FadeOut(self.axes),FadeOut(y),FadeOut(c))
+
+        belowText1=TextMobject("Consider its","normal form",", $f(t)$")
+        belowText1.set_color_by_tex_to_color_map({"normal form":BLUE})
+        belowText2=TextMobject("Shift it to","x=c")
+        belowText2.set_color_by_tex_to_color_map({"x=c":RED})
+        belowText3a=TextMobject("Now to remove the","left part","of","$c$,")
+        belowText3a.set_color_by_tex_to_color_map({"left part":YELLOW,"$c$,":YELLOW})
+        belowText3b=TextMobject("multiply it with the","unit step function",", $\mu_{c}(t)$")
+        belowText3b.set_color_by_tex_to_color_map({"unit step function":BLUE})
+        belowText1.scale(0.4)
+        belowText2.scale(0.4)
+        belowText3a.scale(0.4)
+        belowText3b.scale(0.4)
+        belowText1.shift(2.7*DOWN+4*RIGHT)
+        belowText2.shift(2.7*DOWN+4*RIGHT)
+        belowText3a.shift(2.7*DOWN+4*RIGHT)
+        belowText3b.shift(3.1*DOWN+4*RIGHT)
+        self.setup_axes(animate=True)
+        self.play(Write(belowText1))
+        self.play(ShowCreation(f))
+        ft.shift(1.5*RIGHT+UP*0.8)
+        self.play(FadeIn(ft))
+        self.play(ReplacementTransform(belowText1,belowText2))
+        ftminusc.shift(3.5*RIGHT+UP*0.8)
+        self.play(ReplacementTransform(f,yFull),ReplacementTransform(ft,ftminusc),Write(c))
+        self.wait(1)
+
+        self.play(ReplacementTransform(belowText2,belowText3a))
+        self.play(Write(belowText3b))
+        final.shift(3.7*RIGHT+UP*0.8)
+        self.play(ReplacementTransform(ftminusc,final),ReplacementTransform(yFull,y))
+
+        finalText=TextMobject("We got our required Graph!")
+        finalText.scale(0.55)
+        finalText.shift(2.7*DOWN+4*RIGHT)
+        self.play(FadeOut(belowText3b),ReplacementTransform(belowText3a,finalText))
+        self.wait(1.5)
+
+        self.play(FadeOut(finalText),FadeOut(text1))
+
+        graphGrup=VGroup(self.axes,c,final,y)
+        self.play(ApplyMethod(graphGrup.scale,0.45))
+        box=Square(side_length=2,fill_color=BLUE,fill_opacity=0.7)
+        boxtext=TextMobject("$\mathscr{L}$")
+        boxtext.scale(0.8)
+        self.play(ApplyMethod(graphGrup.shift,5.5*LEFT+UP))
+        self.play(ShowCreation(box),Write(boxtext))
+        outText=TextMobject("${ e }^{ -cs }F(s)$")
+        outText.set_color(GREEN)
+        outText.scale(0.65)
+        outText.shift(2*RIGHT)
+        self.play(ApplyMethod(graphGrup.shift,2*RIGHT))
+        self.play(FadeOut(graphGrup),FadeIn(outText))
+        self.play(ApplyMethod(outText.shift,RIGHT))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file4_diracBasic.py b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file4_diracBasic.py
new file mode 100644
index 0000000..0c7f8e4
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file4_diracBasic.py
@@ -0,0 +1,61 @@
+from manimlib.imports import *
+import math
+import pylatex
+
+class intro(GraphScene,Scene):
+    CONFIG = {
+        "x_min": -9,
+        "x_max": 9,
+        "y_min": -5,
+        "y_max": 5,
+        "graph_origin": ORIGIN+DOWN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$\delta (x)$",
+        "y_axis_height":4,
+        "x_axis_width":7
+    }
+    def setup(self):
+        GraphScene.setup(self)
+        Scene.setup(self)
+    def construct(self):
+        introText=TextMobject("Dirac","Delta","Function")
+        introText.set_color_by_tex_to_color_map({"Dirac":BLUE,"Delta":YELLOW})
+        introText.scale(0.8)
+        self.play(Write(introText))
+        self.wait(0.5)
+        self.play(ApplyMethod(introText.shift,3*UP))
+        formulaa=TextMobject("$\delta (x)=\infty$","$x=0$")
+        formulab=TextMobject("$\delta (x)=0$","$x\\neq 0$")
+        formulaa.set_color_by_tex_to_color_map({"$x=0$":RED})
+        formulab.set_color_by_tex_to_color_map({"$x\\neq 0$":RED})
+        formulaa.scale(0.8)
+        formulab.scale(0.8)
+        formulab.shift(0.5*DOWN)
+        self.play(FadeIn(formulaa),FadeIn(formulab))
+        self.wait(1)
+
+        self.play(FadeOut(formulaa),FadeOut(formulab))
+
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        self.setup_axes(animate=True)
+        self.wait(0.8)
+
+        functionUpLine=Line(start=self.graph_origin,end=self.graph_origin+UP*y_each_unit*5,color=RED)
+        functionDownLine=Line(start=self.graph_origin+UP*y_each_unit*5,end=self.graph_origin,color=RED)
+        functinLeftLine=Line(start=self.graph_origin+LEFT*x_each_unit*9,end=self.graph_origin,color=RED)
+        functionRightLine=Line(start=self.graph_origin,end=self.graph_origin+RIGHT*x_each_unit*9,color=RED)
+        functionUpLine.shift(0.02*LEFT)
+        functionRightLine.shift(0.02*RIGHT)
+
+        self.play(ShowCreation(functinLeftLine))
+        self.play(ShowCreation(functionUpLine))
+        self.play(ShowCreation(functionDownLine))
+        self.play(ShowCreation(functionRightLine))
+        self.wait(1.5)
+
+        self.play(FadeOut(self.axes),FadeOut(introText),FadeOut(functinLeftLine),FadeOut(functionRightLine),FadeOut(functionUpLine),FadeOut(functionDownLine))
+        self.wait(0.5)
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file5_formationDiracDeltaFunction.py b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file5_formationDiracDeltaFunction.py
new file mode 100644
index 0000000..565a7cb
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/file5_formationDiracDeltaFunction.py
@@ -0,0 +1,142 @@
+from manimlib.imports import *
+import math
+import pylatex
+
+def func(x,t):
+    if(x>-t and x<t):
+        return 1/(2*t)
+    else:
+        return 0
+        
+
+class formation(GraphScene):
+    CONFIG = {
+        "x_min": -7,
+        "x_max": 7,
+        "y_min": -2,
+        "y_max": 2,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$t$",
+        "y_axis_label": "$y$",
+        "y_labeled_nums":range(-2,3),
+        "y_axis_height":4,
+        "x_axis_width":7
+    }
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        text1=TextMobject("Consider the","following function's graph!")
+        text1.set_color_by_tex_to_color_map({"following function's graph!":BLUE})
+        text1.scale(0.6)
+
+        equation1=TextMobject("$\delta _{ \\tau  }(t)=\\frac { 1 }{ 2\\tau  } \quad$","$-\\tau <t<\\tau$")
+        equation2=TextMobject("$\delta _{ \\tau  }(t)=0\quad \quad$","$t\in (-\infty ,-\\tau ]\cup [\\tau ,\infty )$")
+        equation1.scale(0.7)
+        equation2.scale(0.7)
+        equation1.shift(0.2*UP)
+        equation2.shift(0.4*DOWN+RIGHT*0.8)
+        equation1.set_color_by_tex_to_color_map({"$-\\tau <t<\\tau$":RED})
+        equation2.set_color_by_tex_to_color_map({"$t\in (-\infty ,-\\tau ]\cup [\\tau ,\infty )$":RED})
+
+        self.play(Write(text1))
+        self.play(ApplyMethod(text1.shift,3*UP))
+        self.play(Write(equation1))
+        self.play(Write(equation2)) 
+        self.wait(1)
+
+        self.play(FadeOut(equation1),FadeOut(equation2))
+        self.wait(0.5)
+
+        pointes1=TextMobject("$-\\tau$")
+        pointes2=TextMobject("$\\tau$")
+        pointes1.set_color(RED)
+        pointes2.set_color(RED)
+        pointes1.scale(0.65)
+        pointes2.scale(0.65)
+        
+        bottomText1=TextMobject("Here","$\int _{ -\infty  }^{ \infty  }{ \delta _{ \\tau  }(t)dt }$","=","$1$")
+        bottomText2=TextMobject("Now as","$\\tau \\rightarrow 0$")
+        bottomText3=TextMobject("We get our","Dirac Function!")
+        bottomText4=TextMobject("i.e.","$\lim _{ \\tau \\rightarrow 0 }{ \delta _{ \\tau  }(t)}$","$=$","$\delta (t)$")
+        textFinal=TextMobject("Area=1")
+        bottomText1.set_color_by_tex_to_color_map({"$\int _{ -\infty  }^{ \infty  }{ \delta _{ \\tau  }(t)dt }$":BLUE,"$1$":YELLOW})
+        textFinal.set_color(PURPLE_B)
+        bottomText2.set_color_by_tex_to_color_map({"$\\tau \\rightarrow 0$":YELLOW})
+        bottomText3.set_color_by_tex_to_color_map({"Dirac Function!":RED})
+        bottomText4.set_color_by_tex_to_color_map({"$\lim _{ \\tau \\rightarrow 0 }{ \delta _{ \\tau  }(t)}$":BLUE,"$\delta (t)$":YELLOW})
+
+        bottomText1.scale(0.6)
+        bottomText2.scale(0.6)
+        bottomText3.scale(0.6)
+        bottomText4.scale(0.6)
+        textFinal.scale(0.9)
+
+        bottomText1.shift(4*RIGHT+3*DOWN)
+        bottomText2.shift(4*RIGHT+3*DOWN)
+        bottomText3.shift(4*RIGHT+3*DOWN)
+        bottomText4.shift(4*RIGHT+3*DOWN)
+        textFinal.shift(5*RIGHT+2*UP)
+        
+        self.setup_axes(animate=True)
+
+        graphs=[
+            self.get_graph(lambda x:func(x,3),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,2),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,1),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,0.5),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,0.3),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,0.15),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,0.05),x_min=-7,x_max=7,color=RED),
+            self.get_graph(lambda x:func(x,0.01),x_min=-7,x_max=7,color=RED)
+        ]
+        pointes1.shift(self.graph_origin+3*LEFT*x_each_unit+0.4*DOWN*y_each_unit)
+        pointes2.shift(self.graph_origin+3*RIGHT*x_each_unit+0.4*DOWN*y_each_unit)
+
+        functionUpLine=Line(start=self.graph_origin,end=self.graph_origin+UP*y_each_unit*2,color=RED)
+        functionDownLine=Line(start=self.graph_origin+UP*y_each_unit*2,end=self.graph_origin,color=RED)
+        functinLeftLine=Line(start=self.graph_origin+LEFT*x_each_unit*7,end=self.graph_origin,color=RED)
+        functionRightLine=Line(start=self.graph_origin,end=self.graph_origin+RIGHT*x_each_unit*7,color=RED)
+        functionUpLine.shift(0.02*LEFT)
+        functionRightLine.shift(0.02*RIGHT)
+
+        self.play(Write(pointes1),Write(pointes2),ShowCreation(graphs[0]))
+        self.play(Write(bottomText1))
+        self.wait(0.7)
+        
+        self.play(ReplacementTransform(bottomText1,bottomText2),Write(textFinal))
+        self.wait(0.5)
+        self.play(ReplacementTransform(graphs[0],graphs[1]),ApplyMethod(pointes2.shift,LEFT*x_each_unit),ApplyMethod(pointes1.shift,RIGHT*x_each_unit))
+        self.play(ReplacementTransform(graphs[1],graphs[2]),ApplyMethod(pointes2.shift,LEFT*x_each_unit),ApplyMethod(pointes1.shift,RIGHT*x_each_unit))
+        self.wait(0.5)
+        self.play(ReplacementTransform(graphs[2],graphs[3]),FadeOut(pointes1),FadeOut(pointes2))
+        self.play(ReplacementTransform(graphs[3],graphs[4]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText2,bottomText3))
+        self.wait(1)
+        self.play(FadeOut(graphs[4]),ReplacementTransform(bottomText3,bottomText4))
+        self.wait(0.5)
+        self.play(ShowCreation(functinLeftLine))
+        self.play(ShowCreation(functionUpLine))
+        self.play(ShowCreation(functionDownLine))
+        self.play(ShowCreation(functionRightLine))
+        self.wait(2)
+
+        self.play(FadeOut(bottomText4),FadeOut(textFinal))
+        graphGrup=VGroup(self.axes,functinLeftLine,functionDownLine,functionRightLine,functionUpLine)
+        self.play(ApplyMethod(graphGrup.scale,0.5))
+        box=Square(side_length=2,fill_color=BLUE,fill_opacity=0.6)
+        boxtext=TextMobject("$\mathscr{L}$")
+        boxtext.scale(0.8)
+        self.play(ApplyMethod(graphGrup.shift,4.9*LEFT))
+        self.play(ShowCreation(box),Write(boxtext))
+        outText=TextMobject("$f(0)$")
+        outText.set_color(GREEN)
+        outText.scale(0.65)
+        outText.shift(1.5*RIGHT)
+        self.play(ApplyMethod(graphGrup.shift,2*RIGHT))
+        self.play(FadeOut(graphGrup),FadeIn(outText))
+        self.play(ApplyMethod(outText.shift,RIGHT))
+        self.wait(2)
\ No newline at end of file
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunction.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunction.gif
new file mode 100644
index 0000000..cb62ed2
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunction.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunctionFormation.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunctionFormation.gif
new file mode 100644
index 0000000..23acbe9
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/DiracFunctionFormation.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformDiracFunction.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformDiracFunction.gif
new file mode 100644
index 0000000..b1d50b5
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformDiracFunction.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformUnitStepFunction.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformUnitStepFunction.gif
new file mode 100644
index 0000000..ccbd791
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/LtransformUnitStepFunction.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/UnitStepFunctionExample.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/UnitStepFunctionExample.gif
new file mode 100644
index 0000000..2b1c38f
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/UnitStepFunctionExample.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/basicIntuition.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/basicIntuition.gif
new file mode 100644
index 0000000..3b974bb
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/basicIntuition.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/solvingDEintuition.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/solvingDEintuition.gif
new file mode 100644
index 0000000..9883a8c
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/solvingDEintuition.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/unitStepFunction.gif b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/unitStepFunction.gif
new file mode 100644
index 0000000..16757e1
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Laplace Transformations/gifs/unitStepFunction.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf
new file mode 100644
index 0000000..9fc409b
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/PowerSeriesQuestions.pdf
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/README.md b/FSF-2020/calculus/series-and-transformations/Power Series/README.md
new file mode 100644
index 0000000..85c6fc4
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/README.md
@@ -0,0 +1,14 @@
+#### PieChart
+![GIF1](gifs/file1_pieChart.gif)
+
+#### Convergence Intuition
+![GIF2](gifs/file2_convergence_Intuition.gif)
+
+#### Convergence of a function
+![GIF3](gifs/file3_convergence_of_a_function.gif)
+
+#### Radius and IntervalOfConvergence
+![GIF4](gifs/file4_radius_and_intervalOfConvergence.gif)
+
+#### Uniform Convergence
+![GIF5](gifs/file5_UniformConvergence.gif)
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file1_pieChart.gif b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file1_pieChart.gif
new file mode 100644
index 0000000..f102f6d
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file1_pieChart.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file2_convergence_Intuition.gif b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file2_convergence_Intuition.gif
new file mode 100644
index 0000000..9463ac2
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file2_convergence_Intuition.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file3_convergence_of_a_function.gif b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file3_convergence_of_a_function.gif
new file mode 100644
index 0000000..836e044
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file3_convergence_of_a_function.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file4_radius_and_intervalOfConvergence.gif b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file4_radius_and_intervalOfConvergence.gif
new file mode 100644
index 0000000..e8dbff4
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file4_radius_and_intervalOfConvergence.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file5_UniformConvergence.gif b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file5_UniformConvergence.gif
new file mode 100644
index 0000000..44cd78b
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/gifs/file5_UniformConvergence.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/video1_pieChart.py b/FSF-2020/calculus/series-and-transformations/Power Series/video1_pieChart.py
new file mode 100644
index 0000000..28eb07c
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/video1_pieChart.py
@@ -0,0 +1,128 @@
+from manimlib.imports import *
+
+
+def formFormula(coeff_list,variable_list):
+    coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")]
+    variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")]
+    coeff_list[0].shift(2.2*UP+1.6*LEFT)    
+    for i in range(0,3):
+        coeff_list[i].set_color(GOLD_A)
+        variable_list[i].next_to(coeff_list[i],buff=0.1)
+        if i!=2:
+            coeff_list[i+1].next_to(variable_list[i],buff=0.1)
+    dots=TextMobject("...")
+    dots.next_to(variable_list[2])
+    expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots)
+    expansion.scale(0.7)
+    return expansion
+
+class pieChart(Scene):
+    def construct(self):
+        circle1=Circle(radius=3,color=BLUE)
+        powerText=TextMobject("Power Series")
+        powerText.scale(0.8)
+        self.play(FadeIn(powerText))
+        self.play(ShowCreation(circle1))
+        self.wait(1)
+
+        powerGroup=VGroup(circle1,powerText)
+
+        self.play(ApplyMethod(powerGroup.scale,0.5))
+        self.play(ApplyMethod(powerGroup.move_to,2.2*UP))
+        self.wait(0.5)
+        expansion_power_coeff=[]
+        variables_power=[]
+        expansion_power=formFormula(expansion_power_coeff,variables_power)
+        self.play(ReplacementTransform(powerText,expansion_power))
+        self.wait(1)
+
+        circle2=Circle(radius=1.5)
+        circle2.shift(2.2*UP)
+        expansion_geo_coeff=[0]*3
+        variables_geo=[0]*3
+        arrow1_2=Line(start=0.7*UP,end=2.5*LEFT)
+        expansion_geo_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")]
+        for i in range(0,3):
+            expansion_geo_coeff[i].set_color(GOLD_A)
+        variables_geo=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")]
+        expansion_geo_coeff[0].shift(2.2*UP+1.6*LEFT)
+        for i in range(0,3):
+            variables_geo[i].next_to(expansion_geo_coeff[i],buff=0.1)
+            if i!=2:
+                expansion_geo_coeff[i+1].next_to(variables_geo[i],buff=0.1)
+        dots=TextMobject("...")
+        dots.next_to(variables_geo[2])
+        expansion_geo=VGroup(expansion_geo_coeff[0],expansion_geo_coeff[1],expansion_geo_coeff[2],variables_geo[0],variables_geo[1],variables_geo[2],dots)
+        expansion_geo.scale(0.7)
+
+        self.play(ApplyMethod(circle2.shift,4*LEFT+2.5*DOWN),ApplyMethod(expansion_geo.shift,4*LEFT+2.5*DOWN))
+        self.add(arrow1_2)
+        self.wait(1)
+
+        ones=[TextMobject("1"),TextMobject("1"),TextMobject("1")]
+        for i in range(0,3):
+            ones[i].set_color(GOLD_A)
+        ones[0].shift(0.3*DOWN,5*LEFT)
+        ones[1].next_to(ones[0],buff=0.5)
+        ones[2].next_to(ones[1],buff=0.7)
+        self.play(ReplacementTransform(expansion_geo_coeff[0],ones[0]),ReplacementTransform(expansion_geo_coeff[1],ones[1]),ReplacementTransform(expansion_geo_coeff[2],ones[2]))
+        self.wait(1)
+        expansion_geo=VGroup(ones[0],ones[1],ones[2],variables_geo[0],variables_geo[1],variables_geo[2],dots)
+
+        expansion_geo_final=TextMobject("$1+x+{ x }^{ 2 }..$")
+        expansion_geo_final.scale(0.8)
+        expansion_geo_final.shift(0.3*DOWN+4*LEFT)
+        self.play(ReplacementTransform(expansion_geo,expansion_geo_final))
+        self.wait(1)
+
+        circle3=Circle(radius=1.5,color=GREEN)
+        circle3.shift(2.2*UP)
+        expansion_taylor_coeff=[0]*3
+        variables_taylor=[0]*3
+        arrow1_3=Line(start=0.7*UP,end=DOWN*0.3)
+        expansion_taylor_coeff=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")]
+        for i in range(0,3):
+            expansion_taylor_coeff[i].set_color(GOLD_A)
+        variables_taylor=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")]
+        expansion_taylor_coeff[0].shift(2.2*UP+1.6*LEFT)
+        for i in range(0,3):
+            variables_taylor[i].next_to(expansion_taylor_coeff[i],buff=0.1)
+            if i!=2:
+                expansion_taylor_coeff[i+1].next_to(variables_taylor[i],buff=0.1)
+        dots=TextMobject("...")
+        dots.next_to(variables_taylor[2])
+        expansion_taylor=VGroup(expansion_taylor_coeff[0],expansion_taylor_coeff[1],expansion_taylor_coeff[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots)
+        expansion_taylor.scale(0.7)
+
+        self.play(ApplyMethod(circle3.shift,4*DOWN),ApplyMethod(expansion_taylor.shift,4*DOWN))
+        self.add(arrow1_3)
+        self.wait(1)        
+
+        differentials=[TextMobject("$f(0)$"),TextMobject("${ f'\left( 0 \\right) }$"),TextMobject("$\\frac { f''\left( 0 \\right)  }{ 2! }$")]
+        for i in range(0,3):
+            differentials[i].set_color(GOLD_A)
+        differentials[0].shift(1.8*DOWN+1.15*LEFT)
+        differentials[1].shift(1.8*DOWN+0.45*LEFT)
+        differentials[2].shift(1.8*DOWN+0.45*RIGHT)
+        differentials[0].scale(0.35)
+        differentials[1].scale(0.35)
+        differentials[2].scale(0.35)
+        self.play(ReplacementTransform(expansion_taylor_coeff[0],differentials[0]),ReplacementTransform(expansion_taylor_coeff[1],differentials[1]),ReplacementTransform(expansion_taylor_coeff[2],differentials[2]))
+        self.wait(2)
+        expansion_taylor_final=VGroup(differentials[0],differentials[1],differentials[2],variables_taylor[0],variables_taylor[1],variables_taylor[2],dots)
+
+        self.play(FadeOut(expansion_geo_final),FadeOut(expansion_taylor_final))
+        geoText=TextMobject("Geometric Series")
+        geoText.scale(0.7)
+        geoText.shift(4*LEFT+0.3*DOWN)
+        taylorText=TextMobject("Taylor Series")
+        taylorText.scale(0.7)
+        taylorText.shift(1.8*DOWN)
+        self.play(FadeIn(geoText),FadeIn(taylorText))
+        self.wait(1)
+
+        soOntext=TextMobject("So on..!")
+        soOntext.shift(4*RIGHT)
+        soOntext.scale(0.8)
+        self.play(FadeIn(soOntext))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/video2_convergence_Intuition.py b/FSF-2020/calculus/series-and-transformations/Power Series/video2_convergence_Intuition.py
new file mode 100644
index 0000000..72356c6
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/video2_convergence_Intuition.py
@@ -0,0 +1,94 @@
+from manimlib.imports import *
+import numpy as np
+
+
+class convergence(Scene):
+    def construct(self):
+        originalFormula=TextMobject("$\sum _{ n=0 }^{ \infty  }{ { a }_{ n }{ x }^{ n } }$")
+        originalFormula.set_color(RED)
+        self.play(Write(originalFormula))
+        self.wait(1)
+        self.play(ApplyMethod(originalFormula.shift,2.7*UP))
+        self.wait(1)
+
+        terms=["$a_{ 0 }$","$a_{ 1 }x$","$a_{ 2 }x^{ 2 }$","$a_{ 3 }x^{ 3 }$","$a_{ 4 }x^{ 4 }$","$a_{ 5 }x^{ 5 }$","$a_{ 6 }x^{ 6 }$","$a_{ 7 }x^{ 7 }$","$a_{ 8 }x^{ 8 }$","$a_{ 9 }x^{ 9 }$","$a_{ 10 }x^{ 10 }$","$a_{ 11 }x^{ 11 }$"]
+        termsTogetherString="+".join(terms)
+        termsTogether=TextMobject(termsTogetherString+"...")
+        termsTogether.scale(0.8)
+        termsTogether.shift(2.7*UP)
+        self.play(ReplacementTransform(originalFormula,termsTogether))
+        self.wait(1)
+
+        termMobjectRect=[0]*12
+        termMobject=TextMobject(terms[0])
+        termMobject.shift(2.7*UP+6.2*LEFT)
+        for i in range(1,13):
+            termMobjectOld=termMobject
+            termMobjectOld.scale(0.8)
+            if(i<12):
+                termMobject=TextMobject(terms[i])
+                termMobject.next_to(termMobjectOld)
+            if(i==1):
+                rectDefine=TextMobject("Here","each rectangle","represents the","value of the term")
+                rectDefine.set_color_by_tex_to_color_map({"each rectangle":BLUE,"value of the term":YELLOW})
+                rectDefine.scale(0.7)
+                rectDefine.shift(3.2*DOWN)
+                self.play(Write(rectDefine))
+                self.wait(1)
+            if(i==2):
+                ratio=TextMobject("If $\\frac { a_{ n+1 } }{ { a }_{ n } } < 1$")
+                ratio.set_color(RED)
+                ratio.scale(0.7)
+                ratio.move_to(3.2*DOWN)
+                inequality=TextMobject("$a_{ n+1 } < a_{ n }$")
+                inequality.set_color(RED)
+                inequality.scale(0.7)
+                inequality.move_to(3.2*DOWN)
+                self.play(FadeOut(rectDefine))
+                self.play(Write(ratio))
+                self.wait(1)
+                self.play(ReplacementTransform(ratio,inequality))
+                self.wait(1)
+            #self.play(ApplyMethod(termMobjectOld.move_to,(2-0.3*i)*DOWN+RIGHT*0.2*i))
+            termMobjectRect[i-1]=Rectangle(height=0.1,width=(5-0.4*i))
+            termMobjectRect[i-1].move_to((2-0.2*i)*DOWN+RIGHT*0.2*i)
+            #rectangles[p] = termMobjectRect
+            #p+=1
+            self.play(ReplacementTransform(termMobjectOld,termMobjectRect[i-1]))
+
+        uparrow=TextMobject("$\\uparrow$")
+        uparrow.set_color(GREEN)
+        uparrow.scale(6)
+        uparrow.shift(4*RIGHT+0.5*DOWN)
+        self.play(ShowCreation(uparrow))
+        self.wait(1)
+
+        converges=TextMobject("Converges!")
+        converges.set_color(RED)
+        converges.scale(0.6)
+        converges.next_to(uparrow)
+        self.play(FadeIn(converges))
+        self.wait(2)
+
+        self.play(FadeOut(converges),FadeOut(uparrow),FadeOut(inequality))
+        self.wait(0.5)
+        rect=VGroup(termMobjectRect[0],termMobjectRect[1],termMobjectRect[2],termMobjectRect[3],termMobjectRect[4],termMobjectRect[5],termMobjectRect[6],termMobjectRect[7],termMobjectRect[8],termMobjectRect[9],termMobjectRect[10],termMobjectRect[11])    
+        self.play(ApplyMethod(rect.scale,0.2))
+        for i in range(0,12):
+            self.play(ApplyMethod(termMobjectRect[i].shift,i*0.04*DOWN+(11-(3-0.11*i)*i)*LEFT*0.3))
+        func=TextMobject("$\\approx$","$f(x)$")
+        func.set_color_by_tex_to_color_map({"$f(x)$":RED})
+        func.scale(0.8)
+        func.shift(DOWN+4.5*RIGHT+0.1*UP)
+        self.play(FadeIn(func))
+
+        rightarrow=TextMobject("$\\rightarrow$")
+        rightarrow.set_color(GREEN)
+        rightarrow.scale(4)
+        rightarrow.shift(2*DOWN)
+        converges=TextMobject("Hence even the","sum converges!")
+        converges.set_color_by_tex_to_color_map({"sum converges!":RED})
+        converges.move_to(3*DOWN)
+        converges.scale(0.7)
+        self.play(Write(rightarrow),FadeIn(converges))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/video3_convergence_of_a_function.py b/FSF-2020/calculus/series-and-transformations/Power Series/video3_convergence_of_a_function.py
new file mode 100644
index 0000000..f710f42
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/video3_convergence_of_a_function.py
@@ -0,0 +1,156 @@
+from manimlib.imports import*
+import math
+
+class intro(Scene):
+    def construct(self):
+        introText1=TextMobject("Let's analyse")
+        introText2=TextMobject("for")
+        function_main=TextMobject("$\sum { { (-1) }^{ n }{ x }^{ 2n } }$")
+        function_main.set_color(GREEN)
+        introText1.scale(1.2)
+        introText1.shift(2*UP)
+        introText2.scale(0.7)
+        introText2.shift(UP)
+        function_main.scale(2)
+        function_main.shift(DOWN)
+        function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$")
+        function_expan.set_color(RED)
+        function_expan.scale(1.2)
+        function_expan.shift(2*UP)
+
+        self.play(Write(introText1))
+        self.play(FadeIn(introText2))
+        self.wait(0.5)
+        self.play(Write(function_main))
+        self.wait(1)
+
+        self.play(FadeOut(introText1),FadeOut(introText2))
+        self.play(ApplyMethod(function_main.shift,3*UP))
+        self.wait(0.5)
+        self.play(ReplacementTransform(function_main,function_expan))
+        self.wait(1)
+        self.play(ApplyMethod(function_expan.scale,0.5))
+        function_expan.to_edge(UP+RIGHT)
+        self.play(ReplacementTransform(function_expan,function_expan))
+        self.wait(1)
+
+
+class graphScene(GraphScene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -8,
+        "y_max": 8,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-1, 2, 1),
+        "y_labeled_nums": range(0,2,1)
+    }
+
+    def construct(self):
+
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$")
+        function_expan.set_color(RED)
+        function_expan.scale(0.6)
+        function_expan.to_edge(UP+RIGHT)
+        self.add(function_expan)
+
+        self.setup_axes(animate=True)
+
+        eqText=[TextMobject("$1$"),TextMobject("$1-{ x }^{ 2 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }$"),TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }$")]
+        for i in range(0,len(eqText)):
+            eqText[i].scale(0.6)
+            eqText[i].set_color(BLUE)
+            eqText[i].shift(ORIGIN+UP*2*y_each_unit+RIGHT*3.3*x_each_unit)
+        eqTextTerm=TextMobject("And so on..!")
+        eqTextTerm.set_color(BLUE)
+        eqTextTerm.scale(0.6)
+        eqTextTerm.shift(ORIGIN+UP*2*y_each_unit+3*RIGHT*x_each_unit)
+        equation1 = self.get_graph(lambda x : 1,color = RED,x_min = -8,x_max=8)
+        equation2 = self.get_graph(lambda x : 1-math.pow(x,2),color = RED,x_min = -1.7,x_max=1.7)
+        equation3 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4),color = RED,x_min = -1.6,x_max=1.6)
+        equation4 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6),color = RED,x_min = -1.45,x_max=1.45)
+        equation5 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8),color = RED,x_min = -1.35,x_max=1.35)
+        equation6 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10),color = RED,x_min = -1.3,x_max=1.3)
+        equation7 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12),color = RED,x_min = -1.25,x_max=1.25)
+        equation8 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14),color = RED,x_min = -1.2,x_max=1.2)
+        equation9 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16),color = RED,x_min = -1.15,x_max=1.15)
+        equation10 = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.15,x_max=1.15)
+
+        textBtwAnim1=TextMobject("Here the graph just","oscilates")
+        textBtwAnim1.set_color_by_tex_to_color_map({"oscilates":BLUE})
+        textBtwAnim2=TextMobject("after","the","point","(as we add higher order terms)")
+        textBtwAnim2.set_color_by_tex_to_color_map({"after":BLUE,"point":YELLOW})
+        textBtwAnim3=TextMobject("$x=1$")
+        textBtwAnim1.scale(0.4)
+        textBtwAnim2.scale(0.4)
+        textBtwAnim3.scale(1.2)
+        textBtwAnim1.shift(2.1*DOWN+4.3*RIGHT)
+        textBtwAnim2.shift(2.4*DOWN+4.1*RIGHT)
+        textBtwAnim3.shift(2.9*DOWN+4.3*RIGHT)
+
+        self.play(ShowCreation(equation1),run_time=0.8)
+        self.add(eqText[0])
+        self.wait(1)
+        self.play(ReplacementTransform(equation1,equation2),ReplacementTransform(eqText[0],eqText[1]))
+        self.wait(0.5)
+        self.play(ReplacementTransform(equation2,equation3),ReplacementTransform(eqText[1],eqText[2]))
+        self.wait(0.4)
+        self.play(ReplacementTransform(equation3,equation4),ReplacementTransform(eqText[2],eqText[3]))
+        self.wait(0.3)
+        self.play(FadeOut(eqText[3]))
+        self.play(FadeIn(eqTextTerm))
+        self.play(Write(textBtwAnim1),Write(textBtwAnim2))
+        self.play(FadeIn(textBtwAnim3))
+        self.play(ReplacementTransform(equation4,equation5))
+        self.wait(0.2)
+        self.play(ReplacementTransform(equation5,equation6))
+        self.wait(0.2)
+        self.play(ReplacementTransform(equation6,equation7))
+        self.wait(0.2)
+        self.play(ReplacementTransform(equation7,equation8))
+        self.wait(0.2)
+        self.play(ReplacementTransform(equation8,equation9))
+        self.wait(0.2)
+        self.play(ReplacementTransform(equation9,equation10))    
+        self.wait(1)
+
+        self.play(FadeOut(textBtwAnim1),FadeOut(textBtwAnim2),FadeOut(textBtwAnim3),FadeOut(equation10),FadeOut(eqTextTerm))
+        self.wait(1)
+        
+        convergeLine=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*RIGHT,color=WHITE)
+        divergeLineLeft=Line(start=ORIGIN+x_each_unit*LEFT,end=ORIGIN+x_each_unit*LEFT*8,color=RED)
+        divergeLineRight=Line(start=ORIGIN+x_each_unit*RIGHT,end=ORIGIN+x_each_unit*8*RIGHT,color=RED)
+        circle1=Circle(radius=0.01,color=PURPLE_E)
+        circle2=Circle(radius=0.01,color=PURPLE_E)
+        circle1.shift(ORIGIN+LEFT*x_each_unit)
+        circle2.shift(ORIGIN+RIGHT*x_each_unit)
+        convergeText=TextMobject("Converges")
+        divergeText1=TextMobject("Diverges")
+        divergeText2=TextMobject("Diverges")
+        convergeText.set_color(GREEN)
+        divergeText1.set_color(RED)
+        divergeText2.set_color(RED)
+        convergeText.scale(0.5)
+        divergeText1.scale(0.5)
+        divergeText2.scale(0.5)
+        convergeText.shift(1.6*UP)
+        divergeText1.shift(0.3*UP+1.5*LEFT)
+        divergeText2.shift(0.3*UP+1.5*RIGHT)
+        self.play(Write(divergeLineLeft),Write(divergeLineRight))
+        self.play(FadeIn(convergeLine))
+        self.wait(0.5)
+        self.play(FadeOut(self.axes))
+        self.play(Write(circle1),Write(circle2))
+        self.wait(0.5)
+        self.play(ApplyMethod(convergeLine.shift,1.3*UP),ApplyMethod(function_expan.shift,5*LEFT+DOWN))
+        self.play(FadeIn(convergeText),FadeIn(divergeText1),FadeIn(divergeText2))
+        self.wait(2)        
+
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/video4_radius_and_intervalOfConvergence.py b/FSF-2020/calculus/series-and-transformations/Power Series/video4_radius_and_intervalOfConvergence.py
new file mode 100644
index 0000000..412d20c
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/video4_radius_and_intervalOfConvergence.py
@@ -0,0 +1,108 @@
+from manimlib.imports import *
+import math
+
+class intro(Scene):
+    def construct(self):
+        introText1=TextMobject("Consider the","above","example..")
+        introText1.scale(0.8)
+        introText1.set_color_by_tex_to_color_map({"above":YELLOW})
+        self.play(Write(introText1))
+        self.wait(1)
+
+class graphScene(GraphScene,MovingCameraScene):
+    CONFIG = {
+        "x_min": -5,
+        "x_max": 5,
+        "y_min": -5,
+        "y_max": 5,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-1, 2, 1),
+        "y_labeled_nums": range(0,2,1),
+        "y_axis_height":7,
+        "x_axis_width":7
+    }
+
+    def setup(self):
+        GraphScene.setup(self)
+        MovingCameraScene.setup(self)
+
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        function_expan=TextMobject("$1-{ x }^{ 2 }+{ x }^{ 4 }-{ x }^{ 6 }+{ x }^{ 8 }+..$")
+        function_expan.scale(0.6)
+        function_expan.set_color(RED)
+        function_expan.to_edge(UP+RIGHT)
+        self.add(function_expan)
+
+        self.setup_axes()
+
+        equation = self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = RED,x_min = -1.1,x_max=1.1)
+        self.play(ShowCreation(equation))
+        self.wait(1)
+
+        dashLineLeft=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN)
+        dashLineRight=DashedLine(start=ORIGIN+y_each_unit*5*UP,end=ORIGIN+y_each_unit*5*DOWN)
+        dashLineLeft.shift(ORIGIN+LEFT*x_each_unit)
+        dashLineRight.shift(ORIGIN+RIGHT*x_each_unit)
+        radiusLine=Line(start=ORIGIN,end=ORIGIN+RIGHT*x_each_unit)
+        rangeLine=Line(start=ORIGIN+LEFT*x_each_unit,end=ORIGIN+RIGHT*x_each_unit)
+        circle=Circle(radius=x_each_unit)
+        movingPoint=Circle(radius=0.025)
+        movingPoint.shift(ORIGIN+RIGHT*x_each_unit)
+        circleEq1=self.get_graph(lambda x:math.sqrt(1-x**2),color=BLUE,x_max=-1,x_min=1)
+        circleEq2=self.get_graph(lambda x:-math.sqrt(1-x**2),color=BLUE,x_max=1,x_min=-1)
+
+        self.play(Write(dashLineLeft),Write(dashLineRight))
+        self.wait(1)
+
+        equation_updated=self.get_graph(lambda x : 1-math.pow(x,2)+math.pow(x,4)-math.pow(x,6)+math.pow(x,8)-math.pow(x,10)+math.pow(x,12)-math.pow(x,14)+math.pow(x,16)-math.pow(x,18),color = GREEN,x_min = -1,x_max=1)
+        self.play(FadeOut(self.axes),ReplacementTransform(equation,equation_updated))
+        self.wait(0.5)
+        self.play(Write(radiusLine))
+        self.play(MoveAlongPath(movingPoint,circleEq1))
+        self.play(MoveAlongPath(movingPoint,circleEq2))
+        self.play(FadeIn(circle))
+        self.wait(1)
+
+        radiusText=TextMobject("Radius of convergence")
+        radiusText.scale(0.14)
+        radiusText.shift(ORIGIN+RIGHT*x_each_unit*0.45+DOWN*y_each_unit*0.2)
+
+        self.play(Write(radiusText))
+        self.wait(0.6)
+
+        self.camera_frame.save_state()
+        self.camera_frame.set_width(5.5)
+        self.play(self.camera_frame.move_to, ORIGIN)
+        self.wait(1)
+        self.camera_frame.set_width(14)
+        self.wait(1.3)
+
+        self.play(FadeOut(radiusText),FadeOut(circle),FadeOut(movingPoint))
+        extendLine=Line(start=ORIGIN,end=ORIGIN+x_each_unit*LEFT)
+        self.play(Write(extendLine))
+        doubleArrow=TextMobject("$\longleftrightarrow$")
+        doubleArrow.scale(1.6)
+        doubleArrow.set_color(BLUE)
+        doubleArrow.shift(ORIGIN+DOWN*y_each_unit*0.5)
+        self.play(FadeIn(doubleArrow))
+        self.wait(1)
+        rangeText=TextMobject("Interval of convergence")
+        rangeText.scale(0.15)
+        rangeText.shift(ORIGIN+y_each_unit*DOWN)
+        self.play(Write(rangeText))
+        self.wait(0.6)
+
+        self.camera_frame.save_state()
+        self.camera_frame.set_width(5.5)
+        self.play(self.camera_frame.move_to, ORIGIN)
+        self.wait(1)
+        self.camera_frame.set_width(14)
+        self.wait(1.5)
diff --git a/FSF-2020/calculus/series-and-transformations/Power Series/video5_UniformConvergence.py b/FSF-2020/calculus/series-and-transformations/Power Series/video5_UniformConvergence.py
new file mode 100644
index 0000000..e9681aa
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Power Series/video5_UniformConvergence.py
@@ -0,0 +1,136 @@
+from manimlib.imports import *
+import math
+
+class uniformlyConvergent(Scene):
+    def construct(self):
+        introText1=TextMobject("Again consider the","above","example")
+        introText2=TextMobject("Let","$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$","and","x=0.5 $\in$(-1,1)")
+        introText3=TextMobject("Lets analyse..","!")
+        introText1.scale(0.8)
+        introText2.scale(0.7)
+        introText3.scale(0.9)
+        introText3.shift(DOWN)
+        introText1.set_color_by_tex_to_color_map({"above":YELLOW})
+        introText2.set_color_by_tex_to_color_map({"$g(x)=\\frac { 1 }{ 1+{ x }^{ 2 } }$":BLUE,"x=0.5 $\in$(-1,1)":YELLOW})
+        introText3.set_color_by_tex_to_color_map({"!":GREEN})
+        self.play(Write(introText1))
+        self.wait(0.5)
+        self.play(FadeOut(introText1))
+        self.play(Write(introText2))
+        self.play(FadeIn(introText3))
+        self.wait(2)
+
+
+def gety(x,n):
+    ans=0
+    for i in range(0,n+1):
+        if(i%2==0):
+            ans+=(math.pow(x,2*i))
+        else:
+            ans-=(math.pow(x,2*i))
+    return ans
+
+def makeSeries(x,points,x_each_unit,y_each_unit):
+    p=0
+    for point in points:
+        y=gety(x,p)
+        point.shift(ORIGIN+RIGHT*x_each_unit*p+UP*y_each_unit*y)
+        p+=1
+
+def makeLines(x,numPoints,x_each_unit,y_each_unit):
+    lines=[0]*numPoints
+    for i in range(0,numPoints-1):
+        y=gety(x,i)
+        y_next=gety(x,i+1)
+        lines[i]=Line(start=ORIGIN+RIGHT*x_each_unit*i+UP*y_each_unit*y,end=ORIGIN+RIGHT*x_each_unit*(i+1)+UP*y_each_unit*y_next,color=RED)
+    return lines
+
+class graphScene(GraphScene,MovingCameraScene):
+    CONFIG = {
+        "x_min": -6,
+        "x_max": 6,
+        "y_min": -5,
+        "y_max": 5,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$k$",
+        "y_axis_label": "$f(\\frac{1}{2})_k$",
+        "exclude_zero_label": True,
+        "x_axis_width":7,
+        "y_axis_height":7    
+    }
+    
+    def setup(self):
+        GraphScene.setup(self)
+        MovingCameraScene.setup(self)
+
+
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+        sequence=TextMobject("$1$ , $1-(0.5)^2$ , $1-(0.5)^2+(0.5)^4..$")
+        sequence.set_color(RED)
+        sequence.scale(0.35)
+        sequence.to_edge(UP+RIGHT)
+        formula=TextMobject("$f(x)_{ k }=\sum _{ i=0 }^{ k }{ (-1)^{ i }(x)^{ 2i } } $")
+        formula.set_color(PURPLE_C)
+        formula.scale(0.4)
+        formula.shift(5.3*RIGHT+3*UP)
+        fLine=Line(start=ORIGIN+x_each_unit*6*LEFT,end=ORIGIN+x_each_unit*6*RIGHT)
+        fLine.shift(ORIGIN+(4/5)*y_each_unit*UP)
+        fLineText=TextMobject("$g(0.5)=\\frac { 4 }{ 5 } $")
+        fLineText.set_color(RED)
+        fLineText.scale(0.3)
+        fLineText.shift(UP*1.2*y_each_unit+RIGHT*x_each_unit+4*LEFT)
+        points=[Dot(radius=0.03,color=BLUE) for i in range(0,6)]
+        makeSeries(0.5,points,x_each_unit,y_each_unit)
+        lines=makeLines(0.5,6,x_each_unit,y_each_unit)
+
+
+        self.add(sequence)
+        self.add(formula)
+        self.setup_axes(animate=True)
+        self.play(Write(fLine))
+        self.add(fLineText)
+        for p in points:
+            self.add(p)
+        for p in range(0,5):
+            self.play(Write(lines[p]))
+        self.wait(0.5)
+        self.camera_frame.save_state()
+        self.camera_frame.set_width(0.6)
+        self.play(self.camera_frame.move_to, points[0])
+        self.wait(0.4)
+        self.play(self.camera_frame.move_to, points[1])
+        self.wait(0.4)
+        self.play(self.camera_frame.move_to, points[2])
+        self.wait(0.3)
+        self.play(self.camera_frame.move_to, points[3])
+        self.wait(1)
+        self.play(self.camera_frame.move_to,ORIGIN)
+        self.camera_frame.set_width(14)
+        self.wait(1)
+
+        explanation1=TextMobject("Since the series","converges","to")
+        explanation1.set_color_by_tex_to_color_map({"converges":YELLOW})
+        explanation2=TextMobject("$\\frac {4}{5}$")
+        explanation2.set_color(BLUE)
+        explanation3=TextMobject("Hence","$\\forall \epsilon>0$,","$\exists k$","such that,")
+        explanation3.set_color_by_tex_to_color_map({"$\\forall \epsilon>0$":BLUE,"$\exists k$":YELLOW})
+        explanation4=TextMobject("$\left| { f\left( \\frac { 1 }{ 2 }  \\right)  }_{ k }-\\frac { 4 }{ 5 }  \\right| <$","$\epsilon$")
+        explanation4.set_color_by_tex_to_color_map({"$\epsilon$":RED})
+        explanation1.scale(0.5)
+        explanation3.scale(0.5)
+        explanation1.shift(1.8*DOWN+3.5*RIGHT)
+        explanation2.shift(2.4*DOWN+3.5*RIGHT)
+        explanation3.shift(1.8*DOWN+3.5*RIGHT)
+        explanation4.shift(2.4*DOWN+3.5*RIGHT)
+
+        self.play(Write(explanation1))
+        self.play(FadeIn(explanation2))
+        self.wait(1)
+        self.play(FadeOut(explanation1),FadeOut(explanation2))
+        self.play(Write(explanation3))
+        self.play(Write(explanation4))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/README.md b/FSF-2020/calculus/series-and-transformations/README.md
new file mode 100644
index 0000000..4747205
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/README.md
@@ -0,0 +1,13 @@
+Contributer: <b>G Sri Harsha</b>

+

+GitHub Handle: <a href="https://github.com/GSri30/">GSri30</a>

+

+Sub-Topics Covered: 

+                    <ul>

+                      <li>Power Series

+                      <li>Taylor Series

+                      <li>Laplace Transformation

+                      <li>Fourier Transformation

+                      <li>z-Transform

+                      <li>Constant-Q transform

+                    </ul>

diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/README.md b/FSF-2020/calculus/series-and-transformations/Taylor Series/README.md
new file mode 100644
index 0000000..ce3b088
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/README.md
@@ -0,0 +1,11 @@
+#### Example of Taylors expansion
+![GIF1](gifs/file1_Example_TaylorExpansion.gif)
+
+#### Taylor Series GeneralForm
+![GIF2](gifs/file2_TaylorExpansionGeneralForm.gif)
+
+#### Radius Of Convergence
+![GIF3](gifs/file3_radiusOfConvergence.gif)
+
+#### Divergence of a Remainder
+![GIF4](gifs/file4_DivergentRemainder.gif)
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf
new file mode 100644
index 0000000..46d46e1
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/TaylorSeriesQuestions.pdf
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file1_Example_TaylorExpansion.gif b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file1_Example_TaylorExpansion.gif
new file mode 100644
index 0000000..ecd3272
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file1_Example_TaylorExpansion.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file2_TaylorExpansionGeneralForm.gif b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file2_TaylorExpansionGeneralForm.gif
new file mode 100644
index 0000000..e6d9171
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file2_TaylorExpansionGeneralForm.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file3_radiusOfConvergence.gif b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file3_radiusOfConvergence.gif
new file mode 100644
index 0000000..6b22d8d
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file3_radiusOfConvergence.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file4_DivergentRemainder.gif b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file4_DivergentRemainder.gif
new file mode 100644
index 0000000..2bb5185
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/gifs/file4_DivergentRemainder.gif
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/video1_Example_TaylorExpansion.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/video1_Example_TaylorExpansion.py
new file mode 100644
index 0000000..e83eff8
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/video1_Example_TaylorExpansion.py
@@ -0,0 +1,198 @@
+from manimlib.imports import*
+import math
+
+def formFormula(coeff_list,variable_list):
+    coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")]
+    variable_list=[TextMobject("+"),TextMobject("${ x }$+"),TextMobject("${ x }^{ 2 }$")]
+    coeff_list[0].shift(2.2*UP+1.6*LEFT)    
+    for i in range(0,3):
+        coeff_list[i].set_color(GOLD_A)
+        variable_list[i].next_to(coeff_list[i],buff=0.1)
+        if i!=2:
+            coeff_list[i+1].next_to(variable_list[i],buff=0.1)
+    dots=TextMobject("...")
+    dots.next_to(variable_list[2])
+    expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots)
+    #expansion.scale(0.7)
+    return expansion,coeff_list
+
+class intro(Scene):
+    def construct(self):
+        equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$")
+        equation.scale(2)
+        equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED})
+        text=TextMobject("let $a=0$")
+        text.scale(0.7)
+        text.shift(DOWN)
+
+        self.play(Write(equation))
+        self.wait(0.5)
+        self.play(FadeIn(text))
+        self.wait(0.7)
+        self.play(FadeOut(equation),FadeOut(text))
+
+class graphScene(GraphScene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -8,
+        "y_max": 8,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-8, 8, 1),
+    }
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)   
+
+        generalized_eq_coeff=[]
+        variables_eq=[]
+        eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq)
+        trText1=TextMobject("let $T_{ n }(x)$:=")
+        eq.next_to(trText1)
+        trTextGrup=VGroup(trText1,eq)
+        trTextGrup.scale(0.5)
+        trTextGrup.to_corner(UP+RIGHT)
+        self.play(Write(trTextGrup))
+        self.setup_axes(animate=True)
+        
+        fx=TextMobject("${ e }^{ -x^{ 2 } }$")
+        fx.scale(0.5)
+        fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP)
+        mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8)
+        self.play(ShowCreation(mainfunction))
+        self.play(FadeIn(fx))
+        self.wait(1.4)
+
+        coeff=[TextMobject("$1$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")]
+        coeff[0].shift(3.39*UP+4.88*RIGHT)
+        coeff[0].scale(0.5)
+        coeff[1].shift(3.39*UP+5.3*RIGHT)
+        coeff[1].scale(0.275)
+        coeff[2].shift(3.39*UP+5.98*RIGHT)
+        coeff[2].scale(0.28)
+
+        for obj in coeff:
+            obj.set_color(GOLD_A)
+
+        firstApprox=[self.get_graph(lambda x:1,color=BLUE)]
+        secondApprox=[self.get_graph(lambda x:1,color=BLUE),
+                    self.get_graph(lambda x:x+1,color=BLUE),
+                    self.get_graph(lambda x:-x+1,color=BLUE)]
+        thirdApprox=[self.get_graph(lambda x:1-2*math.pow(x,2),color=BLUE),
+                    self.get_graph(lambda x:1-0.1*math.pow(x,2),color=BLUE),
+                    self.get_graph(lambda x:1,color=BLUE),
+                    self.get_graph(lambda x:1+0.1*math.pow(x,2),color=BLUE),
+                    self.get_graph(lambda x:1+math.pow(x,2),color=BLUE)]
+                    
+        firstGraph=self.get_graph(lambda x:1,color=BLUE)
+        secondGraph=self.get_graph(lambda x:1-math.pow(x,2),color=BLUE)
+
+        bottomText1=TextMobject("The polynomial should","satisfy","the function at $x=0$")
+        bottomText2=TextMobject("This gives","$a_{ 0 }=1$")
+        bottomText3=TextMobject("Now it could be of","any slope!")
+        #show graphs of second approx
+        bottomText4=TextMobject("Hence the","slopes","should","even match")
+        #final graph
+        bottomText5=TextMobject("This gives","$a_{ 1 }=0$")
+        bottomText6=TextMobject("Since the rate of change of this slope","could vary")
+        #show third approx graphs
+        bottomText7=TextMobject("Hence the","rate of change of these slopes","should also be","same!")
+        #final graph
+        bottomText8=TextMobject("This gives","$a_{ 2 }=-1$")
+
+        bottomText1.set_color_by_tex_to_color_map({"satisfy":YELLOW})
+        bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=1$":BLUE})
+        bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW})
+        bottomText4.set_color_by_tex_to_color_map({"slopes":BLUE,"even match":YELLOW})
+        bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=0$":BLUE})
+        bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW})
+        bottomText7.set_color_by_tex_to_color_map({"rate of change of these slopes":BLUE,"same!":YELLOW})
+        bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=-1$":BLUE})
+
+        bottomText1.scale(0.4)
+        bottomText2.scale(0.5)
+        bottomText3.scale(0.4)
+        bottomText4.scale(0.4)
+        bottomText5.scale(0.5)
+        bottomText6.scale(0.4)
+        bottomText7.scale(0.4)
+        bottomText8.scale(0.5)
+
+        bottomText1.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText2.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText3.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText4.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText5.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText6.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText7.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText8.shift(4.5*RIGHT+2.5*DOWN)
+
+        self.play(Write(bottomText1))
+        self.wait(1)
+        self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2))
+        #change coeff in tn(x)
+        self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0]))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText2,bottomText3))
+        self.wait(0.5)
+        self.play(ReplacementTransform(firstApprox[0],secondApprox[1]))
+        self.wait(0.5)
+        self.play(ReplacementTransform(secondApprox[1],secondApprox[0]))
+        self.wait(0.5)
+        self.play(ReplacementTransform(secondApprox[0],secondApprox[2]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2]))
+        self.wait(1)
+        self.play(Write(firstGraph),ReplacementTransform(bottomText4,bottomText5))
+        #change a1 coeff
+        self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1]))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText5,bottomText6))
+        self.play(ReplacementTransform(firstGraph,thirdApprox[0]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[2],thirdApprox[3]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4]))       
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText6,bottomText7))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],secondGraph))
+        self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2]))
+        self.wait(2)
+
+        textFinal=TextMobject("And so on..!")
+        textFinal.scale(0.7)
+        textFinal.shift(4.5*RIGHT+2.5*DOWN)
+        self.play(ReplacementTransform(bottomText8,textFinal))
+        self.wait(2.5)
+
+        finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$")
+        finalFormula.scale(0.8)
+        finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(0)+f'(0)x+\\frac { f''(0) }{ 2! }x^2+..+\\frac { { f }^{ n }(0) }{ n! } { x }^{ n }$":RED})        
+
+        self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(secondGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2]))
+        self.play(Write(finalFormula))
+        self.wait(2)
+        # self.play(ReplacementTransform(secondApprox[2],secondApprox[3]))
+        # self.wait(0.5)
+        # self.play(ReplacementTransform(secondApprox[3],secondApprox[4]))
+        # self.wait(0.5)
+        # self.play(ReplacementTransform(secondApprox[4],secondApprox[5]))
+        # self.wait(0.5)
+        # self.play(ReplacementTransform(secondApprox[0],secondApprox[0]))
+        # self.wait(0.5)
+        # self.play(ReplacementTransform(secondApprox[0],secondApprox[0]))
+        # self.wait(0.5)
+
+
+
+
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/video2_TaylorExpansionGeneralForm.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/video2_TaylorExpansionGeneralForm.py
new file mode 100644
index 0000000..f84cfe9
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/video2_TaylorExpansionGeneralForm.py
@@ -0,0 +1,195 @@
+from manimlib.imports import*
+import math
+
+
+class intro(Scene):
+    def construct(self):
+        equation=TextMobject("$f(x)=$","${ e }^{ -x^{ 2 } }$")
+        equation.scale(2)
+        equation.set_color_by_tex_to_color_map({"${ e }^{ -x^{ 2 } }$":RED})
+        text=TextMobject("at $a=1$")
+        text.scale(0.7)
+        text.shift(DOWN)
+
+        shiftText=TextMobject("(Here we shift the origin to the point $x=1$)")
+        shiftText.scale(0.6)
+        shiftText.shift(2.4*DOWN)
+
+
+        self.play(Write(equation))
+        self.wait(0.5)
+        self.play(FadeIn(text))
+        self.wait(0.7)
+        self.play(Write(shiftText))
+        self.wait(0.7)
+        self.play(FadeOut(equation),FadeOut(text),FadeOut(shiftText))
+
+
+def formFormula(coeff_list,variable_list):
+    coeff_list=[TextMobject("${ a }_{ 0 }$"),TextMobject("${ a }_{ 1 }$"),TextMobject("${ a }_{ 2 }$")]
+    variable_list=[TextMobject("+"),TextMobject("${ (x-1) }$+"),TextMobject("${ (x-1) }^{ 2 }$")]
+    coeff_list[0].shift(2.2*UP+1.6*LEFT)    
+    for i in range(0,3):
+        coeff_list[i].set_color(GOLD_A)
+        variable_list[i].next_to(coeff_list[i],buff=0.1)
+        if i!=2:
+            coeff_list[i+1].next_to(variable_list[i],buff=0.1)
+    dots=TextMobject("...")
+    dots.next_to(variable_list[2])
+    expansion=VGroup(coeff_list[0],coeff_list[1],coeff_list[2],variable_list[0],variable_list[1],variable_list[2],dots)
+    #expansion.scale(0.7)
+    return expansion,coeff_list
+
+
+class graphScene(GraphScene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -8,
+        "y_max": 8,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-8, 8, 1),
+    }
+    def construct(self):
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)   
+
+        generalized_eq_coeff=[]
+        variables_eq=[]
+        eq,generalized_eq_coeff=formFormula(generalized_eq_coeff,variables_eq)
+        trText1=TextMobject("let $T_{ n }(x)$:=")
+        eq.next_to(trText1)
+        trTextGrup=VGroup(trText1,eq)
+        trTextGrup.scale(0.5)
+        trTextGrup.to_corner(UP+RIGHT)
+        self.play(Write(trTextGrup))
+        self.setup_axes(animate=True)
+        
+        fx=TextMobject("${ e }^{ -x^{ 2 } }$")
+        fx.scale(0.5)
+        fx.shift(ORIGIN+x_each_unit*7.5*RIGHT+y_each_unit*0.5*UP)
+        mainfunction=self.get_graph(lambda x:math.exp(-1*pow(x,2)),color=RED,x_min=-8,x_max=8)
+        self.play(ShowCreation(mainfunction))
+        self.play(FadeIn(fx))
+        self.wait(1.4)
+
+        coeff=[TextMobject("$e^{-1}$"),TextMobject("$f'(x)$"),TextMobject("$\\frac { f''(x) }{ 2! } $")]
+        coeff[0].shift(3.33*UP+3.65*RIGHT)
+        coeff[0].scale(0.45)
+        coeff[1].shift(3.33*UP+4.13*RIGHT)
+        coeff[1].scale(0.275)
+        coeff[2].shift(3.33*UP+5.36*RIGHT)
+        coeff[2].scale(0.28)
+
+        for obj in coeff:
+            obj.set_color(GOLD_A)
+
+        firstApprox=[self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)]
+        secondApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5),
+                    self.get_graph(lambda x:math.exp(-1)+3*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5),
+                    self.get_graph(lambda x:math.exp(-1)-4*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)]
+        thirdApprox=[self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5),
+                    self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)-0.1*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5),
+                    self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_max=5.5,x_min=-5.5),
+                    self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+0.5*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5),
+                    self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+2*math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5)]
+                    
+        firstGraph=self.get_graph(lambda x:math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)
+        secondGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1),color=BLUE,x_min=-5.5,x_max=5.5)
+        thirdGraph=self.get_graph(lambda x:math.exp(-1)-2*(x-1)*math.exp(-1)+math.exp(-1)*(x-1)**2,color=BLUE,x_max=5.5,x_min=-5.5)
+
+        bottomText1=TextMobject("Apply","$f(1)=T_{n}(1)$")
+        bottomText2=TextMobject("This gives","$a_{ 0 }=e^{-1}$")
+        bottomText3=TextMobject("Now it could be of","any slope!")
+        #show graphs of second approx
+        bottomText4=TextMobject("Hence","apply","$f'(1)=T_{n}'(1)$")
+        #final graph
+        bottomText5=TextMobject("This gives","$a_{ 1 }=-2e^{-1}$")
+        bottomText6=TextMobject("Since the rate of change of this slope","could vary")
+        #show third approx graphs
+        bottomText7=TextMobject("Hence also","apply","$f''(1)=T_{ n }''(1)$")
+        #final graph
+        bottomText8=TextMobject("This gives","$a_{ 2 }=e^{-1}$")
+
+        bottomText1.set_color_by_tex_to_color_map({"Apply":YELLOW})
+        bottomText2.set_color_by_tex_to_color_map({"$a_{ 0 }=e^{-1}$":BLUE})
+        bottomText3.set_color_by_tex_to_color_map({"any slope!":YELLOW})
+        bottomText4.set_color_by_tex_to_color_map({"apply":YELLOW})
+        bottomText5.set_color_by_tex_to_color_map({"$a_{ 1 }=-2e^{-1}$":BLUE})
+        bottomText6.set_color_by_tex_to_color_map({"could vary":YELLOW})
+        bottomText7.set_color_by_tex_to_color_map({"apply":YELLOW})
+        bottomText8.set_color_by_tex_to_color_map({"$a_{ 2 }=e^{-1}$":BLUE})
+
+        bottomText1.scale(0.4)
+        bottomText2.scale(0.5)
+        bottomText3.scale(0.4)
+        bottomText4.scale(0.4)
+        bottomText5.scale(0.5)
+        bottomText6.scale(0.4)
+        bottomText7.scale(0.4)
+        bottomText8.scale(0.5)
+
+        bottomText1.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText2.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText3.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText4.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText5.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText6.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText7.shift(4.5*RIGHT+2.5*DOWN)
+        bottomText8.shift(4.5*RIGHT+2.5*DOWN)
+
+        self.play(Write(bottomText1))
+        self.wait(1)
+        self.play(ShowCreation(firstApprox[0]),ReplacementTransform(bottomText1,bottomText2))
+        #change coeff in tn(x)
+        self.play(ReplacementTransform(generalized_eq_coeff[0],coeff[0]))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText2,bottomText3))
+        self.wait(0.5)
+        self.play(ReplacementTransform(firstApprox[0],secondApprox[1]))
+        self.wait(0.5)
+        self.play(ReplacementTransform(secondApprox[1],secondApprox[2]))
+        # self.wait(0.5)
+        # self.play(ReplacementTransform(secondApprox[2],secondApprox[0]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText3,bottomText4),FadeOut(secondApprox[2]))
+        self.wait(1)
+        self.play(Write(secondGraph),ReplacementTransform(bottomText4,bottomText5))
+        #change a1 coeff
+        self.play(ReplacementTransform(generalized_eq_coeff[1],coeff[1]))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText5,bottomText6))
+        self.play(ReplacementTransform(secondGraph,thirdApprox[0]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[0],thirdApprox[1]))
+        # self.wait(0.6)
+        # self.play(ReplacementTransform(thirdApprox[1],thirdApprox[2]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[1],thirdApprox[3]))
+        self.wait(0.6)
+        self.play(ReplacementTransform(thirdApprox[3],thirdApprox[4]))       
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText6,bottomText7))
+        self.wait(1.5)
+        self.play(ReplacementTransform(bottomText7,bottomText8),ReplacementTransform(thirdApprox[4],thirdGraph))
+        self.play(ReplacementTransform(generalized_eq_coeff[2],coeff[2]))
+        self.wait(2)
+
+        textFinal=TextMobject("And so on..!")
+        textFinal.scale(0.7)
+        textFinal.shift(4.5*RIGHT+2.5*DOWN)
+        self.play(ReplacementTransform(bottomText8,textFinal))
+        self.wait(2.5)
+
+        finalFormula=TextMobject("Hence","$T_{ n }(x)$","=","$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$")
+        finalFormula.scale(0.8)
+        finalFormula.set_color_by_tex_to_color_map({"$T_{ n }(x)$":GREEN,"$f(1)+f'(1)(x-1)+\\frac { f''(1) }{ 2! }(x-1)^2+..+\\frac { { f }^{ n }(1) }{ n! } { (x-1) }^{ n }$":RED})        
+
+        self.play(FadeOut(self.axes),FadeOut(textFinal),FadeOut(thirdGraph),FadeOut(trTextGrup),FadeOut(mainfunction),FadeOut(fx),FadeOut(coeff[0]),FadeOut(coeff[1]),FadeOut(coeff[2]))
+        self.play(Write(finalFormula))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/video3_radiusOfConvergence.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/video3_radiusOfConvergence.py
new file mode 100644
index 0000000..a68afb6
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/video3_radiusOfConvergence.py
@@ -0,0 +1,111 @@
+from manimlib.imports import*
+import math
+
+
+class graphScene(GraphScene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -8,
+        "y_max": 8,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-8, 8, 1),
+    }
+    def construct(self):
+
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+        
+        self.setup_axes(animate=True)
+
+        lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8)
+
+        bottomText1=TextMobject("Apply $f(x)=T_{n}(x)$")
+        bottomText2=TextMobject("Then apply $f'(x)=T_{n}'(x)$")
+        bottomText3=TextMobject("Then apply $f''(x)=T_{n}''(x)$")
+        bottomText4=TextMobject("and so on..")
+
+        bottomText1.scale(0.5)
+        bottomText2.scale(0.5)
+        bottomText3.scale(0.5)
+        bottomText4.scale(0.5)
+
+        bottomText1.shift(3*RIGHT+2*DOWN)
+        bottomText2.shift(3*RIGHT+2*DOWN)
+        bottomText3.shift(3*RIGHT+2*DOWN)
+        bottomText4.shift(3*RIGHT+2*DOWN)
+
+        equations=[self.get_graph(lambda x:math.log2(2),color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2,color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8,color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24,color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64,color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160,color=BLUE),
+                    self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE)]
+        
+        terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")]
+        for obj in terms:
+            obj.scale(0.5)
+        
+        terms[0].shift(3*UP+3*RIGHT)
+        terms[1].next_to(terms[0],buff=0.1)
+        terms[2].next_to(terms[1],buff=0.1)
+        terms[3].next_to(terms[2],buff=0.1)
+        terms[4].next_to(terms[3],buff=0.1)
+
+        self.play(ShowCreation(lnx))
+        self.wait(1)
+        self.play(Write(bottomText1))
+        self.wait(0.5)
+        self.play(ShowCreation(equations[0]),Write(terms[0]),Write(terms[1]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText1,bottomText2))
+        self.wait(0.5)
+        self.play(ReplacementTransform(equations[0],equations[1]),Write(terms[2]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText2,bottomText3))
+        self.wait(0.5)
+        self.play(ReplacementTransform(equations[1],equations[2]),Write(terms[3]))
+        self.wait(1)
+        self.play(ReplacementTransform(bottomText3,bottomText4),Write(terms[4]))
+        self.wait(1.5)
+        
+        self.play(FadeOut(terms[0]),FadeOut(terms[1]),FadeOut(terms[2]),FadeOut(terms[3]),FadeOut(terms[4]),FadeOut(bottomText4))
+        
+        dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN)
+        dline.shift(ORIGIN+x_each_unit*4*RIGHT)
+
+        bottomText5=TextMobject("Here","after $x=4$",", the graph","continuously diverges away","from $ln(x)$")
+        bottomText5.scale(0.3)
+        bottomText5.shift(4.5*RIGHT+2*DOWN)
+        bottomText5.set_color_by_tex_to_color_map({"after $x=4$":YELLOW,"continuously diverges away":BLUE})
+
+        self.play(Write(bottomText5),Write(dline))
+        self.wait(1)
+        self.play(ReplacementTransform(equations[2],equations[3]))
+        self.wait(0.3)
+        self.play(ReplacementTransform(equations[3],equations[4]))
+        self.wait(0.3)
+        self.play(ReplacementTransform(equations[4],equations[5]))
+        self.wait(0.3)
+        self.play(ReplacementTransform(equations[5],equations[6]),FadeOut(bottomText5))
+        self.wait(1)
+
+        circle=Circle(radius=ORIGIN+x_each_unit*2,color=PURPLE_E)
+        circle.shift(ORIGIN+RIGHT*x_each_unit*2)
+        radiusLine=Line(start=ORIGIN+x_each_unit*RIGHT*2,end=ORIGIN+x_each_unit*4*RIGHT,color=PURPLE_E)
+        radius=TextMobject("$R$")
+        radius.set_color(RED)
+        radius.scale(0.5)
+        radius.shift(ORIGIN+RIGHT*x_each_unit*2.45+DOWN*y_each_unit*0.6)
+
+        self.play(FadeOut(equations[6]),Write(circle))
+        self.wait(0.6)
+        self.play(Write(radiusLine))
+        self.play(FadeIn(radius))
+        self.wait(2)
diff --git a/FSF-2020/calculus/series-and-transformations/Taylor Series/video4_DivergentRemainder.py b/FSF-2020/calculus/series-and-transformations/Taylor Series/video4_DivergentRemainder.py
new file mode 100644
index 0000000..5389039
--- /dev/null
+++ b/FSF-2020/calculus/series-and-transformations/Taylor Series/video4_DivergentRemainder.py
@@ -0,0 +1,82 @@
+from manimlib.imports import*
+import math
+
+
+class graphScene(GraphScene):
+    CONFIG = {
+        "x_min": -8,
+        "x_max": 8,
+        "y_min": -8,
+        "y_max": 8,
+        "graph_origin": ORIGIN,
+        "function_color": RED,
+        "axes_color": GREEN,
+        "x_axis_label": "$x$",
+        "y_axis_label": "$y$",
+        "exclude_zero_label": True,
+        "x_labeled_nums": range(-8, 8, 1),
+    }
+    def construct(self):
+
+        x_each_unit = self.x_axis_width / (self.x_max - self.x_min)
+        y_each_unit = self.y_axis_height / (self.y_max - self.y_min)
+
+        self.setup_axes(animate=True)
+        lnx=self.get_graph(lambda x:math.log2(x),color=RED,x_min=0.01,x_max=8)
+        equation=self.get_graph(lambda x:math.log2(2)+(x-2)/2-((x-2)**2)/8+((x-2)**3)/24-((x-2)**4)/64+((x-2)**5)/160-((x-2)**6)/384,color=BLUE)
+
+        terms=[TextMobject("$T_{n}:=$"),TextMobject("$ln(2)$"),TextMobject("$+\\frac { x-2 }{ 2 } $"),TextMobject("$-\\frac { (x-2)^{2} }{ 8 }$"),TextMobject("+..")]
+        for obj in terms:
+            obj.scale(0.5)
+        
+        terms[0].shift(3*UP+3*RIGHT)
+        terms[1].next_to(terms[0],buff=0.1)
+        terms[2].next_to(terms[1],buff=0.1)
+        terms[3].next_to(terms[2],buff=0.1)
+        terms[4].next_to(terms[3],buff=0.1)
+
+        self.play(ShowCreation(lnx))
+        self.wait(1)
+        self.play(FadeIn(equation),FadeIn(terms[0]),FadeIn(terms[1]),FadeIn(terms[2]),FadeIn(terms[3]),FadeIn(terms[4]))
+        self.wait(1)
+
+        bottomText1=TextMobject("$R_{n}(x)=\\frac { d }{ dx } ($","area bounded","$)$")
+
+        bottomText1.set_color_by_tex_to_color_map({"area bounded":ORANGE})
+        #bottomText2.set_color_by_tex_to_color_map({"area bounded":BLUE})
+        arrow=TextMobject("$\downarrow$")
+        arrow.scale(2.5)
+        arrow.shift(ORIGIN+x_each_unit*RIGHT*9.5+UP*y_each_unit)
+        increasingText=TextMobject("Increases!")
+        increasingText.set_color(GREEN)
+        followupText=TextMobject("as n increase!")
+        followupText.scale(0.3)
+        followupText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.1)
+        increasingText.shift(ORIGIN+x_each_unit*11*RIGHT+UP*y_each_unit*1.6)
+        increasingText.scale(0.4)
+
+        bottomText1.scale(0.5)
+        #bottomText2.scale(0.5)
+        #bottomText3.scale(0.5)
+
+        bottomText1.shift(3.5*LEFT+2*DOWN)
+        #bottomText2.shift(3.5*LEFT+2.4*DOWN)
+        #bottomText3.shift(3.5*LEFT+2.8*DOWN)
+
+        dline=DashedLine(start=ORIGIN+8*y_each_unit*UP,end=ORIGIN+8*y_each_unit*DOWN)
+        dline.shift(ORIGIN+x_each_unit*4*RIGHT)
+
+        area1=self.get_riemann_rectangles(lnx,x_max=8,x_min=4,dx=0.01,start_color=BLUE,end_color=RED,stroke_width=0,fill_opacity=0.8)
+        area2=self.get_riemann_rectangles(equation,x_max=5.2,x_min=4,dx=0.025,start_color=BLACK,end_color=BLACK,stroke_width=0,fill_opacity=1)
+
+        self.play(Write(dline))
+        self.wait(0.5)
+        self.play(ShowCreation(area1),ShowCreation(area2),Write(bottomText1))
+        # self.play(Write(bottomText2))
+        # self.play(FadeIn(bottomText3))
+        self.play(Write(arrow))
+        self.wait(0.7)
+        self.play(Write(increasingText))
+        self.play(FadeIn(followupText))
+        self.wait(2)
+