# -*- coding: utf-8 -*-

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import linregress

"""Le but de ce code est d'estimer l'incertitude sur la pente d'une régression linéaire, connaissant une série de points de données (x_i +/- u(x_i), y_i +/- u(y_i)) .

On commence dans un premier temps par définir notre jeu de données. Ici j'ai mis des données fictives avec une incertitude uniforme sur x de 0.2 pour chaque point, et une incertitude sur y qui est variable. Il faut bien sûr remplacer ces données par celles que vous avez acquises en TP.
"""

#Valeurs des données en X et Y et leurs incertitudes
X = np.array([1,2,3,4,5])
err_X = np.array([0.2,0.2,0.2,0.2,0.2])
Y = np.array([1.3,2.1,2.8,3.7,5.1])
err_Y = np.array([0.3,0.2,0.1,0.1,0.2])

N = len(X) #Nombre d'échantillons

"""On peut alors faire un régression linéaire simple à l'aide de la fonction linregress, qui va donner les coefficients a (slope) et b (intercept) tels que y = ax + b."""

regression = linregress(X,Y)
a = regression.slope
b = regression.intercept

"""On affiche le résultat de la régression :"""
print("Régression linéaire : Y = a X + b avec")
print("a = "+str(a))
print("b = "+ str(b))

"""On affiche le résultat, avec les barres d'erreur :"""

fig = plt.figure(figsize=(5,5))
plt.errorbar(X,Y,xerr=err_X,yerr=err_Y,  #arguments obligatoires pour la fonction
             color='k',capsize=2,fmt='o',label='Mesures')        #arguments facultatifs (pour le graphe)
plt.plot(X,a*X+b,color='r',label='Regression')
plt.legend(fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlabel('X [sans unité]',fontsize=15)
plt.ylabel('Y [sans unité]',fontsize=15)
plt.show()

"""Notre régression linéaire ne prend pas en compte les barres d'erreur. Pour cela, nous allons faire un grand nombre de régressions en tirant des données aléatoires à partir des données et des incertitudes de mesures, en supposant que la valeur réelle x_i^{réelle} est une variable aléatoire qui suit une loi normale dont la moyenne est la valeur mesurée x_i et l'écart-type son incertitude type u(x_i).

Pour cela, on utilise la fonction randn qui crée un tableau de taille N contenant des nombres aléatoires suivant la loi normale de moyenne 0 et d'écart type 1.

Compléter la fonction :
"""

def simulation_jeu_de_donnees_aleatoire(X,Y,err_X,err_Y,N):
  '''Cette fonction crée un jeu de données aléatoire
  en suivant une loi normale à partir des mesures de X, Y
  et de leurs incertitudes err_X, err_Y'''

  Z = np.random.randn(N) #Tableau de N valeurs aléatoires suivant la loi normale centrée réduite
  X_simul = COMPLETER

  Z = np.random.randn(N) #On tire un nouveau jeu pour générer les Y
  Y_simul = COMPLETER

  return X_simul, Y_simul

"""On va maintenant générer un grand nombre M de tirages et faire à chaque fois une régression linéaire. En enregistrant à chaque fois, on aura non plus une seule estimation des coefficients a et b mais un grand nombre d'estimations issues des incertitudes de mesure."""

M = 1000 #On fait 1000 tirages

#On initialise les tableaux destinés à contenir les résultats de la régression
valeurs_de_a = []
valeurs_de_b = []


for i in range(M):
  #On fait un tirage
  X_simul, Y_simul = simulation_jeu_de_donnees_aleatoire(X,Y,err_X,err_Y,N)
  #On fait une regression à partir de ce tirage
  regression = linregress(X_simul,Y_simul)
  a = regression.slope
  b = regression.intercept
  #On ajoute les valeurs aux listes des coefficients
  valeurs_de_a.append(a)
  valeurs_de_b.append(b)

"""Pour terminer, proposez un code qui permet d'avoir une estimation de a et b avec leur incertitude à partir des deux listes valeurs_de_a et valeurs_de_b et reporter les résultats sur votre compte rendu de TP."""

a = COMPLETER
err_a = COMPLETER
b = COMPLETER
err_b = COMPLETER

"""On indique le résultat, cette fois-ci avec les barres d'erreur :"""
print('a = '+str(a)+' +/-'+str(err_a))
print('b = '+str(b)+' +/-'+str(err_b))

"""On affiche le résultat, avec les barres d'erreur :"""

#Erreur sur la régression par la formule de propagation des incertitudes :
les_x = np.linspace(np.min(X),np.max(X),1000)
les_y = a*les_x+b
err_y = np.sqrt(err_a**2*les_x**2 + err_b**2)

fig = plt.figure(figsize=(5,5))
plt.errorbar(X,Y,xerr=err_X,yerr=err_Y,  #arguments obligatoires pour la fonction
             color='k',capsize=2,fmt='o',label='Mesures')        #arguments facultatifs (pour le graphe)
plt.fill_between(les_x,les_y-err_y,les_y+err_y,color='r',lw=0.5,alpha=0.5)
plt.plot(X,a*X+b,color='r',label='Regression')
plt.legend(fontsize=15)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlabel('X [sans unité]',fontsize=15)
plt.ylabel('Y [sans unité]',fontsize=15)
plt.show()

