<jupyter_start><jupyter_text>Einblick in das Rechnen mit aglavon <NAME> - <EMAIL>Diese Arbeit steht unter der freien Lizenz [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.de)   Konstruktion regelmäßiger VieleckeDas Paket agla ist in der Programmiersprache Python geschrieben und basiertauf dem ebenfalls in Python geschriebenen und quelloffen frei verfügbaren CAS SymPy Für die geometrischen Objekte wurden Python-Klassen im Sinne der Objekt-Orientierten-Programmierung implementiert. Damit können entsprechende Python-Objekte erzeugt werden, mit denen unter Verwendung ihrer Eigenschaften und Methoden am Computer gearbeitet wird Die Berechnungen werden in einem Jupyter-Notebook (mit englischer Bedienoberfläche) durchgeführt; die vorliegende Datei wurde durch den HTML- Export eines solchen Notebooks hergestellt Die Kommentare (nach ) sind lediglich Erläuterungen und für die Berechnungen nicht relevant, Analoges trifft auf die Kontrollausgaben zu<jupyter_code>%run agla/start   # Aktivierung des Paketes<jupyter_output><empty_output><jupyter_text>1. Konstruktion von gleichseitigen Dreieckenin der Ebene und in der $xy$-Ebene des RaumesAusgehend von zwei Punkten $A$ und $B$ wird die Lage des dritten Punktes $C$ auf der Mittelsenkrechten der Grundseite berechnet  Berechnungen in der EbeneZunächst wird eine einfache Grundseite auf der $x$-Achse gewählt, um die Berechnung leicht nachvollziehen zu können<jupyter_code>A = v(0, 0); B = v(1, 0)   # gegebene Punkte (sie werden mit ihren 
                           # Ortsvektoren identifiziert)

c = Strecke(A, B)          # die Grundseite des Dreiecks

M = c.mitte                # der Mittelpunkt von c 
M                          # Kontrollausgabe  
ms = c.gerade.normale(M)   # die Mittelsenkrechte im Punkt M 
    
-ms.koord   #  Geradengleichung in Koordinatenform; Kontrollausgabe
# Der gesuchte Punkt C ist Punkt der Mittelsenkrechten mit  
# irgendeinem Parameterwert t

C = ms.pkt(t)

C   # Kontrollausgabe<jupyter_output><empty_output><jupyter_text>Die Gleichung zum Auffinden von t ergibt sich aus der Bedingung der Gleichseitigkeit des Dreiecks, also$\qquad$Abstand zwischen A und C = Länge von c     (für B ergibt sich der gleiche Abstand)Für die Auflösung muss sie so umgeformt werden, dass die rechte Seite gleich 0 istzu schreiben ist dann nur die linke Seite<jupyter_code>L = löse(Abstand(A, C) - c.länge)
L<jupyter_output><empty_output><jupyter_text>Das Ergebnis wird als Liste mit zwei Elementen (für die  beiden Lösungen) dargestelltJedes Element ist eine Schlüssel-Wert-Liste (ein Python-*dictionary*) mit nur einem EintragDer Zugriff auf die positive Lösung erfolgt zunächst über den Index in der Liste (1, da Python ab 0 zählt) und danach über den Schlüssel (t):<jupyter_code>t0 = L[1][t]

t0   # Kontrollausgabe
C = ms.pkt(t0)

C   # der gesuchte Punkt<jupyter_output><empty_output><jupyter_text>Das Dreieck mit den Eckpunkten A, B und C ist in der Tat gleichseitig:<jupyter_code>d = Dreieck(A, B, C)

d.längen, d.winkel   # die Seitenlängen und Innenwinkel von d

sicht_box(-0.5, 1.5)
zeichne([d, 2])<jupyter_output><empty_output><jupyter_text>Werden die Koordinaten von $A$ und $B$  geändert und alle Berechnungen erneut durchgeführt, kann man sich überzeugen, dass sie für eine beliebige Lage der beiden Punkte zum Ergebnis führen Zur Anwendung in der $xy$ - Ebene des Raumes sind folgende Änderungen zu machen:* die Ausgangspunkte $A$ und $B$ erhalten als dritte Koordinate $0$* eine $normale$-Methode für Geraden ist dort nicht definiert; die Richtung der   Mittelsenkrechten muss anders ermittelt werden * ebenfalls nicht definiert ist die $koord$-Eigenschaft für Geraden, wohl aber die $prg$-  Eigenschaft (zur Anzeige der Parametergleichung); diese ist auch in der Ebene   verfügbar:<jupyter_code>ms.prg<jupyter_output><empty_output><jupyter_text>Berechnungen im allgemeinen Fall Mit den angeführten Änderungen wird ein im Sinne der Aufgabenstellung allgemeingültiger Algorithmus erarbeitet. Dieser wird als Python-Funktion bereitgestellt, die das erzeugte Dreieck zurückgibt<jupyter_code># Definition der Funktion

# Parameter sind die Endpunkte der Ausgangsstrecke

# Es wird die dim-Eigenschaft (Dimension) benutzt, die alle 
# agla-Objekte haben

def gleich_seitiges_dreieck(A, B):
    
    c = Strecke(A, B) 
    M = c.mitte
    
    ri = c.gerade.richt   # Richtungsvektor der Tägergeraden von c
    if A.dim == 2:        # Unterscheidung R^2 und R^3
        norm = Vektor(-ri.y, ri.x)   # Normalenvektor der Strecke
    else:
        norm = Vektor(-ri.y, ri.x, 0)
         
    ms = Gerade(M, norm)
    C = ms.pkt(t)
    
    L = löse(Abstand(A, C) - c.länge)   
    t0 = L[1][t]                         

    C = ms.pkt(t0)
    
    return Dreieck(A, B, C)<jupyter_output><empty_output><jupyter_text>Beispiele für den Gebrauch der Funktion<jupyter_code># Aufruf der Funktion in der Ebene

A = v(-1, 0); B = v(2, 2)

dd = gleich_seitiges_dreieck(A, B)   

dd.punkte, dd.längen, dd.winkel

sicht_box(-3, 5)
zeichne( dd, A, B, [Strecke(A, B), rot, 2])
         
# Aufruf der Funktion im Raum

ddd = gleich_seitiges_dreieck(v(-3, -4, 0), v(2, 3, 0))   

ddd.punkte, ddd.längen, ddd.winkel

sicht_box(10)
zeichne([ddd, blau, 2], xy_gitter=ja)<jupyter_output><empty_output><jupyter_text>Für den eventuell beabsichtigten allgemeinen Gebrauch der Funktion fehlen nur noch Eingabekontrollen bezüglich der Argumente und die Einbindung der Funktion indie Arbeitsumgebung des Anwenders(deutsche Umlaute und veränderte Operatoren sind dann nicht mehr zu verwenden) Man kann sich überlegen, dass bei rationalen Koordinaten von $A$ und $B$ mindestens eine der Koordinaten von $C$ eine irrationale Zahl (Wurzelausdruck) ist. Somit besteht schon bei dieser einfachen Aufgabe die Notwendigkeit, mit irrationalen Koordinaten von Punkten bzw. Komponenten von Vektoren rechnen zu können  2. Konstruktion von regelmäßigen Vielecken am Beispiel von FünfeckenDie Eckpunkte eines n - Ecks werden durch die Teilung des Umkreises in n gleicheTeile gewonnen  Umkreis ist der Einheitskreis<jupyter_code>k = EinhKreis2; k.mitte, k.radius  # der Einheitskreis ist vordefiniert
k.pkt(t)   # der allgemeine Punkt des Kreises; t - Winkel in Grad<jupyter_output><empty_output><jupyter_text>Das Fünfeck wird anhand einer Liste von aufeinander folgenden Punkten erzeugt<jupyter_code>n = 5   # die Anzahl der Ecken

Fünfeck = fe = Figur( [ k.pkt(i * 360/n) for i in (0, 1, 2, 3, 4, 5) ] )   
                                             # in range(n+1) ist möglich<jupyter_output><empty_output><jupyter_text>Die Liste der Eckpunkte der (geschlossenen) Figur ist<jupyter_code>pfad = fe.pfad; pfad<jupyter_output><empty_output><jupyter_text>Die Abstände benachbarter Punkte sind gleich:<jupyter_code>[ Abstand(pfad[i], pfad[i+1]) for i in range(n) ]<jupyter_output><empty_output><jupyter_text>Die Werte sind scheinbar unterschiedlich. Der nummerische "Nachweis" der Gleichheitreicht eventuell in der Schule aus<jupyter_code>[ Abstand(pfad[i], pfad[i+1], d=10) for i in range(n) ]<jupyter_output><empty_output><jupyter_text>Auch der symbolische Nachweis ist hier unmittelbar möglich(die Funktion einfach beruht auf den SymPy-Funktionen zur Vereinfachung simplify, nsimplify, ...)<jupyter_code>[ einfach(Abstand(pfad[i], pfad[i+1]), num=ja) for i in range(n) ] 

sicht_box(1.5)
zeichne(fe)<jupyter_output><empty_output><jupyter_text>Konstruktion eines Fünfecks mit vorgegebener Seitenlänge $a$Die Konstruktion wird auf der Basis des oben erhaltenen Fünfecks mittels einer zentrischen Streckung durchgeführt; eine Formel für den Streckfaktor wird gewonnen<jupyter_code>fe1 = fe.bild(streckung(O2, f))   # O2 - Ursprung, f - Streckfaktor
ecken = fe1.ecken; ecken<jupyter_output><empty_output><jupyter_text>Ermittlung einer Formel für den Streckfaktor, um die vorgegebene Seitenlänge $a$ zu erhaltenDie Bedingung führt auf die Gleichung $\qquad$Abstand(ecke1, ecke2) = aDie rechte Seite wird zu 0 gemacht, da nur die linke Seite interessiert und Python ab 0 zählt, wird notiert<jupyter_code>gl = Abstand(ecken[0], ecken[1]) - a   # Gleichung für f,
gl                                     # rechte Seite wird = 0 angenommen
L = löse(gl, f); L    # Auflösung 
ff = L[1][f]; ff   # der berechnete positive Faktor
f2 = ff.subs(a, 2); f4 = ff.subs(a, 4)  # 2 verschiedene Seitenlängen
f2, f4                      
fe2 = fe.bild(streckung(O2, f2))   # Fünfeck mit der Seitenlänge 2
fe4 = fe.bild(streckung(O2, f4))   # ebenso, 4
sicht_box(5)
zeichne(fe, [fe2, rot], [fe4, grün])
fe3 = fe2.bild(drehung(O2, 90))   # Erzeugung einer "gewohnten" lage
                            
sicht_box(-2.5, 2)
zeichne([fe3, 'lemonchiffon', 'füll=ja'], fe3, achsen=nein)<jupyter_output><empty_output><jupyter_text>Nachweis der Regelmäßigkeit des Fünfecks *fe3*: die Abstände benachbarter Punkte sind alle gleich 2<jupyter_code>pfad = fe3.pfad; pfad
[ Abstand(pfad[i], pfad[i+1]) for i in range(n) ]<jupyter_output><empty_output><jupyter_text>Die Ungleichheit ist nur scheinbar<jupyter_code>[ einfach(Abstand(pfad[i], pfad[i+1]), num=ja) for i in range(n) ]<jupyter_output><empty_output><jupyter_text>Mit etwas mehr Aufwand gelingt der Nachweis gleicher Längen auch bei unbestimmtem a (das wird hier nicht durchgeführt)  Übertragung in die $xy$ - Ebene des Raumes<jupyter_code>e4 = [v(p.x, p.y, 0) for p in fe3.ecken]; e4   # die Eckenliste
fe4 = Körper(e4, fe.kanten)   # ein ebener Körper<jupyter_output><empty_output><jupyter_text>(Eine Körper-Instanz wird formal durch eine Menge von Punkten und eine Menge von Verbindungen zwischen den Punkten (Kanten) definiert. Die Kantenliste ist dieselbe wie beim Ausgangs-Fünfeck):<jupyter_code>fe.kanten
sicht_box(3)
zeichne([fe4, gelb, 'füll=ja'])<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.08360622185837085, 'fraction_numerical': 0.012075317232910356, 'mean_word_length': 4.636101499423298, 'pattern_counts': {'":': 0, '<': 83, '<?xml version=': 0, '>': 83, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '20', 'dir': 'jupyter-structured-clean-dedup', 'id': '475669', 'license': 'Apache-2.0', 'n_tokens_mistral': 3716, 'n_tokens_neox': 3803, 'n_words': 1067, 'path': 'agla/demo/ipynb/b_regulaere_vielecke.ipynb', 'repo_name': 'HBOMAT/AglaUndZufall', 'size': '9790'}