Mantissenlänge varieren

[BlackJack]

@loyloep: Vielleicht noch als Hinweis: Python bringt eine interaktive Shell mit in der man Sachen ”live” ausprobieren kann um ein besseres Gefühl für die Datentypen, Operationen, und Ergebnisse zu bekommen.

Und Du solltest mindestens nebenher ganz normal Python lernen ohne speziellen Fokus auf Dein konkretes zu lösendes Problem. In der Uni wird üblicherweise erwartet das man sich in so etwas wie Programmiersprachen selbstständig einarbeitet und nicht darauf baut das alles in den Veranstaltungen oder Tutorien ”vorgeturnt” wird. Der Fehler den kbr herausgestellt hat ist nämlich nicht speziell mit der Aufgabe verknüpft, sondern offenbart ein ganz grundsätzliches Fehlverständnis von Python-Syntax/-Semantik. Was denkst Du denn was diese Zeile bewirken soll? Also was sind die Zwischenergebnisse der einzelnen Teilausdrücke auf beiden Seiten der Zuweisung und woher weisst Du wo Ausrücke stehen dürfen und wo nicht?

[Gelöscht2200]

Der Fehler taucht in der Zeile 19

Code: Alles auswählen

Decimal(n) += Decimal(1)

auf mit der Beschreibung: Syntax-Fehler: can't assign function call.

Was hier in dieser Zeile passieren soll ist, dass die Variablen n plus Eins addiert werden soll, und dass nicht in floating point sondern in Decimal.

[kbr]

@loyloep: BlackJack hat Dich schon darauf hingewiesen, dass Python einen interaktiven Interpreter mitbringt, in dem Du experimentieren kannst. Ich habe hier mal ipython genommen, aber das macht keinen Unterschied:

Code: Alles auswählen

In [1]: from decimal import Decimal

In [2]: i = Decimal(1)

In [3]: i
Out[3]: Decimal('1')

In [4]: i += 2

In [5]: i
Out[5]: Decimal('3')

Der interaktive Interpreter ist gerade für Anfänger eine tolle Sache. Gebrauche ihn.

[Gelöscht2200]

Ich habe den Fehler gefunden. Da es erneut zu einer Fehlermeldung gekommen ist, nehme ich doch wieder mein anfängliches Programm. Es mag komplizierter und mit viel unnützen Zeug beladen sein. Das ist mir aber egal. Denn es läuft nun auch mit Decimal-Darstellung. Nur die Implementierung einer If-Schleife in der die Variable M für die Mantissenlänge variert wird funktioniert nicht.

Code: Alles auswählen

from __future__ import division
from sympy import *

import numpy as np
import decimal


ctx = decimal.getcontext()


class Integral(object):    # Klasse, deren Objekte Skalare sind 

        def __init__(self, a, n, m):           # Konstruktor
                self.Variable = a  
                self.Wiederholung = n 
                self.Mantisse = m
        

        def integral(self,a,n,m):              # Methode (Berechnung der Integral-Annäherungsformel)
                D = decimal.Decimal            # Decimal -Darstellung von Zahlen
                ctx.prec=m                     # Mantissenlänge
                y =  D("0")
                for i in range(1,n):
                        n += D("1")
                        y = D("1")/D(n) - D(a) * D(y)        # Integral-Annäherungsformel
                        print ("y: ", y)
                


objekt = Integral(10,10,6)      # Klasse aufrufen mit Variablen, a,n,m

objekt.integral(10,10,6)        # Methode aufrufen mit Variablen a,n,m

[BlackJack]

@loyloep: Das sollte Dir nicht egal sein, denn ganz ehrlich wenn Du so etwas zeigst und nach Hinweisen nicht überarbeiten willst, dann dürfte über kurz oder lang jedem potentiellen Helfer hier Dein Problem egal sein.

Demjenigen der das bewerten wird, dürfte der Unsinn auch nicht egal sein. Lösungen sollten schon so aussehen als wenn man verstanden hätte was man da macht und man nicht wild herumgeraten hat. Für die unsinnige Klasse und die unnötigen Importe würde ich Punktabzug geben. Und das die Mantisse nicht variiert wird, gibt ganz sicher Punktabzug, denn die Aufgabe wird da ja nicht so gelöst wie sie soll. Rekursion fehlt auch. Also letztendlich weiss ich gar nicht worauf man da überhaupt Punkte geben soll.

[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.