Mantissenlänge varieren

[kbr]

@loyloep: Ich gewinne den Eindruck, Du möchtest mittels einer Programmiersprache, die Du nicht lernst, etwas berechnen, was Du nicht verstehst. Da lässt sich doch was gegen tun!

Wenn Du eine Fehlermeldung erhältst, dann teile diese mit.
Und wenn Du eine Lösung gefunden hast, dann diese gleichfalls.

Wenn Du aber etwas nicht verstehst (was im Lernvorgang normal ist), deswegen zu Deinem alten Ansatz zurückkehrst, der fehlerhaft ist und den Du offensichtlich auch nicht verstehst, dann wird das mit dem Lernprozess schwierig. Dann kommt auch denjenigen, die Dir hier aus freien Stücken helfen, die Motivation abhanden.

[Gelöscht2200]

Ich habe nun wieder das Programm abegändert. Bis auf die

Code: Alles auswählen

while

-Schleife funktioniert es auch. Das Ergebnis ist identisch mit dem Ergebnis aus dem vorherigen Programm.

Code: Alles auswählen

from __future__ import division
from decimal import Decimal, getcontext
from sympy import *

import numpy as np
import decimal
import json

        

def integral(a,n,m):              # Methode (Berechnung der Integral-Annäherungsformel)
        y = 0
        getcontext().prec = m     # Mantissenlänge (Präzision)
        for i in range(1,n):
                n += Decimal(1)
                y = Decimal(1)/Decimal(n) - Decimal(a) * Decimal(y)        # Integral-Annäherungsformel
                print ("y: ", y)
               # while m < 20:
               #         integral(a,n,m+2)

integral(10,10,6)

[BlackJack]

@loyloep: Das sieht schon wieder geraten aus. Was sollte die Schleife denn an der Stelle im Programm bewirken? Geh doch mal ein bisschen strukturierter an das Problem. Und die Variation der Präzision soll sicher nicht rekursiv gelöst werden sondern die Berechnung der Näherungsfunktion. Und daraus solltest Du vielleicht mal eine Funktion machen, also eine echte Funktion die etwas berechnet und das Ergebnis zurück gibt und nichts ausgibt.

[BlackJack]

@loyloep: Die Funktion sieht auch ohne die ``while``-Schleife komisch aus. Warum wird `i` von 1 an gezählt, aber nicht verwendet? Soll `n` wirklich hochgezählt werden? Also von `n` an? Und nicht eigentlich `i` sein?

Und die feste Anzahl von Schritten ist für eine Näherungsformel auch ungewöhnlich, denn normalerweise will man ja so lange rechnen bis das Ergebnis eine gewisse Qualität erreicht hat.

[Gelöscht2200]

Hier ist mein verbessertes Programm. Es kann nun auch Daten von einem Json-File einlesen und gibt nu noch das Ergebnis aus:

Code: Alles auswählen

from __future__ import division

from decimal import Decimal, getcontext
from sympy import *

import numpy as np
import decimal
import json
from pprint import pprint
import os, sys


with open('data.json') as readJson:    
    data = json.load(readJson)

pprint(data)
        
a = data["Variable"]
n = data["Wiederholung"]
m = data["Mantisse"]


def integral(a,n,m):	          # Methode (Berechnung der Integral-Annaeherungsformel)
        y = 0
        getcontext().prec = m     # Mantissenlaenge (Praezision)
        for i in range(1,n):
                n += Decimal(1)
                y = Decimal(1)/Decimal(n) - Decimal(a) * Decimal(y)        # Integral-Annaeherungsformel
        print ("y: ", y)
                #if m < 20:
                #        integral(a,n,m+2)

integral(a,n,m)			# Aufruf der Methode integral(a,n,m)

Ich bin unsicher, ob die Integral-Annäherungsformel richtig implementiert ist. Der Parameter n soll in der For-Schleife von 1 bis n=10 laufen. Die Formel lautet: y_n = 1/n - a*y_{n-1}.

[Sirius3]

@loyloep: als erstes sollte ein Programm das tun, was gefordert wird, und es sollte sauber programmiert sein. Die Hälfte der Importe wird nicht benutzt. Laut Aufgabenstellung soll es Funktionen und Rekursion geben. Und das wichtigste, Du solltest wissen, welchen Algorithmus Du implementieren sollst!

[Gelöscht2200]

Kann mir jeman erklären, wie ich die While-Schleife oder alternative auch If-Schleife zum laufen bringe, so dass die Mantissenlänge variiert wird?

[Gelöscht2200]

Ich habe nun auch die While-Schleife hinbekommen.

Code: Alles auswählen

from __future__ import division

from decimal import Decimal, getcontext
from sympy import *

import numpy as np
import decimal
import json
from pprint import pprint
import os, sys


with open('data.json') as readJson:    
    data = json.load(readJson)

pprint(data)
        
a = data["Variable"]
n = data["Wiederholung"]
m = data["Mantisse"]


def integral(a,n,m):	          # Methode (Berechnung der Integral-Annaeherungsformel)
        y = 0
        getcontext().prec = m     # Mantissenlaenge (Praezision)
        for i in range(1,n):
                n += Decimal(1)
                y = Decimal(1)/Decimal(n) - Decimal(a) * Decimal(y)        # Integral-Annaeherungsformel
        print ("y: ", y)
while m < 20:                   # Variation der Mantissenlaenge um m = m + 2
        m += 2
        integral(a,n,m)

#integral(a,n,m)			# Aufruf der Methode integral(a,n,m)

[BlackJack]

Irgendwie scheinen die sinnfreien Importe jedes mal mehr zu werden. Komme mir ja so langsam ein bisschen veralbert vor…

[BlackJack]

@loyloep: Noch mal an Sirius3 anknüpfend: Rechne das mit dem Integral doch mal mit bekannten Werten nach und vergleiche die Ergebnisse/den Rechenweg. Die Schleife berechnet nicht wirklich die rekursive Definition (yₙ = 1/n - a·yₙ₋₁) die Du gezeigt hat. Zu der müsste zudem auch noch ein Rekursionsanker gegeben sein damit man das in Code umsetzen kann (y₀ = ?).

Es wäre sinnvoll zuerst diese rekursive Funktion *fehlerfrei* zu implementieren und zu testen. Am einfachsten als rekursive Funktion, denn dann kann man sehr nah an der mathematischen Form bleiben und kann beim umwandeln in eine iterative Lösung keine Fehler einbauen. Dabei braucht man noch nicht einmal `Decimal()` verwenden, denn die Rechenoperation in der Formel haben alle eine Mischung aus einer ganzzahligen Konstante und einem Wert der „von aussen“ kommt als Operanden und wenn dieser Wert von aussen kommende Wert vom Typ `Decimal` ist, reicht das schon aus damit die Operation selbst mit `Decimal` ausgeführt wird, wobei ganze Zahlen problemlos und verlustfrei implizit umgewandelt werden.