# Definiere eine Variable, dafür gibt es die Klasse Symbol
x = sp.Symbol("x")

# wie sieht das aus?
print(x)

# definiere eine Funktion
f = sp.sin(x)

# und wie sieht das aus?
print(f)

# wenn man eine Funktion an einem bestimmten Wert haben möchte, macht man
print("Der Sinus von", sp.pi, "ist", f.subs(x, sp.pi))

# man substituiert also für das Symbol den Wert. Nochmal:
print(f.subs(x, 1.))

# Auch mehrere Variablen sind kein Problem
x0, a, z = sp.symbols("x0 alpha z")

# die Ausgabe im Notebook ohne print-Befehl sieht dann wie Formelschrift aus
x0, a, z

# es gibt auch noch eine praktische Kurzschreibweise für gleich eine ganze Reihe von Variablen
abunchofsymbols = sp.symbols("x0:15")

abunchofsymbols

# Man kann mit .subs auch einen Ausdruck in den anderen einsetzen.
# definieren wir noch eine Funktion
g = sp.exp(-x**2)

# und dann setzen wir f in g ein
out_sub = g.subs(x, f)

# wie sieht das aus?
out_sub

# und zu guter letzt brauchen wir eventuell auch mal numerische Werte:
# aus
out_sub.subs(x, 4)

# wird
sp.N(out_sub.subs(x, 4))

# das gilt auch für die Konstanten
sp.N(sp.pi, 400)

# und hier noch eine effiziente Möglichkeit für Arrays

# importieren von Numpy 
import numpy as np

# ein Array, z.B. für einen Plot (als x-Werte)
x_values = np.linspace(0, 30, 30)

# so kann man die Werte im Array auf einmal zu numerischen Werten in einem f-Array machen
# Vorbereitung der "Funktion für das Einsetzen eines Arrays"
g_to_numerical = sp.lambdify(x, g)

# das Einsetzen des Arrays:
g_to_numerical(x_values)

# Definieren einer Gleichung
sp.Eq(x, z)

# oder mit den Befehlen von vorher
sp.Eq(f, g)

# Bei Angabe nur eines Arguments passiert folgendes:
sp.Eq(f)

# das sieht man allerdings in älteren Tutorials teilweise. 
# Stattdessen soll man also schreiben
sp.Eq(f, 0)

# Lösen einiger Gleichungen
# zunächst: endlich viele Lösungen
sol = sp.solveset(sp.Eq(x**2, 2))
sol

# Verwendbar sind die Lösungen z.B. als Liste
sp.N(list(sol)[0], 5)

# aber auch: unendlich viele Lösungen:
sp.solveset(sp.Eq(f, 0))

# oder aber auch: keine Lösungen im Reellen, dafür im Komplexen:
sp.solveset(sp.Eq(f + sp.pi, 0))

# zur Erinnerung, eine unserer Funktionen
f

# und hier die Ableitung nach x
sp.diff(f, x)

# und hier die 2. Ableitung nach x
sp.diff(f, x, 2)

# und hier die ersten 10 Ableitungen nach x
for der_i in range(10):
    print(sp.diff(f, x, der_i+1))

# und hier die Ableitung nach z
sp.diff(f, z)

# mit mehreren Variablen kann man so arbeiten
h = f * f.subs(x, z)
h

# jetzt kann man konbinieren
sp.diff(h, x, z, x)

# jetzt kann man konbinieren
sp.diff(h, x, 3, z, 4, x, 2)

# einfaches unbestimmtes Integral
sp.integrate(f, x)

# Achtung, SymPy gibt nicht automatisch die Integrationskonstante dazu
# das muss man also selbst machen:
C = sp.Symbol("C")
sp.integrate(f, x) + C

# der gleiche Befehl funktioniert auch für ein Bestimmtes Integral:
sp.integrate(f, (x, 0, sp.pi))

# noch ein bestimmtes Integral
sp.integrate(1/sp.sqrt(2 * sp.pi) * sp.exp(-x**2 / 2), (x, -sp.oo, sp.oo))

# und hier noch ein mehrfach-Integral. 
# Zunächst die Variablen für die Integration
r, theta, phi = sp.symbols("r theta phi")
r, theta, phi

# und nun z.B. die Berechnung des Volumens der Einheitskugel
sp.integrate(r**2 * sp.sin(theta), (r, 0, 1), (theta, 0, sp.pi), (phi, 0, 2*sp.pi))

# hier ein Beispiel für ein nicht lösbares Integral, zunächst unbestimmt
unsolvable = sp.sin(sp.exp(-x**5)/x**2)

sp.integrate(unsolvable, x)

# dann bestimmt (das sehen wir uns weiter unten nochmals an)
sp.integrate(unsolvable, (x, 1, 2))

%matplotlib inline
import matplotlib.pyplot as plt

# sehen wir uns das kurz an

# Erzeuge Figur
fig = plt.figure()

plt.plot(x_vals, xcubed_vals, label=r"$x^3$")

plt.plot(x_vals, numerical_diff_xcubed, label=r"$3x^2$")

plt.legend(loc=0)

plt.show()

# die x-Werte von vorhin
x_vals = np.linspace(1, 4, 50)

# dazu eine Funktion, sagen wir x^3, aber mit Zufallszahlen dazuaddiert
xcubed_vals = x_vals ** 3 + 0.7 * np.random.random(size=(len(x_vals)))

# dann die Funktion für die Ableitung
# zunächst definieren wir h
h_param = 1.e-5

# die symmetrische Formel muss an dieser Stelle etwas anders geschrieben werden
numerical_diff_xcubed = ((x_vals + h_param)**3 + 0.7 * np.random.random(size=(len(x_vals))) 
                       - (x_vals - h_param)**3 - 0.7 * np.random.random(size=(len(x_vals)))) / 2 / h_param

# sehen wir uns auch das kurz an

# Erzeuge Figur
fig = plt.figure()

plt.plot(x_vals, xcubed_vals, label=r"$x^3$")

plt.plot(x_vals, numerical_diff_xcubed, label=r"$3x^2$")

plt.legend(loc=0)

plt.show()

# die x-Werte von vorhin
x_vals = np.linspace(1, 4, 50)

# dazu eine Funktion, sagen wir x^3, aber mit Zufallszahlen dazuaddiert
xcubed_vals = x_vals ** 3 + 0.7 * np.random.random(size=(len(x_vals)))

# Erzeuge Figur
fig = plt.figure(figsize=(15, 20))

# hier nun der Loop über verschiedene Werte von h
for ind_param, h_param in enumerate([1.e-5, 1.e-4, 1.e-3, 1.e-2, 1.e-1, .5]): 

    ax = plt.subplot(3, 2, ind_param+1)
    
    # die symmetrische Formel muss an dieser Stelle etwas anders geschrieben werden
    numerical_diff_xcubed = ((x_vals + h_param)**3 + 0.7 * np.random.random(size=(len(x_vals))) 
                           - (x_vals - h_param)**3 - 0.7 * np.random.random(size=(len(x_vals)))) / 2 / h_param

    # plotten der beiden Kurven
    ax.plot(x_vals, xcubed_vals, label=r"$x^3$")

    ax.plot(x_vals, numerical_diff_xcubed, label=r"$3x^2$")

    # plt.legend(loc=0)

plt.show()

# ein Beispiel für ein Array, wieder einmal zufällig gewählt:
data_array = np.random.random(size=(200, 200))

# und hier die Ableitung in alle Richtungen
data_derivative = np.gradient(data_array)

# Erzeuge eine Figur
fig=plt.figure(figsize=(15,10))

# erster Subplot: das 2x2 array
ax1 = plt.subplot(131)
ax1.matshow(data_array)

# zweiter Subplot: die Ableitung des Arrays entlang der einen Koordinate
ax2 = plt.subplot(132)
ax2.matshow(data_derivative[0])

# dritter Subplot: die Ableitung des Arrays entlang der anderen Koordinate
ax3 = plt.subplot(133)
ax3.matshow(data_derivative[1])

plt.show()

# numpy.trapz() braucht ein Array von y-Werten
# dazu generiern wir zuerst einige x-Werte auf unserem Integrationsintervall [1, 2]
a = 1
b = 2

# und bereite y-Werte vor
y_num = sp.lambdify(x, unsolvable)

# hier ein for-Loop über verschiedene Werte für die Anzahl 
# der Integrationspunkte oder "Stützstellen"
for n_points in [2, 5, 10, 20, 200, 2000, 20000, 200000]:
    
    # definiere den Abstand zwischen zwei Punkten
    del_x = (b-a)/n_points

    # Erzeuge n_points x-Werte von a bis b
    x_values = np.linspace(a, b, n_points)   

    # rechne y-Werte aus
    y_values = y_num(x_values)

    # Berechne das numerische Integral mit der Trapezregel
    # und gib das Resultat sowie die Anzahl der verwendeten Punkte aus
    # np.trapz braucht hier y-Werte und den Abstand zwischen den x-Werten, nicht mehr
    print(np.trapz(y_values, dx=del_x), "für", n_points, "Integrationspunkte.")

# wie sieht diese Funktion eigentlich aus?
fig = plt.figure()

# nimm die zuletzt verwendeten y-Werte und plotte sie
plt.plot(x_values, y_values)

plt.title(unsolvable)

plt.show()

# Vorbereitungen und das Polynom

# die x-Werte zum Plotten
x_vals = np.linspace(-3, 3, 100)

# das Polynom in SymPy
p = x**3 + x**2 - 2 * x + 4
p

# Jetzt rufen wir das für eine andere Kurve auf
p = x**4 - 4

perform_curve_sketching(p, x, x_vals)

# Jetzt rufen wir das für eine andere Kurve auf
p = x**6 - 3*x**5 + 2*x**3 - 4*x + 1

perform_curve_sketching(p, x, x_vals)

# Addiere alle natürlichen Zahlen bis zu N

# Importiere die Package NumPy
import numpy as np

# setze die Zahl fest, bis zu der summiert werden soll
N = 10

# initialisiere den Wert der Summe
thesum_1 = 0

# starte for-Loop von 1 bis N. Achtung: In Python endet eine range 
# bereits bei der Zahl vor dem zweiten Argument. Daher müssen wir N+1 schreiben
for summand in np.arange(1, N+1, 1):
    
    # Ausgabe zur Illustration
    print("Addiere ", summand)
    
    # Addiere den aktuellen Summanden
    thesum_1 += summand   # das ist kurz-Schreibweise für thesum_1 = thesum_1 + summand 
    

# Ausgabe des Resultats mit Loop 1
print("Resultat mit for-Loop: ", thesum_1, "\n")


# Initialisiere den Wert der zweiten Summe
thesum_2 = 0

# Setze Summand auf den Anfangswert
summand = 1

# Starte den while-Loop
while summand <= 10:
    
    # Ausgabe zur Illustration
    print("Addiere ", summand)
    
    # Addiere den aktuellen Summanden
    thesum_2 += summand
    
    # Erhöhe den Wert des Summanden um 1
    summand += 1
    

# Ausgabe des Resultats mit Loop 2
print("Resultat mit while-Loop: ", thesum_2, "\n")

    

%%time    
# lasse einen Timer mitlaufen, umd einen Vergleichswert zu haben

# außerdem importieren wir noch eine time-Package, für die spätere Nutzung
import time

# definiere diese Ausführung als Funktion, um sie später besser nutzen zu können
def get_primes(upto_n):
    
    # speichere die Beginnzeit für später
    start_time = time.time()

    # erstelle eine leere Liste, in die die Primzahlen kommen sollen
    list_of_primes = []

    # definiere den ersten Kandidaten (wir fangen bei 2 an)
    candidate = 2

    # starte den while-Loop. Er läuft, bis die Länge der Primzahlliste N erreicht hat
    while len(list_of_primes) < upto_n:

        # setze den Status als Primzahl vorerst auf True. 
        # Wenn wir einen Teiler finden, setzen wir ihn auf False
        is_prime = True

        # starte den for-Loop. Er läuft von 2 bis zum momentanen Kandidaten minus 1
        # denn eine Primzahl ist nur durch 1 und sich selbst teilbar
        for a_number in range(2, candidate, 1):

            # check, ob der momentane Kandidat durch die Versuchszahl teilbar ist
            if (candidate % a_number == 0):
                
                # ja, ist teilbar, setze den Status auf False
                is_prime = False

        # wenn alle Zahlen kleiner der Kandidatenzahl durchprobiert sind, checken wir den Status
        if is_prime:
            
            # ja, ist noch auf True. Hänge den Kandidaten an die Primzahlliste an
            list_of_primes.append(candidate)

        # gehe zur nächsten natürlichen Zahl weiter
        candidate += 1 
    
    # Bestimme die Zeit, zu der die Berechnung zu Ende war
    end_time = time.time()
    
    # Berechne die Dauer der Primzahl-Berechnung
    run_time = end_time - start_time

    # Zurückgeben der Liste
    return list_of_primes, run_time


# Rufe die Funktion auf
result_list, the_time = get_primes(1000)

# gib die Liste aus
print(result_list)

# und checke die Länge der Liste
print("Anzahl der Primzahlen in dieser Liste: ", len(result_list))

# gib auch die Runtime aus
print("Runtime der Funktion: ", the_time)

%%time
# lasse einen Timer mitlaufen, umd einen Vergleichswert zu haben

# definiere diese Ausführung als Funktion, um sie später besser nutzen zu können
def get_primes_faster(upto_n):

    # speichere die Beginnzeit für später
    start_time = time.time()

    # starte mit der bereits mit 2 vorbefüllten Liste
    list_of_primes = [2]

    # definiere die Länge der Liste als Variable
    total_number = len(list_of_primes)

    # setze den ersten Kandidaten auf 3
    candidate = 3

    # starte den while-Loop bis N
    while total_number < upto_n:

        # setze den Prime-Status auf True
        is_prime = True

        # starte den for-Loop, diesmal nur über die bisher gefundenen Primzahlen als mögliche Teiler
        for a_prime in list_of_primes:

            # check, ob wir schon bei der Quadradwurzel aus der Kandidatenzahl angelangt sind
            if a_prime > np.sqrt(candidate):

                # wenn ja, brich den for-Loop ab
                break

            # check der Teilbarkeit durch den Test-Primzahl-Teiler
            if (candidate % a_prime == 0):

                # ja, ist teilbar, setze den Status auf False
                is_prime = False

                # und brich den for-Loop ab
                break

        # checke den Status
        if is_prime:

            # ist eine Primzahl, wird an die Liste angehängt
            list_of_primes.append(candidate)

        # erzeuge die neue Länge der Primzahlliste
        total_number = len(list_of_primes) 

        # erhöhe die Kandidaten-Zahl um 2 (nur ungerade Zahlen werden als Kandidaten zugelassen)
        candidate += 2

    # bestimme die End-Zeit der Berechnung
    end_time = time.time()
    
    # Berechne die Dauer
    run_time = end_time - start_time

    # Zurückgeben der Liste
    return list_of_primes, run_time


# Rufe die Funktion auf
result_list, the_time = get_primes_faster(1000)

# gib die Liste aus
print(result_list)

# und checke die Länge der Liste
print("Anzahl der Primzahlen in dieser Liste: ", len(result_list))     

# gib auch die Runtime aus
print("Runtime der Funktion: ", the_time)

%matplotlib inline

# importiere Matplotlib
import matplotlib.pyplot as plt


# Erzeuge eine Liste mit den gewünschten N Werten
# n_list_slower = np.arange(10, 500, 50)

# Eine umfangreichere Möglichkeit:
n_list_slower = np.append(np.arange(10, 100, 10), [200, 300, 500, 1000, 3000])

# Erzeuge leere Liste für die Timings
time_list_slower = []

# Loop über alle N in der Liste
for an_n in n_list_slower:
    
    # Rufe die Funktion auf und erhalte das Ergebnis samt Timing
    result_list, the_time = get_primes(an_n)
    
    # Schreibe das Timing in die Zeiten-Liste dazu
    time_list_slower.append(the_time)
    

# Grafische Darstellung der Ergebnisse
fig = plt.figure()

# plot-Befehl
plt.plot(n_list_slower, time_list_slower, "x-")

# Achsenbeschriftungen und Titel
plt.xlabel("N")
plt.ylabel("Zeit [s]")
plt.title("Skalierungsverhalten für Primzahlenberechnung")

# Skalierungen der Achsen von linear auf logarithmisch setzen
plt.xscale("log")  # auskommentieren, um eine lineare Darstellung in x zu erhalten
plt.yscale("log")  # auskommentieren, um eine lineare Darstellung in y zu erhalten

# Grafik anzeigen
plt.show()

# Erzeuge eine Liste mit den gewünschten N Werten
n_list = np.arange(10, 5000, 100)
# n_list = np.array([10, 100, 1000, 10000]) # Alternative für direkte Eingabe

# Eine Liste für den Skalierungsvergleich, mit N Sqrt(N)
comp_list = np.sqrt(n_list) * n_list / 1000000

# Eine Liste für den Skalierungsvergleich, mit N**2
comp_list_slow = n_list**2 / 400000

# Eine Liste für den Skalierungsvergleich, mit N**2
#comp_list_slow_1 = np.sqrt(n_list) * n_list / 4000    # Aktivieren, um den Vergleich mit dem anderen Scaling zu sehen

# Erzeuge leere Liste für die Timings
time_list = []

# Loop über alle N in der Liste
for an_n in n_list:
    
    # Rufe die Funktion auf und erhalte das Ergebnis samt Timing
    result_list, the_time = get_primes_faster(an_n)
    
    # Schreibe das Timing in die Zeiten-Liste dazu
    time_list.append(the_time)
    

# Grafische Darstellung der Ergebnisse
fig = plt.figure()

# Daten der schnelleren Variante
plt.plot(n_list, time_list, "g", label="Data")

# Vergleichs-Skalierung
plt.plot(n_list, comp_list, "r", label=r"$\mathcal{O}(N\sqrt{N})$")

# Daten der langsameren Variante
plt.plot(n_list_slower, time_list_slower, "b", label="Slower Data")

# Vergleichs-Skalierung
plt.plot(n_list, comp_list_slow, "r--", label=r"$\mathcal{O}(N^2)$")
# plt.plot(n_list, comp_list_slow_1, "r.", label=r"$\mathcal{O}(N\sqrt{N})$")  # Aktivieren, um den Vergleich mit dem anderen Scaling zu sehen

# Achsenbeschriftung und Titel
plt.xlabel("N")
plt.ylabel("Zeit [s]")
plt.title("Skalierungsverhalten für Primzahlenberechnung")

# Log-Skala für y und Platzierung der Legende
plt.yscale("log")
plt.legend(loc=4)

plt.show()

# Beispiellösung:

# Setze Anfangswert für x_0
x0 = 1.

# Setze x_0 auch als vergangenen Wert für die Iteration an
x_prev = x0

# Setze relative Zielgenauigkeit
eps = 1.e-6

# Setze Maximalwert für Iterationen im while-Loop
nmax = 1000

def f(x):
    # definiere Funktion, von der wir Nullstellen finden wollen
    return x**2 - 2.

def fprime(x):
    # definiere Ableitung dieser Funktion
    return 2*x


# Setze Counter zum Verfolgen der Iterationsschritte
icount = 1

# Setze Schrittvergleich auf etwas großes
the_change = 1.

# starte while-Loop
while icount < nmax and the_change > eps:
    
    # Berechne relative Änderung
    the_change = np.abs(f(x_prev)/fprime(x_prev)/x_prev)
    
    # Iterationsvorschrift
    x_next = x_prev - f(x_prev)/fprime(x_prev)
    
    # Ausgabe der Werte für diesen Schritt in der Iteration
    print("Schritt ", icount)
    print("Relative Änderung: ", the_change)
    print("Neuer Näherungswert: ", x_next)
    
    # Übergeben des Neuen Wertes in den nächsten Durchlauf der Schleife
    x_prev = x_next
    
    # Erhöhe den Schritt-Counter
    icount += 1
    
    
# Schluss-Output nach Beendigung des While-Loops
print("Das Ergebnis ist ", x_next)
print("Check: ", np.sqrt(2.))
    

# Definition zweier integer Variablen
var_1 = 1
var_2 = 2

# Ausgabe der Summe auf dem Bildschirm
print("Die Summe der beiden Variablen ist: ", var_1 + var_2)

# Definition von String Variablen
var_1 = "Hello"
var_2 = "World!"

# Ausgabe der Summe auf dem Bildschirm
print("Der überraschende Text: ", var_1 + " " + var_2 + "\n" + "Das war überraschend!")

# Definition einer Funktion
def a_function(var_1, optional_var_1 = 10):
    
    # addiere 10 (oder einen anderen Term) zur eingegebenen Zahl
    output = var_1 + optional_var_1
    
    # was von der Funktion zurückgegeben wird
    return output

# verwende die Funktion
print("Ohne optionales Argument: ", a_function(1))
print("Mit optionalem Argument: ", a_function(1,5))

# Definition der Liste
a_list = [1,3,5,7,9]

# noch eine leere Liste
square_list = []

# For-Loop über Listen-Elemente
for an_element in a_list:
    
    # Ausgabe von Informationen zur Variable, über die der Loop läuft
    print(an_element, " zum Quadrat ist ", an_element**2)
    
    # Hänge ein Ergebnis an eine andere Liste an
    square_list.append(an_element**2)
    
# gib am Schluss auch die andere Liste aus
print("Die Quadrat-Liste ist jetzt ", square_list)

# Eine andere Art von Loop

# initialisiere einen Zähler
a_counter = 0

# While-Loop, bis der Zähler 10 erreicht
while a_counter < 10:
    
    # Ausgabe des Zählers
    print("die nächste Zahl ist ", a_counter)
    
    # Erhöhe den Zähler um 1
    a_counter += 1

# Loop über Elemente und indices einer Liste
for an_index, an_element in enumerate(square_list):
    
    # Ausgabe von Informationen, wobei man Index in der Liste und das Element nutzen kann
    print("die Zahl an der Stelle ", an_index, " ist ", an_element)
    

# Ein impliziter Loop erzeugt eine Liste
print("Die ersten paar Quadrate: ", [b**2 for b in range(100)])

# Variablen mit Wahrheitswert
is_it = True
it_is = False

# Ausgabe der Ergebnisse logischer Operationen
print("AND: ", it_is and is_it)
print("OR: ", it_is or is_it)

# IF-Statement, d.h. Abfrage ob etwas wahr oder falsch ist
if(it_is and is_it):
    
    # wenn Abfrage wahr ist, tu das:
    print("Kombiniert!")

# weitere Abfrage für zusätzliche Möglichkeiten
elif(it_is or is_it):
    
    # wenn das wahr ist, dann tu das:
    print("Nicht ganz!")
    
# und für alle andere Fälle
else:
    
    # wenn bisher nichts zugetroffen ist, dann tu das:
    print("Weder noch!")

# Definition eines Dictionary:
# Im Prinzip eine Sammlung von Zuordnungen von "values" zu "keys"
a_dict = {"Alice": 12, "Bob": 14}

# Ausgabe von Eigenschaften/values über keys
print("So alt ist Alice: ", a_dict["Alice"])

# Einträge in Dictionaries lassen sich hinzufügen
a_dict["Frank"] = 16

# und ändern
a_dict["Alice"] = 13

# Ausgabe des aktuellen Dictionary
print("Die aktuellen Werte: ", a_dict)

# values in Dictionaries können auch Dictionaries sein
another_dict = {"people": a_dict}

# so sieht ein verschachteltes Dictionary aus
print("Verschachteltes Dict: ", another_dict)

# Mathematische Funktionen ohne NumPy findet man hier:
import math as m

# andere Möglichkeiten für den Import:
# import math
# from math import sin, cos, exp

# Aber Achtung: Tun Sie das nie (Lebensgefahr!):
# from math import *

# Ausgabe des Sinus von Pi
print(m.sin(m.pi/2))

# Ausgabe der Exponentialfunktion von minus ein Halb
print(m.exp(-.5))

# NumPy stellt eine breite mathematische Funktionalität und Arrays bereit
import numpy as np

# Machen wir ein Array aus einer der Listen von oben
square_array = np.array(square_list)

# Ausgabe des Arrays
print(square_array)

# rechnen mit Arrays ist sehr intuitiv
# Hier die (elementweise) Multiplikation mit der Zahl 4
print(square_array*4)

# Hier das elementweise Quadrieren des Arrays
print(square_array**2)

# Hier der elementweise Logarithmus des Arrays
print(np.log(square_array))

# Hier die elementweise Exponentialfunktion des Arrays
print(np.exp(square_array))

# In NumPy findet man auch Zufallszahlen (mehr dazu in einer späteren Einheit), z.B.:

# Loop über 20 Runden
for i in range(20):
    
    # Wähle zwei Zahlen aus dem Array von vorhin, mit Zurücklegen
    a_selection = np.random.choice(square_array, 2, replace=True)
    
    # Gib das Ergebnis aus
    print(a_selection)
    
    # Überprüfe, ob die zwei gezogenen Zahlen zufällig gleich sind
    if a_selection[0] == a_selection[1]:
        
        # Wenn ja, bitte kurz jubeln!
        print("Yeee-Haaaa!")

# Arrays können auch mehrdimensional sein (die gewünschte Größe wird als Tupel angegeben):
another_array = np.random.random(size=(5, 5))

# Ausgabe dieses Zufallsarrays mit gleichverteilten Zahlen zwischen 0 und 1
print(another_array)

# Ein Array mit lauter 1en
some_ones = np.ones((5, 5))

# Ein Array mit lauter 0en
some_zeros = np.zeros((5, 5))

# Hier eine Art IF-Abfrage, aber elementweise für Arrays:
# wo das "andere Array" kleiner als 0.5 ist, schreibe eine 1 in den Check, 
# ansonsten schreibe dort eine 0 hinein
the_check = np.where(another_array < 0.5 * some_ones, some_ones, some_zeros)

# Ausgabe der 0en und 1en für das Check-Array
print(the_check)

# Summiere alle Fälle größer 0.5 und gib die Summe aus
print("größer als 1/2: ", np.sum(the_check))

# Die gleiche Summe, aber nur über die Spalten ausgeführt
# Die Ausgabe wird als Integer angefordert
print("pro Zeile: ", np.sum(the_check, axis=1).astype(int))

%matplotlib inline

# die vorige Zeile stellt den Ausgabe-Modus für Plots im Jupyter-Notebook ein

# Die Standart-Art, Matplotlib zu importieren
import matplotlib.pyplot as plt

# Beginne eine neue Figur/Grafik
fig = plt.figure()

# Zeichne rote Punkte von Daten aus dem Quadrat-Array, nochmals quadriert, mit Bezeichnung
plt.plot(np.arange(len(square_array)), square_array**2, "r.", label="Squares squared")

# Zeichne eine blaue Linie für Daten aus dem Quadrat-Array, mit Bezeichnung
plt.plot(np.arange(len(square_array)), square_array, "b-", label="Just Squares")

# Setze Beschriftung für die x-Achse fest
plt.xlabel("Numbers")

# Setze Beschriftung für die y-Achse fest
plt.ylabel("Squares?")

# Setze Beschriftung für den Plot fest
plt.title("A nice plot")

# Setze Skalierung für die y-Achse auf logarithmisch
plt.yscale("log")

# Erzeuge aus den Bezeichnungen eine Legende im Plot
plt.legend(loc=0)

# Speichere die Grafik als pdf-Datei ab
plt.savefig("test_plot.pdf")

# Zeige die Grafik außerdem hier an
plt.show()

# Erzeuge noch eine Figur
fig2 = plt.figure()

# Plotte die Werte im anderen Array als farbige Bild-Punkte bzw. -Quadrate
plt.matshow(another_array)

# zeige die Figur hier an
plt.show()

# Direkter Input durch den User, Achtung, das Resultat ist eine String-Variable
# an dieser Stelle wartet das Programm auf eine Eingabe
a_number = int(input("Bitte eine Zahl eingeben: "))

# Ausgabe des Quadrats der Eingabe
print("Das Quadrat Ihrer Zahl ist ", a_number**2)

# Lesen aus einer Datei (präzise, kann aber mühsam sein)
# Zunächst öffnen wir die Datei, diesmal mit der Fähigkeit zu Lesen ("r")
in_f = open("a_text_file.csv", "r")

# Ausgabe der Zeilen in der gelesenen Datei
print(in_f.readlines())

# Schließe die Datei wieder
in_f.close()

# NumPy hat eine gute und einfachere Alternative für das Einlesen
# von Dateien parat, z.B. im csv-Format:
new_array = np.genfromtxt("a_text_file.csv", dtype=int, delimiter=",", skip_header=1)

# Ausgabe des eingelesenen Dateiinhalts
print(new_array)

# initialisiere die Liste der Primzahlen mit 2, der einzigen geraden Primzahl
list_of_primes = [2]

# Berechne die derzeitige Anzahl der Primzahlen in der Liste
total_number = len(list_of_primes)

# Setze den Wert für den ersten zusätzlichen Kandidaten nach der 2
candidate = 3

# Ein While-Loop hilft dabei, die Abbruchbedingung (1000 Zahlen) umzusetzen
while total_number < 1000:
    
    # setzte die Eigenschaft "ist eine Primzahl" auf True
    is_prime = True
    
    # jetzt suchen wir nach Teilern, dadurch können wir diese Eigenschaft ggf. widerlegen
    # Loop über alle bisher gefundenen Primzahlen (denn nur die kommen eigentlich als
    # Teiler in Frage)
    for a_prime in list_of_primes:
        
        # checke, ob die momentane Primzahl größer ist als die Wurzel aus dem
        # Kandidaten, denn wenn das so wäre, kann sie kein Teiler mehr sein
        # (denn dann müsste es auch einen kleineren Teiler geben, und die
        # haben wir alle schon überprüft)
        if a_prime > np.sqrt(candidate):
            
            # Verlasse den innersten Loop, in dem wir uns gerade befinden
            break
        
        # checke, ob die momentane Primzahl den Kandidaten teilt
        if (candidate % a_prime == 0):
            
            # wenn wir einen Teiler finden, setzen wir die Prim-Eigenschaft auf False um
            is_prime = False
    
    # nachdem jetzt alle möglichen Teiler überprüft sind, checke die Prim-Eigenschaft
    if is_prime:
        
        # ist immer noch wahr, also hängen wir den Kandidaten an die Primzahl-Liste an
        list_of_primes.append(candidate)
        
    # wenn die Eigenschaft false ist, passiert nichts
    
    # berechne die aktuelle Anzahl der Primzahlen in der Liste
    total_number = len(list_of_primes)  
    
    # Erhöhe die Kandidaten-Zahl um 2 (d.h. gehe zur nächsten ungeraden Zahl)
    candidate += 2

# Gib die Primzahl-Liste aus
print(list_of_primes)

# Erzeuge eine neue Grafik
fig2 = plt.figure()

# Erzeuge ein Histogramm der ersten 1000 Primzahlen
plt.hist(list_of_primes, bins=50)

# Beschrifte die Achsen
plt.xlabel("Zahlenbereich")
plt.ylabel("Anzahl")

# Zeige die Grafik an
plt.show()