diff --git a/.DS_Store b/.DS_Store
index 3e2b0bd..7373d0b 100644
Binary files a/.DS_Store and b/.DS_Store differ
diff --git a/Sans titre b/Carla/carla.py
similarity index 100%
rename from Sans titre
rename to Carla/carla.py
diff --git a/Screen Recording.py b/Detection/Screen Recording.py
similarity index 100%
rename from Screen Recording.py
rename to Detection/Screen Recording.py
diff --git a/Detection/camera opencv.py b/Detection/camera opencv.py
new file mode 100644
index 0000000..d8e8a31
--- /dev/null
+++ b/Detection/camera opencv.py	
@@ -0,0 +1,24 @@
+import cv2
+cap = cv2.VideoCapture(0)
+print(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+print(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+cap.set(3, 3000)
+cap.set(4, 3000)
+
+print(cap.get(3))
+print(cap.get(4))
+while(cap.isOpened()):
+    ret, frame = cap.read()
+    if ret == True:
+
+       gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+       cv2.imshow('frame', gray)
+
+       if cv2.waitKey(1) & 0xFF == ord('q'):
+         break
+    else:
+        break
+
+cap.release()
+cv2.destroyAllWindows()
diff --git a/detect_circles.py b/Detection/detect_circles copie.py
similarity index 100%
rename from detect_circles.py
rename to Detection/detect_circles copie.py
diff --git a/Detection/opencv camera in pygame.py b/Detection/opencv camera in pygame.py
new file mode 100644
index 0000000..b55dfed
--- /dev/null
+++ b/Detection/opencv camera in pygame.py	
@@ -0,0 +1,29 @@
+import pygame
+from pygame.locals import *
+import cv2
+import numpy as np
+import sys
+
+camera = cv2.VideoCapture(0)
+pygame.init()
+pygame.display.set_caption("OpenCV camera stream on Pygame")
+screen = pygame.display.set_mode([1280,720])
+
+try:
+    while True:
+
+        ret, frame = camera.read()
+
+        screen.fill([0,0,0])
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        frame = np.rot90(frame)
+        frame = pygame.surfarray.make_surface(frame)
+        screen.blit(frame, (0,0))
+        pygame.display.update()
+
+        for event in pygame.event.get():
+            if event.type == KEYDOWN:
+                sys.exit(0)
+except (KeyboardInterrupt,SystemExit):
+    pygame.quit()
+    cv2.destroyAllWindows()
diff --git a/opencv test.py b/Detection/opencv test.py
similarity index 100%
rename from opencv test.py
rename to Detection/opencv test.py
diff --git a/email test 2.py b/Email/email test 2.py
similarity index 100%
rename from email test 2.py
rename to Email/email test 2.py
diff --git a/Fox Snow Dive - Yellowstone - BBC Two-dP15zlyra3c.mp4.part b/Fox Snow Dive - Yellowstone - BBC Two-dP15zlyra3c.mp4.part
deleted file mode 100644
index bb0317d..0000000
Binary files a/Fox Snow Dive - Yellowstone - BBC Two-dP15zlyra3c.mp4.part and /dev/null differ
diff --git a/Hanoi Towers.py b/HackerRank/Hanoi Towers.py
similarity index 100%
rename from Hanoi Towers.py
rename to HackerRank/Hanoi Towers.py
diff --git a/hackerrank magic square.py b/HackerRank/hackerrank magic square.py
similarity index 100%
rename from hackerrank magic square.py
rename to HackerRank/hackerrank magic square.py
diff --git a/Image Processing/hough circles.py b/Image Processing/hough circles.py
new file mode 100644
index 0000000..bff1833
--- /dev/null
+++ b/Image Processing/hough circles.py	
@@ -0,0 +1,26 @@
+import cv2
+import numpy as np
+
+sj="saint jalm.jpg"
+vl="valentin.png"
+tm="tetedemarc.png"
+pm="profiledemarc.jpg"
+
+img = cv2.imread(tm,0)
+img = cv2.medianBlur(img,5)
+img = cv2.Canny(img,50,150)
+cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)
+
+circles = cv2.HoughCircles(img,cv2.HOUGH_GRADIENT,1,20,
+                            param1=50,param2=30,minRadius=0,maxRadius=200)
+
+circles = np.uint16(np.around(circles))
+for i in circles[0,:]:
+    # draw the outer circle
+    cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
+    # draw the center of the circle
+    cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)
+
+cv2.imshow('detected circles',cimg)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
diff --git a/Image Processing/hough lines.py b/Image Processing/hough lines.py
new file mode 100644
index 0000000..036d3b4
--- /dev/null
+++ b/Image Processing/hough lines.py	
@@ -0,0 +1,18 @@
+import cv2
+import numpy as np
+
+sj="saint jalm.jpg"
+vl="valentin.png"
+tm="tetedemarc.png"
+pm="profiledemarc.jpg"
+
+img = cv2.imread(tm)
+gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
+edges = cv2.Canny(gray,50,150,apertureSize = 3)
+minLineLength = 100
+maxLineGap = 10
+lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)
+for (x1,y1,x2,y2) in lines[0]:
+    cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)
+
+cv2.imwrite('houghlines5.jpg',img)
diff --git a/Lovinsky/lovinsky tuto.py b/Lovinsky/lovinsky tuto.py
new file mode 100644
index 0000000..74fe87c
--- /dev/null
+++ b/Lovinsky/lovinsky tuto.py	
@@ -0,0 +1,4 @@
+level=0
+
+while not (level in [1,2,3]):
+    level=int(input("Sélectionner votre level:"))
diff --git a/Lovinsky/morpions.py b/Lovinsky/morpions.py
new file mode 100644
index 0000000..587f134
--- /dev/null
+++ b/Lovinsky/morpions.py
@@ -0,0 +1,20 @@
+
+
+"""
+x| |o
+ | |x
+ | |x
+"""
+
+class Morpion:
+    def __init__(self):
+        self.grille=[[0,0,0],
+                    [0,0,0],
+                    [0,0,0]]
+        self.symboles=[" ","x","o"]
+
+    def aff(self):
+        for y in range(3):
+            a="|".join(map(lambda x:self.symboles[x],self.grille[y]))
+            print(a)
+    m.aff()
diff --git a/Fractal Dimensions.py b/Pyspace/Fractal Dimensions.py
similarity index 100%
rename from Fractal Dimensions.py
rename to Pyspace/Fractal Dimensions.py
diff --git a/Teletype/polynomial.py b/Teletype/polynomial.py
new file mode 100644
index 0000000..5133d68
--- /dev/null
+++ b/Teletype/polynomial.py
@@ -0,0 +1,509 @@
+"""
+Features:
+1:COMPLETED: print #renvoie str
+2:COMPLETED: addition #renvoie Polynomial
+3:COMPLETED: multiplication #renvoie Polynomial
+4:COMPLETED: derive #renvoie un Polynomial
+5:COMPLETED: division #renvoie couple de Polynomial
+6:COMPLETED: pgcd #renvoie Polynomial
+7:COMPLETED: ppcm #renvoie Polynomial
+8:COMPLETED: taylor #renvoie Polynomial
+9: factoriser #renvoie str ou liste de liste des coefficients "pareil"
+10: racines reelles #renvoie liste des racines reelles
+11: racines complexes #renvoie liste des racines complexes
+12: Decomposition en éléments simples
+12: show #Affiche le polynome sur une fenetre pygame, pyglet ou matplotlib
+"""
+
+from copy import deepcopy
+# import matplotlib.pyplot as plt #Old way to show the polynomials on screen. Not very nice though...
+
+# from mygrapher.grapher import Grapher #Used to show the polynome on screen with the ability to move within it.
+
+import random  # Used only to generate random polynomials.
+import functools
+
+# Changing the type of the coefficients
+#from decimal import Decimal
+#from numpy import float128
+
+# p=Polynomial.createFromInterpolation(x,y)
+
+
+def prod(l): return functools.reduce(lambda a, b: a * b, l)
+
+
+class Polynomial:
+    def null():
+        """Return the null polynomial."""
+        return Polynomial([0])
+
+    def sum(ps):
+        """Sum polynomials between themselves."""
+        v = Polynomial([0])  # Addition neutral
+        for p in ps:
+            v += p
+        return v
+
+    def prod(ps):
+        """Multiply polynomials between themselves."""
+        v = Polynomial([1])  # Multiplication neutral
+        for p in ps:
+            v *= p
+        return v
+
+    def createFromInterpolation(x, y):
+        """Create a polynomial using the lagrangian interpolation."""
+        n = max(len(x), len(y))
+        p = Polynomial.sum([Polynomial([y[j]]) * Polynomial.prod([Polynomial([-x[i] / (
+            x[j] - x[i]), 1 / (x[j] - x[i])]) for i in range(n) if x[i] != x[j]]) for j in range(n)])
+        return Polynomial(p.coefficients)
+
+    def __init__(self, coefficients, definition=[-10**20, 10**20]):
+        """Create a polynomial using its coefficients."""
+        self.coefficients = coefficients
+        self.definition = definition
+
+    def make(self, f):
+        """Transform all the coefficients into a decimal type."""
+        self.coefficients = [f(c) for c in self.coefficients]
+        self.definition = [f(d) for d in self.definition]
+
+    def __str__(self):
+        """Return the usual representation of a polynomial."""
+        if self.coefficients == []:
+            return "0"
+        liste = []
+        if self.coefficients[0] != 0:
+            liste.append(str(self.coefficients[0]))
+        for degre, coefficient in enumerate(self.coefficients[1:], 1):
+            if coefficient != 0:
+                liste.append(str(coefficient) + "X^" + str(degre))
+        liste.reverse()
+        text = "+".join(liste)
+        text = text.replace("^1", "").replace("+-", "-").replace("1X", "X")
+        return text
+
+    def adapt(coefficients, size):
+        """Add zeros to the coefficients using coefficients and size."""
+        return coefficients + [0] * (size - len(coefficients))
+
+    def __eq__(self, other):
+        """Determine if two polynomials are equals by checking if the coefficients
+        are the same."""
+        return self.coefficients == other.coefficients
+
+    def __add__(self, other):
+        """Add 2 polynomials together by adding their coefficients."""
+        maxdegree = max(self.degree + 1, other.degree + 1)
+        cA = Polynomial.adapt(self.coefficients, maxdegree)
+        cB = Polynomial.adapt(other.coefficients, maxdegree)
+        coefficients = [a + b for (a, b) in zip(cA, cB)]
+        A = Polynomial(coefficients)
+        A.correct()
+        return A
+
+    def __sub__(self, other):
+        """Substract 2 polynomials together by multiplying the second polynomial by -1 and adding it to the first using add method."""
+        return self + other * Polynomial([-1])
+
+    def __mul__(self, other):
+        """Multiply 2 polynomials together using the formula for the coefficients."""
+        degree = len(self.coefficients) + len(other.coefficients)
+        A = self.coefficients + [0] * (degree - len(self.coefficients) + 1)
+        B = other.coefficients + [0] * (degree - len(other.coefficients) + 1)
+        newcoefficients = []
+        for k in range(degree + 1):
+            coeff = 0
+            for i in range(k + 1):
+                coeff += A[i] * B[k - i]
+            newcoefficients.append(coeff)
+        C = Polynomial(newcoefficients)
+        C.correct()
+        return C
+
+    def __pow__(self, n):
+        """Does an ~exponentiation of the polynomial."""
+        return Polynomial.mul([self for i in range(n)])
+
+    def correct(self):
+        """Correct the coefficients of the polynomial by deleting useless zeros at the end,"""
+        while len(self.coefficients) > 1:
+            if self.coefficients[-1] == 0:
+                del self.coefficients[-1]
+            else:
+                break
+        if self.coefficients == [0]:
+            self.coefficients = []
+        """and then replace float coefficients by int coefficients if possible."""
+        for i in range(len(self.coefficients)):
+            if self.coefficients[i] == int(self.coefficients[i]):
+                self.coefficients[i] = int(self.coefficients[i])
+
+    def __len__(self):
+        """Return the number of coefficients.
+        It is important to notice that it is not the degree due to the fact that
+        the polynomial might have a degree of -inf and the len method must have positive values.
+        In such a case this method will raise an error.
+        It is why it is better to use the degree method in the general case."""
+        A = deepcopy(self)
+        A.correct()
+        return len(A.coefficients) - 1
+
+    def getDegree(self):
+        """Return the degree of a polynomial.
+        It will return -1 if the degree is -inf to be computer friendly."""
+        A = deepcopy(self)
+        A.correct()
+        return len(A.coefficients) - 1
+
+    def __getitem__(self, index):
+        """Return a coefficient of the polynomial."""
+        return self.coefficients[index]
+
+    def __setitem__(self, index, value):
+        """Change a coefficient of the polynomial."""
+        self.coefficients[index] = value
+
+    def __delitem__(self, index):
+        """Delete a coefficient of the polynomial."""
+        del self.coefficients[index]
+
+    def derivate(self):
+        """Derivate the polynomial."""
+        self.coefficients = [i * c for (i, c) in enumerate(self.coefficients)]
+        del self.coefficients[0]
+
+    def derivative(self):
+        """Return the derivative polynomial."""
+        newcoefficients = [i * c for (i, c) in enumerate(self.coefficients)]
+        del newcoefficients[0]
+        return Polynomial(newcoefficients)
+
+    def unit(self):
+        """Return the polynomial unit form."""
+        k = self.coefficients[-1]
+        newcoefficients = []
+        for i in range(len(self.coefficients)):
+            newcoefficients.append(self.coefficients[i] / k)
+        A = Polynomial(newcoefficients)
+        A.correct()
+        return A
+
+    def unitarize(self):
+        """Convert the polynomial into its unit form."""
+        self.coefficients = self.unit().coefficients
+
+    def __xor__(self, other):
+        """Return the HCF (PGCD  en francais) of self and other by Euclide algorithm. Make use of "^" operator."""
+        R0 = deepcopy(self)
+        R1 = deepcopy(other)
+        R0.correct()
+        R1.correct()
+        listR = [R0, R1]
+        while listR[-1].degree > 0:
+            R, Q = listR[-2] / listR[-1]
+            listR.append(R)
+        return listR[-2]
+
+        # Resultat d'une enorme galere de 2h...
+        # Algorithme d'Euclide:
+        # a=b*q0+r0
+        # b=r*q1+r1
+        # r=r1*q2+r2
+        # r1=r2*q3+r3
+        # ...
+        # ri=r(i-1)*q(i-1)+1+0
+
+    def __or__(self, other):
+        """Return the LCM (PPCM en francais) using "i have absolutely no clue how to do this so figure it out!" Make use of "|" operator."""
+        # On sent la (tres) grosse fatigue apres minuit.
+        return "Figure it out!"
+
+    def __truediv__(self, other):
+        """Return the division of 2 polynomials."""
+        R = deepcopy(self)
+        B = deepcopy(other)
+        R.correct()
+        B.correct()
+        Q = Polynomial([])
+        while R.degree >= B.degree:
+            d = R.degree - B.degree + 1
+            C = Polynomial([0 for i in range(d)])
+            C[-1] = R[-1] / B[-1]
+            R = R - B * C
+            Q = Q + C
+        return [R, Q]
+
+        # Ce que j'ai du faire pour trouver l'implementation...
+        # On a: A=BQ+R
+        # [3,2,4,5,1]/[1,4,1]
+        # [3,2,3,1,0]=[3,2,4,5,1]-[0,0,1]*[1,4,1] #[0,0,1,4,1]
+        # [3,1,-1,0]=[3,2,3,1]-[0,1]*[1,4,1] #[0,1,4,1]
+        # [4,5,0]=[3,1,-1]-[-1]*[1,4,1] #[-1,-4,-1]
+        # [4,5]
+
+        # 5=8*0+5 cas particulier de la division euclidienne
+
+    def isDivisible(self, other):
+        """Determine if the polynomial is divisible by other."""
+        q, r = self / other
+        return r == Polynomial.zero
+
+    def __call__(self, x):
+        """Evaluate the polynomial given an x value."""
+        return sum([c * x**n for (n, c) in enumerate(self.coefficients)])
+
+    def getFactoredForm(self):
+        """Return the list of the factors of the factored form of the polynomial."""
+        return
+
+    def allDerivatives(self):
+        """Return the list of all derivatives of the polynome until the zero polynome."""
+        B = deepcopy(self)
+        derivatives = [deepcopy(self)]
+        while B.degree > 1:
+            B.derivate()
+            derivatives.append(deepcopy(B))
+        return derivatives
+
+    def getRootsByDichotomy(self, precision=1e-15):
+        """Return the list of all the roots of the polynomial."""
+        """Does that by finding where all the derivates cancel, to find new extrema and applying tvi."""
+        roots = []
+        derivatives = self.allDerivatives()
+        derivatives.reverse()
+        old_extrema = []
+        for derivative in derivatives:
+            new_extrema = []
+            neglim = self.definition[0]
+            poslim = self.definition[1]
+            extrema = [neglim] + old_extrema + [poslim]
+            for i in range(len(extrema) - 1):
+                if derivative(extrema[i]) * derivative(extrema[i + 1]) <= 0:
+                    new_extrema.append(derivative.dichotomy(
+                        extrema[i], extrema[i + 1], precision))
+            old_extrema = new_extrema[:]
+        return new_extrema
+
+    def dichotomy(self, xa, xb, precision=1e-15):
+        """Return a float value x between a and b for which the polynomial canceled itself.
+        Does that based on theoreme of intermediate value with dichotomy."""
+        if self(xa) * self(xb) > 0:
+            raise Exception(
+                "The polynomial cannot cancel itself within this interval.")
+        a = min(xa, xb)
+        b = max(xa, xb)
+        x = (a + b) / 2
+        while abs(self(x)) > precision:
+            print(x, self(x), abs(self(x)), precision)
+            if self(x) * self(b) > 0:
+                b = x
+            if self(x) * self(a) > 0:
+                a = x
+            x = (a + b) / 2
+        return x
+
+    def getRoots(self, precision=1e-15):
+        """
+        Return the roots of the polynomial by doing the best possible calculation
+        that combines precision and efficiency.
+        """
+        degree = self.degree  # There are less calculations by selecting the degree
+        if degree == 0:
+            if self.coefficients[0] == 0:
+                raise Exception("Every number is a root of p.")
+            else:
+                return []
+        elif self.degree == 1:
+            b, a = self.coefficients
+            return [-b / a]  # a cannot be null
+        elif self.degree == 2:
+            c, b, a = self.coefficients
+            discriminant = b**2 - 4 * a * c
+            x1 = (-b - discriminant**(1 / 2)) / (2 * a)  # a cannot be null
+            x2 = (-b + discriminant**(1 / 2)) / (2 * a)  # a cannot be null
+            return [x1, x2]
+        else:
+            return self.getRootsByDichotomy(precision)
+
+    def getMultiplicity(self, root):
+        """Return the multiplicity of a root."""
+        b = self
+        n = 0
+        while b.coefficients != [1]:
+            q, b = b / Polynomial([-root, 1])
+            n += 1
+        return n
+
+    def getRootsWithMultiplicity(self):
+        """Return a list of couples of roots with their multiplicity associated.
+        Example: [(r1,m1),(r2,m2),...] """
+        return [(r, self.getMultiplicity(r)) for r in list(set(self.roots))]
+
+    def __floordiv__(self, other):
+        """Return a rational function of numerator the polynomial, and the denominator the other."""
+        return RationalFunction(self, other)
+
+    def show(self):
+        """Show the polynomial with grapher."""
+        Grapher([self])()  # Instance Grapher only takes the list of the functions in parameter and can be called to display them.
+
+    def matplotlibShow(self, zone=[-5, 5], precision=0.1):
+        """Show the polynomial with matplotlib using optional zone and precision."""
+        z, Z = zone
+        X = list(
+            [precision * x for x in range(int(z / precision), int(Z / precision))])
+        Y = list([self(x) for x in X])
+        plt.plot(X, Y, label="Polynomial")
+        plt.show()
+
+    degree = property(getDegree)
+    roots = property(getRoots)
+
+
+class FactoredPolynomial(Polynomial):
+    """For factored of a polynomial."""
+
+    def __init__(self, roots_and_multiplicity):
+        """Define the factored polynomial with its roots."""
+        self.roots = roots
+
+    def __str__(self):
+        """Return a string representation of the factored polynomial."""
+
+    def getCoefficients(self):
+        """Return the coefficients of the polynomial."""
+
+
+class RationalFunction:
+    """Wikipedia: In algebra, the partial fraction decomposition or partial
+    fraction expansion of a rational function (that is, a fraction such that the
+    numerator and the denominator are both polynomials) is an operation that
+    consists of expressing the fraction as a sum of a polynomial (possibly zero)
+    and one or several fractions with a simpler denominator"""
+
+    def __init__(self, p, q):
+        """Define a rational function using two polynomials p: the numerator
+        and q: the denominator."""
+        self.p = p
+        self.q = q
+
+    def __str__(self):
+        """String representation of a rational function."""
+        return "(" + str(self.p) + ")/(" + str(self.q) + ")"
+
+    def __call__(self, x):
+        """Evaluate in x the rational function."""
+        return self.p(x) / self.q(x)
+
+    def __add__(self, other):
+        """Add two rational functions."""
+        p = self.p * other.q + other.p * self.q
+        q = self.q * other.q
+        return RationalFunction(p, q)
+
+    def __sub__(self, other):
+        """Substract two rational functions."""
+        p = self.p * other.q - other.p * self.q
+        q = self.q * other.q
+        return RationalFunction(p, q)
+
+    def __mul__(self, other):
+        """Multiply two rational functions."""
+        p = self.p * other.p
+        q = self.q * other.q
+        return RationalFunction(p, q)
+
+    def __invert__(self, other):
+        """Return the inverse of the rational function. (This operation is optional.)"""
+        return RationalFunction(self.q, self.p)
+
+    def __truediv__(self, other):
+        """Divide a rational function by another."""
+        p = self.p * other.q
+        q = self.q * other.p
+        return RationalFunction(p, q)
+
+    def getDegree(self):
+        """Return the degree of the rational function."""
+        return self.p.degree - self.q.degree
+
+    def getPoles(self):
+        """Return the poles of the rational function."""
+        return self.q.roots
+
+    def getRoots(self):
+        """Return the roots of the rational function."""
+        return self.p.roots
+
+    def decompose(self):  # Not implemented
+        """Return the partial fraction decomposition."""
+        # Note this method is supposed to work with complexes
+        # So it is not always valid and needs a more general case
+        e, r = self.p / self.q
+        roots = self.q.getRoots()
+        l = [e]
+        for (j, xj) in enumerate(roots):
+            p = Polynomial([self.p(xj) / self.q.derivative(xj)])
+            q = Polynomial([-xj, 1])
+            fp = RationalFunction(p, q)
+            l.append(fp)
+        return l
+
+    def getWholePart(self):  # Not finished
+        """Return the whole part of the fraction."""
+        e, r = self.p / self.q
+        return e
+
+    def getFractionalPart(self):  # Not finished
+        """Return the fractional part of the fraction."""
+        e, r = self.p / self.q
+        return r
+
+    degree = property(getDegree)
+    poles = property(getPoles)
+
+
+class PartialFraction(RationalFunction):  # This is just an idea
+    """The only difference with the rational function is that the denominator is
+    of the form: [a,b] which corresponds to q=(x-a)**b."""
+    # It might not be a good idea.
+
+    def __init__(self, p, q):
+        """Define a rational function using two polynomials p: the numerator
+        and q: the denominator."""
+        self.p = p
+        self.q = q
+
+
+if __name__ == "__main__":
+    # suite_random = [random.randint(0,10) for i in range(10)] #Create polynome as big as needed.
+    # X=Polynomial(suite_random)
+    # t=float128
+    suite1 = [3, 2, 4, 5, 1]
+    suite2 = [1, -2, 1]
+    suite3 = [4, 5]
+    A = Polynomial(suite1)
+    B = Polynomial(suite2)
+    C = Polynomial(suite3)
+    FP = RationalFunction(A, B)
+    print("A =", A)
+    print("B =", B)
+    print("C =", C)
+    print("A+B =", A + B)
+    print("A*B =", A * B)
+    print("Derivative of A =", A.derivative())
+    print("A/B :", A / B)
+    print("A//B:", A // B)
+    print("Unit polynomial of C =", C.unit())
+    print("HCF (PGCD en francais) of A and B (written A^B) =", A ^ B)
+    print("LCM (PPCM en francais) of A and B (written A|B) =", A | B)
+    print("Roots of B:", B.roots)
+    print("Multiplicity of the root 2 of B:", B.getMultiplicity(2))
+    print("Roots with multiplicities of B:", B.getRootsWithMultiplicity())
+    #print("Show A on screen:")
+    # C=Polynomial.createFromInterpolation([1,2,-4,-6,4],[1,-3,-2,5,-2])
+    print(C.coefficients)
+    print(FP.decompose())
+    # C.show()
diff --git a/Tests/__future__ and syntax tests.py b/Tests/__future__ and syntax tests.py
new file mode 100644
index 0000000..d4ad974
--- /dev/null
+++ b/Tests/__future__ and syntax tests.py	
@@ -0,0 +1,18 @@
+#from __future__ import *
+
+simple_stmt ::=  expression_stmt
+                 | assert_stmt
+                 | assignment_stmt
+                 | augmented_assignment_stmt
+                 | annotated_assignment_stmt
+                 | pass_stmt
+                 | del_stmt
+                 | return_stmt
+                 | yield_stmt
+                 | raise_stmt
+                 | break_stmt
+                 | continue_stmt
+                 | import_stmt
+                 | future_stmt
+                 | global_stmt
+                 | nonlocal_stmt
diff --git a/Tests/calculations.py b/Tests/calculations.py
new file mode 100644
index 0000000..0f4a69b
--- /dev/null
+++ b/Tests/calculations.py
@@ -0,0 +1,13 @@
+a=8*3600
+b=1*60+12
+
+print(a/b)
+
+print(b*15)
+
+
+c=(1e13/200)**(1/1000)
+print(c)
+
+
+print(1080/8/60)
diff --git a/Tests/classmethod test.py b/Tests/classmethod test.py
new file mode 100644
index 0000000..3104529
--- /dev/null
+++ b/Tests/classmethod test.py	
@@ -0,0 +1,11 @@
+class Test:
+    v=1
+    def __init__(self):
+        self.v=1
+
+    @staticmethod
+    def test(cls,self):
+        print(cls.v,self.v)
+
+t=Test()
+print(t.test())
diff --git a/Tests/deque collections.py b/Tests/deque collections.py
new file mode 100644
index 0000000..cc09b0b
--- /dev/null
+++ b/Tests/deque collections.py	
@@ -0,0 +1,17 @@
+from collections import deque
+
+d = deque('hello', maxlen=5)
+
+d.append('4')
+d.append(4)
+d.appendleft(2)
+d.pop()
+d.popleft()
+d.clear()
+
+d.extend(iter([1,2,3]))
+print(d)
+d.extendleft('hey')
+print(d)
+d.rotate(2) #useful
+print(d)
diff --git a/Tests/metaclasses test.py b/Tests/metaclasses test.py
new file mode 100644
index 0000000..4f27c98
--- /dev/null
+++ b/Tests/metaclasses test.py	
@@ -0,0 +1,45 @@
+def creer_personne(personne, nom, prenom):
+    """La fonction qui jouera le rôle de constructeur pour notre classe Personne.
+
+    Elle prend en paramètre, outre la personne :
+    nom -- son nom
+    prenom -- son prenom"""
+
+    personne.nom = nom
+    personne.prenom = prenom
+    personne.age = 21
+    personne.lieu_residence = "Lyon"
+
+def presenter_personne(personne):
+    """Fonction présentant la personne.
+
+    Elle affiche son prénom et son nom"""
+
+    print("{} {}".format(personne.prenom, personne.nom))
+
+# Dictionnaire des méthodes
+methodes = {
+    "__init__": creer_personne,
+    "presenter": presenter_personne,
+}
+
+# Création dynamique de la classe
+Personne = type("Personne", (), methodes)
+print(Personne)
+
+
+#---------------------#
+
+class MaMetaClasse(type):
+
+    """Exemple d'une métaclasse."""
+
+    def __new__(metacls, nom, bases, dict):
+        """Création de notre classe."""
+        print("On cree la classe {}".format(nom))
+        return type.__new__(metacls, nom, bases, dict)
+
+class MaClasse(metaclass=MaMetaClasse):
+    pass
+
+print()
diff --git a/Tests/opencv pygame conversion.py b/Tests/opencv pygame conversion.py
new file mode 100644
index 0000000..7c7cfaf
--- /dev/null
+++ b/Tests/opencv pygame conversion.py	
@@ -0,0 +1,80 @@
+import pygame
+import cv2
+
+pygame.init()
+
+# --- create PyGame image ---
+
+pg_img = pygame.Surface((400, 200))
+pygame.draw.circle(pg_img, (255,0,0), (0,0), 200)
+
+# --- display PyGame image ---
+
+screen = pygame.display.set_mode((400, 400))
+
+screen.fill((255,255,255))
+screen.blit(pg_img, pg_img.get_rect())
+pygame.display.flip()
+
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        if event.type == pygame.KEYDOWN:
+            running = False
+
+pygame.quit()
+
+# --- move from PyGame to CV2 ---
+
+color_image = pygame.surfarray.array3d(pg_img)
+
+color_image = cv2.transpose(color_image)
+color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
+
+# --- display CV2 image ---
+
+cv2.imshow('Color', color_image)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+# --- change CV2 image ---
+
+color_image = cv2.rotate(color_image, cv2.ROTATE_90_CLOCKWISE)
+gray_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2GRAY)
+
+# --- display CV2 image ---
+
+cv2.imshow('Gray', gray_image)
+cv2.waitKey(0)
+cv2.destroyAllWindows()
+
+# --- save in file in CV2 ---
+
+cv2.imwrite('test.png', color_image)
+
+# --- move back from CV2 to PyGame ---
+
+gray_image = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)
+gray_image = cv2.transpose(gray_image)
+
+pg_img = pygame.surfarray.make_surface(gray_image)
+
+# --- display PyGame image ---
+
+screen = pygame.display.set_mode((400, 400))
+
+screen.fill((255,255,255))
+screen.blit(pg_img, pg_img.get_rect())
+pygame.display.flip()
+
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        if event.type == pygame.KEYDOWN:
+            running = False
+
+pygame.quit()
diff --git a/Tests/opencv video capture.py b/Tests/opencv video capture.py
new file mode 100644
index 0000000..8c634a1
--- /dev/null
+++ b/Tests/opencv video capture.py	
@@ -0,0 +1,29 @@
+import numpy as np
+import cv2
+
+cap = cv2.VideoCapture(0)
+
+# Get the Default resolutions
+frame_width = int(cap.get(3))
+frame_height = int(cap.get(4))
+
+# Define the codec and filename.
+out = cv2.VideoWriter('output.avi',cv2.VideoWriter_fourcc('M','J','P','G'), 10, (frame_width,frame_height))
+
+while(cap.isOpened()):
+    ret, frame = cap.read()
+    if ret==True:
+
+        # write the  frame
+        out.write(frame)
+
+        cv2.imshow('frame',frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    else:
+        break
+
+# Release everything if job is finished
+cap.release()
+out.release()
+cv2.destroyAllWindows()
diff --git a/Tests/opencv video.py b/Tests/opencv video.py
new file mode 100644
index 0000000..ad2cc8c
--- /dev/null
+++ b/Tests/opencv video.py	
@@ -0,0 +1,27 @@
+import numpy as np
+import cv2
+
+cap = cv2.VideoCapture(0)
+
+# Define the codec and create VideoWriter object
+#fourcc = cv2.cv.CV_FOURCC(*'DIVX')
+#out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))
+out = cv2.VideoWriter("output.mp4",
+cv2.VideoWriter_fourcc(*'MP4V'), 10,(640,480))
+
+
+while(cap.isOpened()):
+    ret, frame = cap.read()
+    frame = cv2.flip(frame,0)
+
+    # write the flipped frame
+    out.write(frame)
+
+    cv2.imshow('frame',frame)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# Release everything if job is finished
+cap.release()
+out.release()
+cv2.destroyAllWindows()
diff --git a/Tests/opencv video2.py b/Tests/opencv video2.py
new file mode 100644
index 0000000..37fb26e
--- /dev/null
+++ b/Tests/opencv video2.py	
@@ -0,0 +1,13 @@
+import cv2
+import numpy as np
+
+a="MPEG"
+b='MP4V'
+
+writer = cv2.VideoWriter("output.mp4",
+cv2.VideoWriter_fourcc(*a), 100,(640,480))
+
+for frame in range(1000):
+    writer.write(np.random.randint(0, 255, (480,640,3)).astype('uint8'))
+
+writer.release()
diff --git a/Tests/output.avi b/Tests/output.avi
new file mode 100644
index 0000000..8a75723
Binary files /dev/null and b/Tests/output.avi differ
diff --git a/Tests/output.mp4 b/Tests/output.mp4
new file mode 100644
index 0000000..5271311
Binary files /dev/null and b/Tests/output.mp4 differ
diff --git a/Tests/sympy test.py b/Tests/sympy test.py
new file mode 100644
index 0000000..0708718
--- /dev/null
+++ b/Tests/sympy test.py	
@@ -0,0 +1,23 @@
+from math import sin
+from sympy import Symbol,sin,sqrt
+from sympy import *
+
+x=Symbol('x')
+
+
+#f=sin(x)/x
+f=sqrt(sin(x)/(2*x))
+
+a=5
+
+print(f)
+
+#x=2
+
+print(f)
+
+print("\n".join(map(str,Symbol.__dict__.items())))
+
+a=(1/x)~(1/x**2)
+
+print(a)
diff --git a/Text/__pycache__/classes.cpython-36.pyc b/Text/__pycache__/classes.cpython-36.pyc
deleted file mode 100644
index 4878c1e..0000000
Binary files a/Text/__pycache__/classes.cpython-36.pyc and /dev/null differ
diff --git a/Text/classes.py b/Text/classes.py
deleted file mode 100644
index e50488d..0000000
--- a/Text/classes.py
+++ /dev/null
@@ -1,256 +0,0 @@
-"""mots=[]
-
-determinants=["le","la","un","une"]
-
-determinants={"avant":[],
-              "apres":[],
-              "masculin":None,
-              "singulier":None}
-
-#print(determinants)"""
-
-words=[]
-
-articles=["a","an","the"]
-a=["I","you","he","she","it","we","they"]
-
-class List(list):
-    def __init__(self,object):
-        super().__init__(object)
-
-    def removeall(self,element):
-        while element in self:
-            self.remove(element)
-
-    def purge(self,elements):
-        for element in elements:
-            self.removeall(element)
-
-    def keep(self,elements):
-        for element in self[:]:
-            if not (element in elements):
-                self.removeall(element)
-
-    def whipe(self):
-        accumulator=[]
-        for e in self:
-            accumulator+=e
-        return accumulator
-
-
-
-
-
-
-
-class Str(str):
-    def __init__(self,object):
-        super().__init__()
-        self.alphabet="abcdefghijklmnopqrstuvwxyz"
-        self.consonants="bcdfghjklmnpqrstvwxyz"
-        self.vowels="aeiouy"
-        self.numbers="0123456789"
-
-    def remove(self,element):
-        self.replace(element,"")
-
-
-    def removeall(self,element):
-        while element in self:
-            self.replace(element,"")
-
-
-    def purge(self,elements):
-        a=Str("")
-        l=List(self)
-        l.purge(elements)
-        return Str(a.join(l))
-
-    def keep(self,elements):
-        a=Str("")
-        l=List(self)
-        l.keep(elements)
-        return Str(a.join(l))
-
-
-    def reverse(self):
-        self=[l for l in self[-1:]]
-        #for i in range(len(self)//2):
-        #    self[i]=self[-i-1]
-
-    def append(self,element):
-        self+=element
-
-
-    def apphead(self,element):
-        self.reverse()
-        self.append(element)
-        self.reverse()
-
-    def __sub__(self,element):
-        return self.replace(element,"")
-
-    def __isub__(self,element):
-        self.replace(element,"")
-
-    def __truediv__(self,elements):
-        for element in elements:
-            self.replace(element,"")
-
-    def __floordiv__(self,element):
-        for element in elements:
-            self.removeall(element,"")
-
-    def decompose(self):
-        accumulator=[]
-        for i in range(1,len(self)):
-            for j in range(len(self)-i):
-                accumulator.append(self[j:j+i])
-        return accumulator
-
-    def union(self,l1,l2):
-        accumulator=[]
-        for e1 in l1:
-            if e1 in l2:
-                accumulator.append(e1)
-        return set(accumulator)
-
-    def __mod__(self,other):
-        other=Str(other)
-        own_dec=self.decompose()
-        other_dec=other.decompose()
-        result=len(self.union(own_dec,other_dec))/len(own_dec+other_dec)*100
-        return result #in [0,1]
-
-
-
-    def reverse(self):
-        data=list(self)
-        data.reverse()
-        return Str("".join(data))
-
-
-
-
-
-class Sentence(Str):
-    def __init__(self,object):
-        super().__init__(object)
-        self.words=self.wordsplit()
-
-    def wordsplit(self):
-        text=self[:]
-        text=text.lower()
-        text=Str(text.replace("'"," "))
-        text=text.keep(" "+self.alphabet)
-        words=List(text.split(" "))
-        words.removeall('')
-        words=[Word(word) for word in words]
-        return words
-
-    def __mod__(self,other):
-        other=Sentence(other)
-        own_dec=self.wordsplit()
-        other_dec=other.wordsplit()
-        print(own_dec,other_dec)
-        union=self.union(own_dec,other_dec)
-        print(union)
-        result=len(union)/len(own_dec+other_dec)*100
-        return result #in [0,1]
-
-
-
-
-class Word(Str):
-    def __init__(self,object):
-        super().__init__(object)
-        self.syllables=self.syllablesplit()
-
-    def syllablesplit(self):
-        syllables=[]
-        word=self[:]
-        while word!="":
-            syllable=self.firstsyllable(word)
-            syllables.append(syllable)
-            word=word[len(syllable):]
-        return syllables
-
-    def firstsyllable(self,word):
-        vowelfound=False
-        for i in range(len(word)-1):
-            if word[i] in self.vowels: vowelfound=True
-            if (word[i] in self.consonants) and (word[i+1] in self.vowels):
-                if i>0 and vowelfound: return word[:i]
-        return word
-
-
-class MutableString(object):
-    def __init__(self, data):
-        self.data = list(data)
-    def __str__(self):
-        return "".join(self.data)
-    def append(self,element):
-        self.data+=list(element)
-    def appstart(self,element):
-        self.data.reverse()
-        element.reverse()
-        self.data.append(element)
-        self.data.reverse()
-
-    def __repr__(self):
-        return "".join(self.data)
-    def __setitem__(self, index, value):
-        self.data[index] = value
-    def __getitem__(self, index):
-        if type(index) == slice:
-            return "".join(self.data[index])
-        return self.data[index]
-    def __delitem__(self, index):
-        del self.data[index]
-    def __add__(self, other):
-        self.data.extend(list(other))
-    def __len__(self):
-        return len(self.data)
-    def __reverse__(self):
-	       self.data.reverse()
-
-
-
-noun={"nature":None,
-      "singular":None,
-      "synonyms":[]}
-
-
-
-
-
-
-
-if __name__=="__main__":
-
-    sentence=Sentence("you're a fucking asshole you dumbass, you are a scrotumbag")
-    #b=Str([1,2])
-    #a=a.remove(".")
-    #print(a)
-    #print(sentence.words)
-    #print([word.syllables for word in sentence.words])
-    #print(sentence-"fucking ")
-    #sentence=MutableString(sentence)
-    #print(sentence)
-    #print(Str(sentence).title())
-    #print(list(a))
-    #print(a.remove("s"))
-    #print(b.remove(1))
-    other=Sentence("you are a fucking asshole and a dumbass")
-    other.words.reverse()
-    other=Sentence(" ".join(other.words))
-    #other=other.reverse()
-    print(other)
-    print(sentence%other)
-
-
-    #def decomposeSentence(Str):
-
-        #return words
-
-    #decomposeSentence(a)
diff --git a/Text/converter.py b/Text/converter.py
deleted file mode 100644
index 4431421..0000000
--- a/Text/converter.py
+++ /dev/null
@@ -1,176 +0,0 @@
-import inspect
-
-
-def test(arg1,arg2):
-    a = arg1 + arg2
-    return a
-
-    #do something with args
-
-keywords=["assert","break","class","continue","def","del","elif","else","except","finally","for",
-          "from","global","if","import","in","pass","print","raise","return","try","while","yield"]
-
-conversion1 = {"assert":"ASSERT",
-              "break":"SORTIR DE LA BOUCLE",
-              "class":"CLASSE",
-              "continue":"CONTINER",
-              "def":"DONNEES",
-              "del":"SUPPRIMER",
-              "elif":["SINON SI","FAIRE"],
-              "else":["SINON","FAIRE"],
-              "except":"EXCEPTE",
-              "finally":"FINALLEMENT",
-              "for":["POUR","FAIRE"],
-              "from":"DEPUIS",
-              "global":"GLOBAL",
-              "if":"SI",
-              "import":"IMPORTER",
-              "in":"DANS",
-              "pass":"PASSER",
-              "print":"AFFICHER",
-              "raise":"RELEVER",
-              "return":"AFFICHER",
-              "try":"ESSAYER",
-              "while":["TANT QUE","FAIRE"],
-              "yield":"PASSER AU TOUR SUIVANT",
-              "==":"=",
-              "=":"<-"}
-
-
-
-def algorithm(name):
-    lines = inspect.getsource(name)
-    output = []
-    lines = lines.split("\n")
-    for line in lines:
-        output.append(Converter(line)())
-        #print("output: ",output)
-    return "\n".join(output)
-
-
-class Converter:
-    def __init__(self,line):
-        self.line=line
-        self.alphabet="abcdefghijklmnopqrstuvwxyz"
-        self.numbers="0123456789"
-        self.punctuation="():.,"
-        self.conversion= {"assert":     [[None,"assert",None],              [None,"ASSERT",None]],
-                          "break":      [[None,"break"],                    [None,"SORTIR DE LA BOUCLE"]],
-                          "class":      [["class",None],                    ["CLASS",None]],
-                          "continue":   [[None,"continue",None],            [None,"CONTINUER",None]],
-                          "def":        [["def",None,"(",None,"):"],        [None,":\nDONNES: ",None," :"]],
-                          "del":        [[None,"del",None],                 [None,"SUPPRIMER",None]],
-                          "elif":       [[None,"elif",None,":"],            [None,"SINON SI",None," FAIRE"]],
-                          "else":       [[None,"else:",None],               [None,"SINON",None," FAIRE"]],
-                          "except":     [[None,"except:",None],             [None,"EXCEPTE",None]],
-                          "finally":    [[None,"finally:",None],            [None,"FINALLEMENT",None]],
-                          "for":        [["for",None," in ",None,":"],      ["POUR",None," DANS ",None," FAIRE"]],
-                          "from":       [["from",None],                     ["DEPUIS",None]],
-                          "global":     [["global",None],                   ["GLOBAL",None]],
-                          "if":         [[None,"if ",None],                 [None,"SI",None]],
-                          "import":     [[None,"import",None],              [None,"IMPORTER",None]],
-                          " in ":       [[None," in ",None],                [None, "DANS ",None]],
-                          " is ":       [[None," is ",None],                [None," EST ",None]],
-                          "pass":       [[None,"pass"],                     [None,"PASSER",None]],
-                          "print":      [[None,"print",None,"(",None,")"],  [None,"AFFICHER: ",None,None]],
-                          "raise":      [[None,"raise",None],               [None,"RELEVER",None]],
-                          "return":     [[None,"return",None],              [None,"AFFICHER",None]],
-                          "try":        [[None,"try:",None],                [None,"ESSAYER",None]],
-                          "while":      [["while ",None,":"],               ["TANT QUE ",None," FAIRE"]],
-                          "yield":      [[None,"yield"],                    [None,"PASSER AU TOUR SUIVANT"]],
-                          "==":         [[None,"==",None],                  [None,"=",None]],
-                          "!=":         [[None,"!=",None],                  [None,"≠",None]],
-                          "=":          [[None,"=",None],                   [None,"<=",None]],
-                          "append":     [[None,".append(",None,")"],             ["AJOUTER A ",None," LA VALEUR ",None]]}
-
-        self.removeIndent()
-
-
-    def removeIndent(self):
-        self.indent=0
-        if self.line!="":
-            while self.line[0]==" ":
-                self.indent+=1
-                self.line=self.line[1:]
-
-    def convert(self):
-        if not ("#" in self.line):
-            for key in self.conversion:
-                if key in self.line:
-                    self.apply(key)
-
-    def apply(self,key):
-        #print("key:",key)
-        l=self.missing(self.conversion[key][0])
-        #print("l:",l)
-        filled=self.fill(self.conversion[key][1],l)
-        #print("filled:",filled)
-        self.line="".join(filled)
-        #print(self.line)
-
-    def missing(self,l):
-        """
-        l=          ["def ",None,"(",None,"):"]
-        self.line=  "def algorithm(name):"
-        l1=["def","(","):"]
-        """
-        line=[]
-        if l[0]==None:
-            i=self.next(self.line,l[1])
-            line.append(self.line[:i])
-        for i in range(1,len(l)-1):
-            #print("missing loop:",l[i-1],l[i],l[i+1])
-            if l[i]==None:
-                a=self.between(self.line,l[i-1],l[i+1])
-                line.append(a)
-                #print("a",a)
-        if l[-1]==None:
-            i=self.next(self.line,l[-2])+len(l[-2])
-            line.append(self.line[i:])
-        return line
-
-    def removeNone(self,l):
-        l1=[]
-        for word in l:
-            if word!=None:
-                l1.append(word)
-        return l1
-
-    def between(self,text,word1,word2):
-        i1=self.next(text,word1)+len(word1)
-        i2=i1+self.next(text[i1:],word2)
-        return text[i1:i2]
-
-    def cut(self,text,word):
-        for i in range(len(text)-len(word)+1):
-            if text[i:i+len(word)]==word:
-                break
-        return [text[:i],word,text[i+len(word):]]
-
-    def next(self,text,word):
-        for i in range(len(text)-len(word)+1):
-            if text[i:i+len(word)]==word:
-                break
-        return i
-
-    def fill(self,l1,l2):
-        line=[]
-        for e1 in l1:
-            if e1==None:
-                line.append(l2[0])
-                del l2[0]
-            else:
-                line.append(e1)
-        return line
-
-    def __call__(self):
-        self.convert()
-        return " "*self.indent+self.line
-
-
-
-print(algorithm(algorithm))
-
-#c=Converter("def test(arg1,arg2):")
-
-#print(c.between("def test(arg1,arg2):","(",")"))
diff --git a/Text/test.py b/Text/test.py
deleted file mode 100644
index 2b7754d..0000000
--- a/Text/test.py
+++ /dev/null
@@ -1,31 +0,0 @@
-def foo(arg1,arg2):
-    #do something with args
-    a = arg1 + arg2
-    return a
-
-
-
-print(lines.split("\n"))
-
-
-
-def convertir(nom):
-    import inspect
-    lines = inspect.getsource(foo)
-    lines=Str(lines)
-    output=[]
-    for line in lines:
-        output.append(convert(line))
-    return "".join(output)
-
-def convert(line):
-    if word_split():
-
-
-
-#import dis
-#print(dis.dis(foo))
-
-#from dill.source import getsource
-
-#print(getsource(list.remove))
diff --git a/fermi's elephant.py b/fermi's elephant.py
new file mode 100644
index 0000000..6a9abad
--- /dev/null
+++ b/fermi's elephant.py	
@@ -0,0 +1,36 @@
+import numpy as np
+import pylab
+
+# elephant parameters
+p1, p2, p3, p4 = (50 - 30j, 18 +  8j, 12 - 10j, -14 - 60j )
+p5 = 40 + 20j # eyepiece
+
+def fourier(t, C):
+    f = np.zeros(t.shape)
+    A, B = C.real, C.imag
+    for k in range(len(C)):
+        f = f + A[k]*np.cos(k*t) + B[k]*np.sin(k*t)
+    return f
+
+def elephant(t, p1, p2, p3, p4, p5):
+    npar = 6
+    Cx = np.zeros((npar,), dtype='complex')
+    Cy = np.zeros((npar,), dtype='complex')
+
+    Cx[1] = p1.real*1j
+    Cx[2] = p2.real*1j
+    Cx[3] = p3.real
+    Cx[5] = p4.real
+
+    Cy[1] = p4.imag + p1.imag*1j
+    Cy[2] = p2.imag*1j
+    Cy[3] = p3.imag*1j
+
+    x = np.append(fourier(t,Cx), [-p5.imag])
+    y = np.append(fourier(t,Cy), [p5.imag])
+
+    return x,y
+
+x, y = elephant(np.linspace(0,2*np.pi,1000), p1, p2, p3, p4, p5)
+pylab.plot(y,-x,'.')
+pylab.show()
diff --git a/test addition.py b/test addition.py
deleted file mode 100644
index 84c840b..0000000
--- a/test addition.py	
+++ /dev/null
@@ -1,2 +0,0 @@
-def __+__(a,b):
-  return a+b
diff --git a/test.py b/test.py
deleted file mode 100644
index 261a651..0000000
--- a/test.py
+++ /dev/null
@@ -1,2 +0,0 @@
-import sys
-print(sys.version)
diff --git a/test2.py b/test2.py
deleted file mode 100644
index 4fea93e..0000000
--- a/test2.py
+++ /dev/null
@@ -1,3 +0,0 @@
-#--coding:utf-8--
-
-print('é')
diff --git a/videos/FindingNemo1/Finding Nemo- Dorys Best Moments.mp4 b/videos/FindingNemo1/Finding Nemo- Dorys Best Moments.mp4
deleted file mode 100644
index 0744668..0000000
Binary files a/videos/FindingNemo1/Finding Nemo- Dorys Best Moments.mp4 and /dev/null differ