import numpy as np
import matplotlib.pyplot as plt
from random import random, randrange, seed

# Minimaler und maximaler x-Wert im Koordinatensystem.
# Dieselber Werte werden auch als minimale und maximale y-Werte verwendet.
minx = 0
maxx = 10

##########################################
# "Zufälliges" Erstellen einer Punktwolke #
###########################################

# Anzahl der Punkte
n = 50

# Steigung und y-Achsenabschnitt der Geraden g,
# die beim Berechnen der Punktwolke verwendet wird. 
m_vorgabe = 3/7
q_vorgabe = 3

# Anzahl und Grösse der Störungen.
anzahl_stoerungen = 1000
messfehler_je_stoerung = 0.02

def h(x):
    # Gerade zum Erzeugen der Punktewolke.
    return m_vorgabe*x+q_vorgabe

def messfehler(fehler, anzahl):
    # Idee: "anzahl" = Anzahl der Störfaktoren, jeder stört um plus-minus "fehler".
    return sum([(2*randrange(2)-1)*fehler for _ in range(anzahl)])

def zufallszahl(linke_grenze, rechte_grenze):
    # Liefert eine (reelle) Zufallszahl zwischen linker und rechter Grenze.
    z = random() * (rechte_grenze-linke_grenze) + linke_grenze
    return z

# Falls man stets dieselben Zufallszahlen möchte,
# kann man den Zufallszahlengenerator mit eine, sogenannten "seed" starten.
# Dazu die folgende Zeile auskommentieren.
# seed(42)

# Liste der x-Koordinaten der Punkte.
liste_x = [zufallszahl(minx, maxx) for i in range(n)]
# Liste der y-Koordinaten der Punkte.
liste_y = [h(x)+messfehler(messfehler_je_stoerung, anzahl_stoerungen) for x in liste_x]

# Ausgabe dieser beiden Listen:
print(f'{liste_x=}')
print(f'{liste_y=}')

#########################################################
# Koordinatensystem festlegen und Punktewolke zeichnen. #
#########################################################

axis = plt.gca()
axis.set_aspect('equal')
axis.set_xlim([minx, maxx])
axis.set_ylim([minx, maxx])

axis.set_axisbelow(True)
axis.yaxis.grid(color='gray', linestyle='dashed')
axis.xaxis.grid(color='gray', linestyle='dashed')

plt.xticks(np.arange(minx, maxx+1, 1))
plt.yticks(np.arange(minx, maxx+1, 1))

# Punkte einzeichnen.
plt.plot(liste_x, liste_y, marker = "o", mfc = "red", linestyle='None')

####################################
# Berechnung der Ausgleichsgeraden #
####################################

# Mittelwerte berechnen
x_mittel = sum(liste_x)/n
y_mittel = sum(liste_y)/n
print(f'{x_mittel=}')
print(f'{y_mittel=}')


# Die Steigung der Ausgleichsgeraden ist ein Bruch mit Zähler 
zaehler = sum([(liste_x[i]-x_mittel)*(liste_y[i]-y_mittel) for i in range(n)])
# und Nenner
nenner = sum([(liste_x[i]-x_mittel)**2 for i in range(n)])

# Steigung der Ausgleichsgeraden
m_ausgleich = zaehler/nenner

# Ausgleichsgerade als Funktion
def g(x):
    return m_ausgleich*(x-x_mittel) + y_mittel

# Ausgleichsgerade einzeichnen.
plt.plot([minx, maxx], [g(minx), g(maxx)], color='blue')

plt.title(f"""Berechnete Ausgleichsgerade:
$y=\ell(x)={m_ausgleich:.3f} \cdot (x-{x_mittel:.3f}) + {y_mittel:.3f}$
$y=\ell(x)={m_ausgleich:.3f} \cdot x+{-m_ausgleich*x_mittel+y_mittel:.3f}$""")

# Speichern des Bildes als png-Datei.
# Funktioniert vermutlich nur, 
# wenn du lokal auf deinem Rechner arbeitest.
plt.savefig('ausgleichsgerade-zu-generierter-punktewolke.png')
plt.show()
plt.close()