Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen gezeigt.

--- ws1920:arbeitstermin_03 [2020/02/09 20:14]
Zetraeder angelegt
+++ ws1920:arbeitstermin_03 [2020/03/25 16:57] (aktuell)
Zetraeder
@@ Zeile 1: / Zeile 1: @@
+----
 ====== Dritter Arbeits-Termin ======
 **12.12.2019**
+[[ws1920:arbeitstermin_02|<<]] | [[ws1920:scutoids|Home]] | [[ws1920:cd_03|Code]] | [[ws1920:arbeitstermin_04|>>]]
 Wir haben heute versucht, die Methode für Schnittpunkte in unser Hauptprogramm zu implementieren, was leider noch nicht funktioniert hat. Es wurden mehrere andere Probleme aufgeworfen, zum Beispiel dass Geraden nicht aus der Geradenliste gelöscht werden, selbst wenn sie als sich schneidend erkannt wurden.
 Zu nächster Woche haben wir uns vorgenommen, eine Methode zu schreiben, die testen kann, ob ein Punkt x auf einer Geraden g liegt.
-<code python>
-# -*- coding: utf-8 -*-
-"""
-Created on Thu Nov 28 15:22:24 2019
-@author: Lukas
-"""
-import numpy as np
-import math
-from math import *
-import turtle
-import random as rn
-from scipy.spatial import distance
-turtle.speed(100)
-turtle.ht()
-#
-anzahlKerne = 4
-class Gerade(object):
-    ov = (0,0,0)    #Ortsvektor
-    rv = (0,0,0)    #Richtungsvektor
-    l = 0;          #Laenge
-###   Zuerst sollen n mal random punkte (x,y) in einem Feld maxx*maxy generiert werden und einer Liste zugewiesen werden
-def generiereKernListe(n,maxx,maxy,abstand):
-    liste=[]
-    for c in range(n):
-        x = rn.randint(-maxx,maxx)#rn.uniform(0,maxx)
-        y = rn.randint(-maxy,maxy)#rn.uniform(0,maxy)
-        #if (len(liste) > 0):
-        #    try:
-        #        for x in len(liste):
-        #            if (distance.euclidean(liste[x],(x,y)) < abstand == True):
-        #                print("good")
-        #            else:
-        #                raise Exception("Fehler")
-        #        liste.append((x,y))
-        #    except:
-        #        x = rn.uniform(0,maxx)
-        #        y = rn.uniform(0,maxy)
-        #        continue
-        #    break
-        #else: liste.append((x,y))
-        liste.append((x,y))
-    return liste
-ker = generiereKernListe(anzahlKerne,300,300,0.1)
-print("Kerne : ",ker)
-###   Zunächst werden Funktionen deklariert, mit deren Hilfe das Programm Linien zwischen den Punkten untersucht
-def zeichneLinie(start,ende):
-    #   zeichnet eine Linie zwischen start und ende mithilfe einer turtle
-    turtle.penup()
-    turtle.goto(start)
-    turtle.pendown()
-    turtle.goto(ende)
-def richtungLinie(start,ende):
-    #   gibt den Richtungsvektor von start nach ende aus
-    richtung  = np.subtract(ende,start)
-    return richtung
-def schnittTest(g1,g2):
-    return np.linalg.solve([[g2.rv[0],-g1.rv[0]],[g2.rv[1],-g1.rv[1]]],[[g1.ov[0]-g2.ov[0]],[g1.ov[1]-g2.ov[1]]])
-def vektorLänge(v2):     #Wir erwarten Start- und Endpunkt eines Vektors
-    #   errechnet die Laenge eines Vektors
-    v1 = np.array([0,0])
-    math.sqrt((abs(v1[0]-v2[0])**2)+(abs(v1[1]-v2[1])**2))
-def vektorNorm(v):
-    return(1/sqrt(v[0]**2+v[1]**2)*v)
-def punktAufG(p, g):
-    return np.roots([g.rv[0],g.ov[0]-p[0]])
-#z = np.zeros(2)
-#print(np.array([1,2]))
-a = (0,0)
-b = (30,30)
-c = (50,0)
-d = (50,70)
-#Linien = [a,b,c,d]
-#zeichneLinie(a,b)
-#zeichneLinie(c,d)
-#print(richtungLinie(c,b))
-listeGeraden = []
-for i in range(anzahlKerne):
-    for k in range(anzahlKerne):
-        if (i!=k):
-            #zeichneLinie(ker[i],ker[k])
-            #name = str(i)+" und "+str(k)
-            eineGerade = Gerade()
-            eineGerade.ov = np.array(ker[i])
-            eineGerade.rv = np.subtract(ker[k],ker[i])
-            eineGerade.l  = vektorLänge(eineGerade.rv)
-            listeGeraden.append(eineGerade)
-            #print(name)
-print(listeGeraden)
-print(listeGeraden[0].ov)
-print(listeGeraden[0].rv)
-print(listeGeraden[0].rv[0])
-#print("Gerade 0 und 1 schneiden sich bei",schnittTest(listeGeraden[0],listeGeraden[49]))
-counter = 0
-schnitt = 0
-#testet, welche geraden gelöscht werden sollen
-for i in range(0, len(listeGeraden)):
-    for k in range(0, len(listeGeraden)):
-        counter=counter+1
-        #   parallele Richtungsvektoren aussortieren MUSS NOCH GEMACHT WERDEN
-        #if (vektorNorm(listeGeraden[i].rv) == vektorNorm(listeGeraden[k].rv)):
-        #    try:
-        #        punktAufG(listeGerade[i].ov,listeGeraden[k])
-            #   dann testen ob ov des einen auf der anderten gerade liegt
-        #   Werte der gerade ausgeben
-        print("\ni.rv",listeGeraden[i].rv)
-        print("i.ov",listeGeraden[i].ov)
-        print("k.rv",listeGeraden[k].rv)
-        print("k.ov",listeGeraden[k].ov)
-        #   schneiden sich die Linien?
-        z = schnittTest(listeGeraden[i],listeGeraden[k])
-        print(z)
-        if (z[0]<1 and z[0]>0 and z[1]<1 and z[1]>0):
-            schnitt=schnitt+1
-            #del listeGeraden[i]   #ACHTUNG: EIGENTLICH SOLL DIE LÄNGERE GELÖSCHT WERDEN
-                #if (listeGeraden[i].l < listeGeraden[k].l):
-                #    del listeGeraden[k]
-                #else: del listeGeraden[i]
-print(counter, " Schnitte : ", schnitt)
-print(listeGeraden)
-for i in range(0, len(listeGeraden)):
-    zeichneLinie(listeGeraden[i].ov,listeGeraden[i].ov+listeGeraden[i].rv)
-#zeichneLinie(ker[0],ker[1])
-#zeichneLinie(ker[1],ker[2])
-#zeichneLinie(ker[2],ker[0])
-#zeichneLinie((10,40),(50,150))
-###     das eigentlihe programm
-turtle.done()
-</code>
-[Hung] Code für Normieren von Vektoren
-<code python>
-import numpy as np
-from math import sqrt
-v=np.array([3,4])
-v1=np.array([4,3])
-print(1/sqrt(v[0]**2+v[1]**2)*v)
-print(1/sqrt(v1[0]**2+v1[1]**2)*v)
-</code>
-----
-====== Code - Schnipsel ======
-[Lukas] punktAufLinie - Methode
-.12.2019
-<code python>
-#   liegt punkt p auf der geraden g = o + m*r?
-def punktAufLinie(p,o,r):
-    if(np.array_equal(p,o)): return True
-    elif(np.array_equal(r,[0,0])): return False
-    elif(r[1] == 0):
-        a = (p[0]-o[0])/r[0]
-        if (o[1]+a*r[1] == p[1]):
-            if(a<=1 and a>=0): return True
-            else: return False
-        else: return False
-    else:
-        a = (p[1]-o[1])/r[1]
-        if (o[0]+a*r[0] == p[0]):
-            if(a<=1 and a >=0): return True
-            else: return False
-        else: return False
-</code>
 ----

Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Unterschiede

Seiten-Werkzeuge