# Zufallszahlen zwischen 0 und 1, gleichverteilt

# Fixiere den Seed, um reproduzierbare Ergebnisse zu erhalten:
#np.random.seed(1234)

# Generiere ein Feld von Zufallszahlen
np.random.random(size=(4, 5))

# Zufallszahlen zwischen 1 und 2
a = 1
b = 2
(b - a) * np.random.random(size=(4, 5)) + a

# Zufallszahlen aus der Normalverteilung
normal_values_x = np.random.normal(0., 1., size=(1000))
normal_values_y = np.random.normal(0., 1., size=(1000))

fig = plt.figure()

plt.scatter(normal_values_x, normal_values_y, s=0.1)

plt.show()

# checke Mittelwert
print("Mittelert:", np.mean(normal_values_x))

# checke Standardabweichung
print("Standardabweichung:", np.std(normal_values_x))

# checke Skewness (Asymmetrie)
print("Skewness:", scs.skew(normal_values_x))

# checke Kurtosis ("Dicke der Extrembereiche im Vergleich zu Normal")
print("Kurtosis:", scs.kurtosis(normal_values_x))

# Erzeuge ein einfaches Array von Daten
all_data = np.arange(1, 20)

# hole mir eine zufällige 3x5 Matrix von Werten aus diesem Array von 1 bis 20
np.random.choice(all_data, size=(3, 5))

# hier kommen einige Zahlen mehrfach vor. Wenn man das nicht möchte:
np.random.choice(all_data, size=(17), replace=False)

# und schließlich kann man noch ein Array mit Wahrscheinlichkeiten
# übergeben, nach der die Elemente bestimmt werden sollen

# Beispiel: Ein Würfel mit den Augenzahlen 1, 1, 1, 2, 2, 3
# zunächst die Möglichkeiten für die Augen
die_faces = np.array([1, 2, 3])

# Dann die relativen Häufigkeiten
die_probs_raw = np.array([3, 2, 1])

# das Argument p muss jedoch auf 1 normiert sein
die_probs = die_probs_raw/np.sum(die_probs_raw)

print("Wahrscheinlichkeiten für 1, 2, 3:", die_probs, "\n")

# Erzeuge nun einige Würfe mit diesem Würfel
n_rolls = 300
die_rolls = np.random.choice(die_faces, size=n_rolls, p=die_probs)

print("Ein paar Würfe:", die_rolls)

# Passt das zusammen?

# Was sollten die Ergebnisse sein?
print("Theoretische Anzahl:", n_rolls * die_probs)

fig = plt.figure()

plt.hist(die_rolls, bins=[1,2,3,4])

plt.show()

# definiere eine Funktion für die Suche nach deren Minimum
def a_landscape(x, y):
    # mehrere Täler und Berge, mit einer globalen Neigung
    our_function = 4*np.sin(x) + 6*np.sin(y) - 0.5 * x - 0.2 * y

    return our_function

        
# plotten wir das mal

# definiere x-Werte
x_vals = np.linspace(-10, 10, 500)

# definiere y-Werte
y_vals = np.linspace(-10, 10, 500)

# erzeuge x-y-Grid für 3D Plots
X, Y = np.meshgrid(x_vals, y_vals)

Z = a_landscape(X, Y)

# neue Grafik
fig = plt.figure()

# 3D Achsen erzeugen
ax = fig.add_subplot(1,1,1, projection='3d')

# erzeuge 3D-Oberflächenplot
ax.plot_surface(X, Y, Z, cmap="magma")

plt.show()

# für Reproduzierbarkeit die nächste Zeile verwenden
# np.random.seed(12345)

sample_size = 100

# nun wählen wir einen Satz Werte zufällig aus unserem Bereich:
# Wertebereich für x und y
a = -10
b =  10


def evaluate_a_sample(size=sample_size, verbose=False):
    # ziehe eine Stichprobe von 2xSamplesize (für x und y)
    test_sample = (b - a) * np.random.random(size=(2, sample_size)) + a

    # Werte die Funktion an diesen Punkten aus
    sample_values = a_landscape(*test_sample)  

    if verbose: print("Alle Funktionswerte des Samples:\n", sample_values)

    the_minimum = np.min(sample_values)

    if verbose: print("Der kleinste Wert im Sample:", the_minimum)
    
    return the_minimum

evaluate_a_sample(100, verbose=True)

# Anzahl der Samples
n_samples = 200

# Eine Liste mit Resultaten anlegen
min_list = []

# Mache die Auswertung für einige Samples
for i in range(n_samples):
    min_list.append(evaluate_a_sample(100))
    

print("Liste der Minima:", min_list, "\n")

print("Minimum der Minima:", np.min(min_list))
    
fig = plt.figure()

plt.hist(min_list)

plt.show()

# Tabelle der Anzahl der Möglichkeiten, Dinge 
# in den Rucksack zu packen, wenn es _N_ zur Auswahl gibt
for n in np.arange(1, 62, 5):
    # für jedes Ding gibt es 2 Möglichkeiten (mit, nicht mit)
    # daher insgesamt 2**n
    print(n, "->", 2**n)

# wie lange dauert sowas ca.? 
# nehmen wir eine Mikrosekunde für eine Kombination an
2**61 * 1.e-6 / 3600 / 24 / 365   # hier sollten Jahre herauskommen

# was ist zum Beispiel mit Ding nummer 5?
(item_weights[4], item_prices[4])

# Das Encoding für eine Variante des Einpackens 
# ist ein Vektor mit _N_ Zahlen, die entweder 1 oder 0 sein können
test_encoding = np.random.choice([0, 1], size=num_items, replace=True)
test_encoding

# Damit kann man leicht das Gewicht für eine Variante ausrechnen
the_weight = np.sum(item_weights * test_encoding)
the_weight

# Ebenso funktioniert der Gesamtpreis
the_price = np.sum(item_prices * test_encoding)
the_price

# Nun zum Ausprobieren aller Möglichkeiten:

# setze Wert für besten Preis an
best_price = 0.

# setze Wert für bestes Encoding an
best_encoding = np.zeros(num_items)

# setze Wert für Gewicht zum besten Preis an
best_weight = 0.

# loop über alle natürlichen Zahlen bis 2**N
for counter in tqdm(np.arange(0, 2**num_items, 1)):
    
    # generiere binäre Darstellung des Zählers (als String) und ergänze führende Nullen
    counter_binary = np.binary_repr(counter).zfill(num_items)
    
    # verwandle den String in ein numpy-Array mit 0en und 1en
    current_encoding = np.array([int(a_letter) for a_letter in counter_binary])
        
    # berechne den Preis (inklusive Gewichtscheck) über die Fitness-Funktion
    the_price, the_weight = fitness([current_encoding])
    
    # Abfrage, ob wir eine bessere Lösung gefunden haben als bisher
    if the_price > best_price:
        
        # ersetze Bestwerte für Preis, Encoding und Gewicht
        best_price    = the_price
        best_encoding = current_encoding
        best_weight   = the_weight
        
        
print("The best price is", best_price)
print("at a weight of", best_weight)
print("The best encoding is\n", best_encoding)
    

# Nun zum genetischen Algorithmus

# definiere Anzahl der Eltern
num_parents = 20

# definiere Anzahl Kinder pro Elternpaar
num_c_p_p = 3

# definiere Anzahl der Individuen in einer Generation
# entspricht dem Quadrat der Anzahl der Eltern 
# (wegen der Möglichkeiten von Crossovers)
generation_size = num_c_p_p * num_parents**2

# definiere maximale Anzahl der Generationen
max_generations = 10

# definiere Crossover von zwei Encodings, d.h. rekombiniere die beiden
# an einer zufällig gewählten Stelle
def crossover(encoding_1, encoding_2):
    
    # wähle eine zufällige Stelle aus der Länge der Encodings
    cut_position = np.random.choice(range(num_items))
    
    # rekombiniere die beiden Arrays zu einem mit Schnitt an dieser Stelle
    new_encoding = np.hstack((encoding_1[:cut_position], encoding_2[cut_position:]))
    
    return new_encoding

# erzeuge Generation 0
next_generation = np.random.choice([0, 1], size=(generation_size, num_items), replace=True)

# Loop über die Generationen
for count_generations in range(max_generations):
    
    # print(next_generation)
    
    # bestimme die Fitness aller Individuen in dieser Generation
    the_prices, the_weights = fitness(next_generation)
    
    # print(the_prices)
    
    # bestimme Reihenfolge der Indizes nach Fitness der Individuen
    the_ranking = np.argsort(the_prices)[::-1]
    
    # print(the_ranking)
        
    # suche die nächsten Eltern aus den besten aus
    the_parents = (next_generation[the_ranking])[:num_parents]
    
    # baue die nachfolgende Generation aus den Eltern plus 
    # num_parents x num_parents "Kindern" zusammen
    the_children = []
    
    # erzeuge Kinder durch Crossover, d.h. Kombination der genetischen
    # Codes der beiden Eltern an einer bestimmten Stelle
    # Erster Loop über alle Eltern
    for parent_1 in the_parents:
        
        # Zweiter Loop über alle Eltern
        for parent_2 in the_parents:
            
            # Zusätzlicher Loop über die Anzahl der Kinder pro Elternpaar
            for child_counter in range(num_c_p_p):
                
                # hänge alle möglichen Crossovers in eine Liste zusammen
                the_children.append(crossover(parent_1, parent_2))
    
    # mache aus der Liste ein Array
    next_generation = np.array(the_children)
    
    # hier sind auch die Eltern wieder dabei, weil ein Crossover eines Encodings
    # mit sich selbst das gleiche Encoding nochmals erzeugt
    
    
    # print("parents", the_parents)
    # print("children", the_children)
    # print("new gen.", next_generation)
    
    
    # Output für diese Generation
    print("Gen.:", count_generations, "Beste Fitness:", np.round(np.max(the_prices), 2),
          "mit Gewicht ", np.round(the_weights[the_ranking[0]], 2), "bestes Encoding:", the_parents[0])