def partition(liste,debut,fin):
    pivot = liste[fin]
    i = debut
    for j in range(debut,fin):
        if liste[j]<=pivot:
            liste[i],liste[j] = liste[j],liste[i]
            i += 1
    liste[i],liste[fin] = liste[fin],liste[i]
    return i
                 

def tri_rapide(liste,debut,fin):
    if debut<fin:
        i = partition(liste,debut,fin)
        tri_rapide(liste,debut,i-1)
        tri_rapide(liste,i+1,fin)
    return liste
                  

def trier(liste):
    return tri_rapide(liste.copy(),0,len(liste)-1)
                  

import numpy.random
liste = numpy.random.randint(0,100,size=10)
liste = trier(liste)
                  

def selection(liste,debut,fin,rang): 
    if debut==fin:
        return liste[debut]
    i = partition(liste,debut,fin)
    k = i-debut+1
    if rang==k:
        return liste[i]
    elif rang < k:
        return selection(liste,debut,i-1,rang)
    else:
        return selection(liste,i+1,fin,rang-k)
                  

def selectionner(liste,rang):
    return selection(liste.copy(),0,len(liste)-1,rang)
                  

liste = numpy.random.randint(0,100,size=10)
element = selectionner(liste,2)
liste_trie = trier(liste)
                  

def mediane(liste):
    rang = (len(liste)+1)/2
    return selectionner(liste,rang)
                  

m = mediane(liste)
                  

def median_fenetre(y,debut,longueur):
    liste = y[debut:debut+longueur]
    return mediane(liste)
                

def filtre_median(y,longueur):
    m = []
    debut = 0
    while debut+longueur < N:
        m.append(median_fenetre(y,debut,longueur))
        debut += 1
    return m
                

import random
N=1000
x = numpy.linspace(0,5,N)
y = numpy.sin(2*numpy.pi*x)
P=50
for p in range(P):
    i = random.randrange(N)
    y[i] += (random.random()-0.5)*0.4
 
from matplotlib.pyplot import *
figure()
plot(y)
                 

m = filtre_median(y,5)
figure()
plot(m)
                 

import math
P_gauss=2
h_gauss = numpy.zeros(2*P_gauss+1)
epsilon=0.01
sigma=P_gauss/math.sqrt(-2.0*math.log(epsilon))
som = 0.0
for k in range(2*P_gauss+1):
    h_gauss[k] = math.exp(-(k-P_gauss)**2/(2*sigma**2))
    som += h_gauss[k]
h_gauss = h_gauss/som
                  

import scipy.signal
z = scipy.signal.convolve(y,h_gauss,mode='valid')

figure()
plot(z)