Das deutsche Python-Forum

Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/

Problem mit grossen Zahlenwerten

https://www.python-forum.de/viewtopic.php?t=5626

Seite 1 von 1

Problem mit grossen Zahlenwerten

Verfasst: Montag 3. April 2006, 17:02
von PelzMorph
Hallo alle zusammen,

so ich habe ein etwas gröberes Problem. Ich habe schon eine ganze Menge möglichkeiten ausprobiert aber dennoch vielleicht weiss hier jemand Rat:
Es ist so das ich ein "Programm" geschrieben habe, bzw angefangen, mit welchem Kepler Ellipsen ausgerechnet werden sollten.
Das Problem ist jetzt bei der Rechnung. Es werden merkwürdige Zahlenwerte ausgegeben, die eigentlich überhaupt nicht angehen können.
Ich stelle mal das ganze skript rein.
Nebenbei, der Button wird einfach ausgeführt obwohl ich ihn nie angeklickt habe o.ä.
Aber die Rechnung ist wichtiger;

Code: Alles auswählen

# -*- coding: cp1252 -*-

from Tkinter import *
from Formeln import *
from cmath import *
from re import *
from array import *

def rechnung():
    M2 = entryMDHO.get()   #'ab Hier werden sich neue Werte gekrallt
    Xpos = entryXposition.get()
    Ypos = entryYposition.get()
    Xvel = entryXgeschwindigkeit.get()
    Yvel = entryYgeschwindigkeit1.get()
    f = entryGravitationskonstante.get()

    WerteSpeicher = {} #Dient zum abspeichern der Zwischenergebnisse um direkt auf diese Variablen zugreifen zu können,

    #PosRech1 = (float(Ypos) ** 2) + (float(Xpos) ** 2) #Hier soll der Wert ausgerechnet werden um den Radius von dem GRavitationsobjekt zu sehen

    for i in xrange(100):   # Durchgänge in Sekunden
        if i == 0:   # Diese Bedingung muss sein, damit einmal alle Variablen einen Wert bekommen haben und diese Werte auch im DIctionary "WerteSpeicher" abgespeihchert sind damit die
                       #zweite Schleife mit den Werten richtig umgehen kann.
            
        
            PosRech = (float(Ypos) ** 2) + (float(Xpos) ** 2) #Hier soll der Wert ausgerechnet werden um den Radius von dem GRavitationsobjekt zu sehen
            rabsta = sqrt(PosRech)
            abesch = beschleunigunga (float(f), rabsta, float(M2))
            ybesch = beschleunigungy (abesch, float(Ypos), rabsta)          #AUsrechnung aller Variablen die man braucht
            xbesch = beschleunigungx (abesch, float(Xpos), rabsta)
            xveloc = geschwindigkeitsaenderungx (xbesch, i)
            yveloc = geschwindigkeitsaenderungy (ybesch, i)
            vrelat = relativgeschwindigkeit (xveloc, yveloc)
            
            

            neuesvx = xveloc
            neuesvy = yveloc        #Geschwindigkeitsberechnungsänderung

            WerteSpeicher['RadiusR'] = rabsta
            WerteSpeicher['BeschleunigungA'] = abesch
            WerteSpeicher['BeschleunigungY'] = ybesch       #An dieser Stelle wird das erste mal der Dicionairy gefüllt!
            WerteSpeicher['BeschleunigungX'] = xbesch
            WerteSpeicher['GeschwindigkeitX'] = xveloc
            WerteSpeicher['GeschwindigkeitY'] = yveloc
            WerteSpeicher['RelativeGeschwindigkeit'] = vrelat
            WerteSpeicher['YPosition'] = float(Ypos) # Um das erste mal eine YPosition zu speichern die dann in der anderen schleife weiter fortgeführt wird.
            WerteSpeicher['XPosition'] = float(Xpos) # Um das erste mal eine XPosition zu speichern die dann in der anderen schleife weiter fortgeführt wird.
            
        


            anzeigetafel.insert(END, 'ABSTAND R=>'+ str(rabsta) + " \n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNG A=>'+ str(abesch) + "\n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNGY=>'+ str(ybesch) + "\n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNGX=>'+ str(xbesch) + "\n")           #Ausgabe der Werte
            anzeigetafel.insert(END, 'GESCHWINDIGKEITX=>'+ str(neuesvx) + "\n")
            anzeigetafel.insert(END, 'GESCHWINDIGKEITY=>'+ str(neuesvy) + "\n")
            anzeigetafel.insert(END, 'GESCHWINDIGKEITRELA=>'+ str(vrelat) + "\n")
            if i > 0:
                anzeigetafel.insert(END, 'XPOSITION=>'+ str(XposNeu) + "\n")
            anzeigetafel.insert(END, "---------------\n")

        else:
            PosRech2 = ((WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN')) ** 2) + ((WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN')) ** 2)  #Berechnung der Position um den Radius r zu berechnen
            rabsta = sqrt(PosRech2)
            WerteSpeicher['RadiusR'] = rabsta   # Hier wird der neue Radius in die SpeicherDictionary eingetragen. Folgender Vorteil, alle folgenden Elemente haben gleich einen aktuellen Radius r.

            abesch2 = beschleunigunga (float(f), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN'), float(M2)) # Die neue Beschleunigung a
            WerteSpeicher['BeschleunigungA'] = abesch2 # Aktualisierung der Beschleunigung

            ybesch2 = beschleunigungy (WerteSpeicher.get('BeschleunigungA', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN'))
            #Berechnung der Y Beschleunigung mithilfe der in der "WerteSpeicher" abgespeicherten Daten
            WerteSpeicher['BeschleunigungY'] = ybesch2 #Aktualisierung der Werte
            

            xbesch2 = beschleunigungy (WerteSpeicher.get('BeschleunigungA', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('RadiusR', 'FEHLER NICHT GEFUNDEN')) 
             #Das gleiche wie bei der YBeschleunigung
            WerteSpeicher['BeschleunigungX'] = xbesch2 #Aktualisierung des Wertes

            xveloc2 = geschwindigkeitsaenderungx (WerteSpeicher.get('BeschleunigungX', 'FEHLER NICHT GEFUNDEN'), i)
             #GEschwindigkeit in X Richtung. Wichtig für die Positionsänderung
            WerteSpeicher['GeschwindigkeitX'] = xveloc2

            yveloc2 = geschwindigkeitsaenderungy (WerteSpeicher.get('BeschleunigungY', 'FEHLER NICHT GEFUNDEN'), i)
             #Geschwindigkeit in Y Richtung. Wichtig für die Positionsänderung
            WerteSpeicher['GeschwindigkeitY'] = yveloc2

            vrelat2 = relativgeschwindigkeit (WerteSpeicher.get('GeschwindigkeitX', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitY', 'FEHLER NICHT GEFUNDEN'))
             #Die Relativgeschwindigkeit
            WerteSpeicher['RealativeGeschwindigkeit'] = vrelat2 # AKtualisierung der Werte

            xposi = xyposgeschwin (WerteSpeicher.get('XPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitX', 'FEHLER NICHT GEFUNDEN'), i)
             #Hier wird die neue XPosition errechnet
            WerteSpeicher['XPosition'] = xposi

            yposi = xyposgeschwin (WerteSpeicher.get('YPosition', 'FEHLER NICHT GEFUNDEN'), WerteSpeicher.get('GeschwindigkeitY', 'FEHLER NICHT GEFUNDEN'), i)
             #Hier wird die neue XPosition errechnet
            WerteSpeicher['YPosition'] = yposi

            anzeigetafel.insert(END, 'ABSTAND R=>'+ str(rabsta) + " \n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNG A=>'+ str(abesch2) + "\n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNGY=>'+ str(ybesch2) + "\n")
            anzeigetafel.insert(END, 'BESCHLEUNIGUNGX=>'+ str(xbesch2) + "\n")           #Ausgabe der Werte
            anzeigetafel.insert(END, 'GESCHWINDIGKEITX=>'+ str(xveloc2) + "\n")
            anzeigetafel.insert(END, 'GESCHWINDIGKEITY=>'+ str(yveloc2) + "\n")
            anzeigetafel.insert(END, 'GESCHWINDIGKEITRELA=>'+ str(vrelat2) + "\n")
            if i > 0:
                    anzeigetafel.insert(END, 'XPOSITION=>'+ str(xposi) + "\n")
                    anzeigetafel.insert(END, 'YPOSITION=>'+ str(yposi) + "\n")
            anzeigetafel.insert(END, "---------------\n")

             

#AUFRUF DES KONSTRUKTORS FÜR EIN FENSTER
hauptfenster = Tk()
hauptfenster.title("Kepler Ellipsen, SimulationsSoftware")



# DER GESAMTE TEXT FÜR DIE EINTRÄGE
Label(hauptfenster, text="MDHO : ", pady=10).grid(row=0,column=0)

Label(hauptfenster, text="XPosition : ", pady=10).grid(row=1,column=0)

Label(hauptfenster, text="YPosition : ", pady=10).grid(row=2,column=0)

Label(hauptfenster, text="XGeschwindigkeit : ", pady=10).grid(row=0,column=5)

Label(hauptfenster, text="YGEschwindigkeit : ", pady=10).grid(row=1,column=5)

Label(hauptfenster, text="Gravitationskonstante : ", pady=10).grid(row=2,column=5)

#DAS TEXTWIDGET, UM SPÄTER ERGEBNISSE ANZUZEIGEN UND ABZUSPEICHERN
scroll_y = Scrollbar(hauptfenster, orient=VERTICAL)

anzeigetafel = Text(hauptfenster, width=50, height=30, yscrollcommand=scroll_y.set)
anzeigetafel.grid(row=4, column=5)

#DIE ENTRY FELDER UM EINGABEN ZU TÄTIGEN
PlaniMasse=DoubleVar()
PlaniMasse.set(1989000000000000000000000000000.0)
                                             
XPosition=DoubleVar()
XPosition.set(147100000.0)
                                             
YPosition=DoubleVar()
YPosition.set(14234100000.0)
                                             
XGeschwindigkeit=DoubleVar()
XGeschwindigkeit.set(0.0)
                                             
YGeschwindigkeit=DoubleVar()                                #Hier werden den Entrys Varaiblen übergeben. Funktioniert noch nicht 100%
YGeschwindigkeit.set(30.290)
                                             
GravitationsKonstante=DoubleVar()
GravitationsKonstante.set(0.0000000000000000667)


entryMDHO=Entry(hauptfenster, textvariable=PlaniMasse)
entryMDHO.grid(row=0,column=1)


entryXposition=Entry(hauptfenster, textvariable=XPosition)
entryXposition.grid(row=1,column=1)


entryYposition=Entry(hauptfenster, textvariable=YPosition)
entryYposition.grid(row=2,column=1)


entryXgeschwindigkeit=Entry(hauptfenster, textvariable=XGeschwindigkeit)
entryXgeschwindigkeit.grid(row=0,column=6)


entryYgeschwindigkeit1=Entry(hauptfenster, textvariable=YGeschwindigkeit)
entryYgeschwindigkeit1.grid(row=1,column=6)


entryGravitationskonstante=Entry(hauptfenster, textvariable=GravitationsKonstante)
entryGravitationskonstante.grid(row=2,column=6)

# DEr STARTBUTTON DER ALLES ZUM ANFANG BRINGT
anfangbutt = Button(hauptfenster, text="REchnungstarten", command=rechnung())   #Der semioptimale Button um eine Rechnung zu starten
anfangbutt.grid(row=6, column=1)

# DAMIT DAS HAUPTFENSTER AM LEBEN BLEIBT
hauptfenster.mainloop()
SO jetzt noch die importierten Formeln:

Code: Alles auswählen

# -*- coding: cp1252 -*-
# KEPLER BERECHNUNGSFORMELN UND FUNKTIONEN
from cmath import *

# Beschleunigung des Himmelskörpers:

def beschleunigunga (f, r, M):
    radius=r**2
    ##abs(radius)
    faktor=M/radius
    a = f*faktor
    return a

# Momentaner Abstand zum GravitationsZentrum:

#def abstandr (xs, ys):
#    r = sqrt((xs ** 2) + (ys ** 2))
#   return r

# Y Beschleunigung

def beschleunigungy (a, ys, r):
    ay = a*(ys/r)
    return ay

# X BEschleunigung

def beschleunigungx (a, xs, r):
    ax = a*(xs/r)
    return ax

def geschwindigkeitsaenderungx (ax, t):
    neuesvx = ax * t
    return neuesvx

def geschwindigkeitsaenderungy (ay, t):
    neuesvy = ay * t
    return neuesvy

def relativgeschwindigkeit (vx, vy):
    zwischenrech = (vx ** 2) + (vy ** 2)
    vrel = sqrt(zwischenrech)
    return vrel

def xyposgeschwin (xypos1, vx, t):
    xypos = xypos1 + vx * t
    return xypos
Vielen Dank schonmal!

EDIT:::>
Hier ist eine Stichprobe von den Werten, welche ausgegeben werden.
Es ist die erste ausgabe. Daran sieht man mit was für merkwürdigen werten gerechnet wird.

Code: Alles auswählen

ABSTAND R=>(14234860070.3+0j) 
BESCHLEUNIGUNG A=>(6.54717896417e-007+0j)
BESCHLEUNIGUNGY=>(6.54682937759e-007+0j)
BESCHLEUNIGUNGX=>(6.76571473746e-009+0j)
GESCHWINDIGKEITX=>(6.76571473746e-009+0j)
GESCHWINDIGKEITY=>(6.54682937759e-007+0j)
GESCHWINDIGKEITRELA=>(6.54717896417e-007+0j)
XPOSITION=>(147100000+0j)
YPOSITION=>(14234100000+0j)

Verfasst: Montag 3. April 2006, 18:03
von Leonidas
Das ist eben das Problem, wenn man die Programm-Logik mit der GUI koppelt: die GUI geht nicht, die Algorytmen gehen nicht und das zu debuggen ist auch schwer. :(

Versuch doch mal den ganzen Rechnen-Kram auszulagern, soweit es geht. Dann kannst du diesen Teil debuggen und dann dich um die GUI kümmern.

Verfasst: Montag 3. April 2006, 18:53
von PelzMorph
Mh,

also das auslagern der Rechnung ist nicht so das Problem.
Das kann einfach mit in die Formel.py mit rein.
Denke ich.
Aber das mit den Zahlen ist trotzdessen komisch :)

EDIT:
So einfach dann doch nicht, erstma mit den Variablen schauen...
das schon wieder ein nerv;) Aber kein Problem;) Man muss das einfach mit Parametern im AUfruf machen. Allerdings gestaltet sich die Werte Rückgabe schwer. Kann ich mit einem "return" auch einfach alle ausgerechnetten werte ausgeben damit diese dann nacheinander herausgenommen werden? ODer sollte man lieber sowas wie ein Dicionary zurückgeben?
Alle Zeiten sind UTC+01:00
Seite 1 von 1

Powered by phpBB® Forum Software © phpBB Limited

Deutsche Übersetzung durch phpBB.de