updated Task 4

Schenk_Brandenberger_S2_Aufg2.py

@@ -18,29 +18,25 @@ def f2(x):
 
 x1 = np.arange(xmin, xmax + xsteps, xsteps)
 
-#todo yf1 = [f1(x_value) for x_value in x1]
+yf1 = [f1(x_value) for x_value in x1]
-#todo yf2 = [f2(x_value) for x_value in x1]
+yf2 = [f2(x_value) for x_value in x1]
-yf1 = np.array([])
+
-yf2 = np.array([])
-for x_value in x1:
-    yf1 = np.append(yf1, f1(x_value))
-    yf2 = np.append(yf2, f2(x_value))
 plt.plot(x1, yf1, label='f1(x)')
 plt.plot(x1, yf2, label='f2(x)')
 plt.legend()
 plt.title("Aufgabe 2a")
 plt.figure()
 
-print("min f1: ", min(yf1), "max f1: ", max(yf1))
+print(f'min f1: {min(yf1)}     max f1: {max(yf1)}')
-print("min f2: ", min(yf2), "max f2: ", max(yf2))
+print(f'min f2: {min(yf2)}     max f2: {max(yf2)}')
 
 # Die Werte sind sehr klein (von -e-14 bis e-14)
 # sodass Rundungsfehler entstehen wenn die Werte als Fliesskommazahlen
 # zwischengespeichert werden. In den zwei Funktionen f1 und f2 werden die
 # Rechenoperationen in einer anderen Reihenfolge ausgeführt.
-# bei f1 werden die Terme addiert. Entsprechend ist beim Runden nur der Term mit dem
+# bei f1 werden die Terme addiert. Damit werden die Rundungsfehler Kummuliert.
-# grössten Exponent dominant.
+# bei f2 erhält man immer eine Zahl nahe bei 0 da nur eine Subtraktion durchgeführt
-# bei f2 erhält man immer eine Zahl nahe bei 0.
+# wird die einen zu einem Rundungsfehler führen kann.
 
 # Aufgabe 2b
 xmin = -10 ** -14
@@ -53,37 +49,31 @@ def g1(x):
 
 
 x2 = np.arange(xmin, xmax + xsteps, xsteps)
-# todo yg1 = [g1(x_value) for x_value in x2] ?
+yg1 = [g1(x_value) for x_value in x2]
-yg1 = np.array([])
-for x_value in x2:
-    yg1 = np.append(yg1, g1(x_value))
 plt.plot(x2, yg1, label='g1(x)')
-#todo print(f'min g1: {min(yg1)}     max g1: {max(yg1)}')
+print(f'min g1: {min(yg1)}     max g1: {max(yg1)}')
-print("min g1: ", min(yg1), "max g1: ", max(yg1))
 
 
 # Die Berechnung des Grenzwertes für x --> 0 g(x) ist nicht stabil.
 # Der Grenzwert scheint unendlich gross / klein zu sein.
+# Bei g1 ist der Nenner sehr gross wenn x --> 0.
 
 # Aufgabe 2c
 # a = 1+x, b = 1
 def g2(x):
     return x / (2 * np.cos((1 + x + 1) / 2) * np.sin((x) / 2))
 
-#todo yg2 = [g2(x_value) for x_value in x2]
-yg2 = np.array([])
 
-for x_value in x2:
+yg2 = [g2(x_value) for x_value in x2]
-    yg2 = np.append(yg2, g2(x_value))
+
 plt.plot(x2, yg2, label='g2(x)')
-#todo print(f'min g2: {min(yg2)}     max g2: {max(yg2)}')
+
-print("min g2: ", min(yg2), "max g2: ", max(yg2))
+print(f'min g2: {min(yg2)}     max g2: {max(yg2)}')
 plt.legend()
 plt.title("Aufgabe 2bc")
 
-# Der Grenzwert für x = 0 beträgt 1.85. Die Funktion ist nun stabil. Bei g1 ist der Nenner 0 wenn x = 0
+# Bei der Funktion g2 bleibt der Wert stabil bei 1.85. Somit ist dies der Grenzwert.
-# Bei der Funktion g2 bleibt der Wert stabil bei 1.85.
+# Die Auslöschung kann vermieden werden indem Sinus und Cosinus im Nenner stehen.
-# Die Auslöschung kann vermieden werden, Wenn X gegen 0 geht wurde der Nenner sehr gross.
 
 
 plt.show()

Schenk_Brandenberger_S2_Aufg3.py

@@ -1,14 +1,17 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
+
 def s2n(s1n):
     return np.sqrt(2 - 2 * np.sqrt(1 - ((s1n ** 2) / 4)))
 
+
 def s2n_new(s1n):
     return np.sqrt((s1n ** 2) / (2 * (1 + np.sqrt(1 - ((s1n ** 2) / 4)))))
 
-r = 1 #Radius
+
-n = 6 #Anzahl Ecken
+r = 1  # Radius
+n = 6  # Anzahl Ecken
 sn = r
 sn_new = r
 x = np.array([])
@@ -19,7 +22,7 @@ for i in range(50):
     sum_s_new = sn_new * n
     pi2 = sum_s
     pi2_new = sum_s_new
-    print("n: ", n, " sn: ", sn_new, " pi: ", pi2)
+    print(f'n: {n}  sn: {sn_new}  pi: {pi2}')
     x = np.append(x, n)
     y = np.append(y, pi2)
     y_new = np.append(y_new, pi2_new)
@@ -28,17 +31,17 @@ for i in range(50):
     sn = s2n(sn)
     sn_new = s2n_new(sn_new)
 
-
+plt.plot(x, y, label='2*pi')
-
+plt.plot(x, y_new, label='2*pi_new')
-plt.plot(x, y)
-plt.plot(x, y_new)
 plt.xscale('log', base=2)
-plt.xlim((2**3, 2**31))
+plt.xlim((2 ** 3, 2 ** 31))
-plt.legend(["2*pi", "2*pi_new"])
 plt.ylim((6.25, 6.3))
+plt.legend()
+
 plt.title("Aufgabe 3")
 plt.show()
 
 # mit der ersten Formel stimmt der berechnete Wert ab n = 50331648 nicht mehr.
-# mit n = 805306368 erhält man für pi 6, danach immer 0.
+# Durch Rundungsfehler steigt der Wert fälschlicherweise an und fällt anschliessend durch
-# mit der zweiten Formel tritt der Fehler nicht auf.
+# Auslöschung auf 0.
+# mit der zweiten Formel tritt der Fehler nicht auf und der Wert nähert sich an 2*pi

Schenk_Brandenberger_S2_Aufg4.py

@@ -3,19 +3,19 @@ def eps(base, n): # n = Anzahl Stellen der Mantisse
     return 0.5 * (base ** (1-n))
 
 
-def digitsMantiss(base):     # -5*10^-17
+def bitsMantiss(base):
     last_x = 0
     x = 1.5
-    n = 1
+    n = 0
     while x > 1:
         last_x = x
         x = x - (x - 1) / base
         n = n + 1
     return n, last_x
 
-def largestNumber(digitsMantiss):
+def largestNumber(bitsMantiss):
     x = 0.0
-    for i in range(digitsMantiss):
+    for i in range(bitsMantiss):
         x = x + 2 ** i
     return x
 
@@ -23,16 +23,14 @@ def largestNumber_eps(eps, n):
     return eps * 2**(2*n) - 1
 
 
-
+bitsMan = bitsMantiss(2)
-
+epsVal = eps(2, bitsMan[0])
-digMan = digitsMantiss(2)
+largest = largestNumber(bitsMan[0])
-epsVal = eps(2, digMan[0])
+largest_eps = largestNumber_eps(epsVal, bitsMan[0])
-largest = largestNumber(digMan[0])
-largest_eps = largestNumber_eps(epsVal, digMan[0])
 
 
 print(f'eps: {epsVal}')
-print(f'Digits Mantiss: {digMan[0]}')
+print(f'Bits Mantiss: {bitsMan[0]}')
-print(f'Smallest Number 1 + eps > 1: {digMan[1]}')
+print(f'Smallest Number 1 + eps > 1: {bitsMan[1]}')
 print(f'largest Number 1 + qmax > qmax: {largest}')
 print(f'largest Number 1 + qmax > qmax (calculated by eps: {largest_eps}')