Programmcode aus dem Post.

infinite-270-oc.py

@@ -0,0 +1,82 @@
+# infinite-no-oc.py
+
+# Dauerberechnung ohne Übertaktung
+# Clock-Speed: 270 MHz
+
+import time
+import machine
+from machine import Pin
+
+led = Pin(25, Pin.OUT)
+
+#Berechnung von Primzahlen mit dem Sieb des Eratosthenes.
+
+def sieb_des_eratosthenes(limit):
+  # Erzeuge eine Liste, die angibt, ob eine Zahl eine Primzahl ist
+  is_prime = [True] * (limit + 1)
+  p = 2
+
+  while (p * p <= limit):
+      # Wenn is_prime[p] nicht verändert wurde, ist p eine Primzahl
+    if is_prime[p]:
+    # Alle Vielfachen von p können keine Primzahl sein.
+      for i in range(p * p, limit + 1, p):
+        is_prime[i] = False
+        p += 1
+
+    # Sammle alle Primzahlen in einer Liste.
+    prime_numbers = [p for p in range(2, limit + 1) if is_prime[p]]
+    return prime_numbers
+
+# Methode zur Laufzeitbestimmung
+
+def berechnung(limit):
+  ergebnis = {}
+  
+  start_time = time.ticks_ms()
+  
+  prime_numbers = sieb_des_eratosthenes(limit)
+  ergebnis['primzahlen'] = prime_numbers
+  
+  end_time = time.ticks_ms()
+  
+  running_time =time.ticks_diff(end_time,start_time)
+  ergebnis['laufzeit'] = running_time
+  
+  return ergebnis
+  
+# Liefert den Clock-Speed in MHz
+def get_speed():
+  return str(round(machine.freq()/1000000,1))
+               
+
+
+limit = 10000
+
+machine.freq(270000000)
+
+while True:
+ led.on()
+ berechnung(limit)
+ led.off()
+#laufzeit1 = ergebnis1['laufzeit']
+
+
+#print(f'Laufzeit: {laufzeit1}ms')
+
+#Übertaktung auf 270MHz
+#led.on()
+#machine.freq(270000000)
+#print(f'Durchgang #2 mit {get_speed()}MHz')
+#ergebnis2 = berechnung(limit)
+
+
+#laufzeit2 = ergebnis2['laufzeit']
+#primzahlen = ergebnis2['primzahlen']
+#led.off()
+machine.freq(125000000)
+
+print(f'Primzahlen bis {limit}: {primzahlen}')
+print(f'Laufzeit: {laufzeit2}ms')
+p = (laufzeit1 -laufzeit2) / laufzeit1 *100
+print(f' prozentualer Unterschied: {p}%%')

infinite-no-oc.py

@@ -0,0 +1,84 @@
+# infinite-no-oc.py
+
+# Dauerberechnung ohne Übertaktung
+# Clock-Speed: 125 MHz
+
+import time
+import machine
+from machine import Pin
+
+led = Pin(25, Pin.OUT)
+
+#Berechnung von Primzahlen mit dem Sieb des Eratosthenes.
+
+def sieb_des_eratosthenes(limit):
+  # Erzeuge eine Liste, die angibt, ob eine Zahl eine Primzahl ist
+  is_prime = [True] * (limit + 1)
+  p = 2
+
+  while (p * p <= limit):
+      # Wenn is_prime[p] nicht verändert wurde, ist p eine Primzahl
+    if is_prime[p]:
+    # Alle Vielfachen von p können keine Primzahl sein.
+      for i in range(p * p, limit + 1, p):
+        is_prime[i] = False
+        p += 1
+
+    # Sammle alle Primzahlen in einer Liste.
+    prime_numbers = [p for p in range(2, limit + 1) if is_prime[p]]
+    return prime_numbers
+
+# Methode zur Laufzeitbestimmung
+
+def berechnung(limit):
+  ergebnis = {}
+  
+  start_time = time.ticks_ms()
+  
+  prime_numbers = sieb_des_eratosthenes(limit)
+  ergebnis['primzahlen'] = prime_numbers
+  
+  end_time = time.ticks_ms()
+  
+  running_time =time.ticks_diff(end_time,start_time)
+  ergebnis['laufzeit'] = running_time
+  
+  return ergebnis
+  
+# Liefert den Clock-Speed in MHz
+def get_speed():
+  return str(round(machine.freq()/1000000,1))
+               
+# Beispielverwendung: Finde alle Primzahlen bis 1000
+
+print(f'Durchgang #1 mit {get_speed()}MHz')
+
+limit = 10000
+
+machine.freq(125000000)
+
+while True:
+ led.on()
+ berechnung(limit)
+ led.off()
+#laufzeit1 = ergebnis1['laufzeit']
+
+
+#print(f'Laufzeit: {laufzeit1}ms')
+
+#Übertaktung auf 270MHz
+#led.on()
+#machine.freq(270000000)
+#print(f'Durchgang #2 mit {get_speed()}MHz')
+#ergebnis2 = berechnung(limit)
+
+
+#laufzeit2 = ergebnis2['laufzeit']
+#primzahlen = ergebnis2['primzahlen']
+#led.off()
+machine.freq(125000000)
+
+print(f'Primzahlen bis {limit}: {primzahlen}')
+print(f'Laufzeit: {laufzeit2}ms')
+p = (laufzeit1 -laufzeit2) / laufzeit1 *100
+print(f' prozentualer Unterschied: {p}%%')

sieve.py

@@ -0,0 +1,29 @@
+import time
+
+def sieve_of_eratosthenes(limit):
+    # Erzeuge eine Liste, die angibt, ob eine Zahl eine Primzahl ist
+    is_prime = [True] * (limit + 1)
+    p = 2
+
+    while (p * p <= limit):
+        # Wenn is_prime[p] nicht verändert wurde, ist p eine Primzahl
+        if is_prime[p]:
+            # Aktualisiere alle Vielfachen von p als nicht prim
+            for i in range(p * p, limit + 1, p):
+                is_prime[i] = False
+        p += 1
+
+    # Sammle alle Primzahlen
+    prime_numbers = [p for p in range(2, limit + 1) if is_prime[p]]
+    return prime_numbers
+
+# Beispielverwendung: Finde alle Primzahlen bis 100
+limit = 10000
+start_time = time.ticks_ms()
+prime_numbers = sieve_of_eratosthenes(limit)
+end_time = time.ticks_ms()
+
+running_time =time.ticks_diff(end_time,start_time)
+
+print(f'Primzahlen bis {limit}: {prime_numbers}')
+print(f'Laufzeit: {running_time}ms')

sieve_oc.py

@@ -0,0 +1,74 @@
+# sieve_oc.py
+import time
+import machine
+from machine import Pin
+
+led = Pin(25, Pin.OUT)
+
+#Berechnung von Primzahlen mit dem Sieb des Eratosthenes.
+
+def sieb_des_eratosthenes(limit):
+  # Erzeuge eine Liste, die angibt, ob eine Zahl eine Primzahl ist
+  is_prime = [True] * (limit + 1)
+  p = 2
+
+  while (p * p <= limit):
+      # Wenn is_prime[p] nicht verändert wurde, ist p eine Primzahl
+    if is_prime[p]:
+    # Alle Vielfachen von p können keine Primzahl sein.
+      for i in range(p * p, limit + 1, p):
+        is_prime[i] = False
+        p += 1
+
+    # Sammle alle Primzahlen in einer Liste.
+    prime_numbers = [p for p in range(2, limit + 1) if is_prime[p]]
+    return prime_numbers
+
+# Methode zur Laufzeitbestimmung
+
+def berechnung(limit):
+  ergebnis = {}
+  
+  start_time = time.ticks_ms()
+  
+  prime_numbers = sieb_des_eratosthenes(limit)
+  ergebnis['primzahlen'] = prime_numbers
+  
+  end_time = time.ticks_ms()
+  
+  running_time =time.ticks_diff(end_time,start_time)
+  ergebnis['laufzeit'] = running_time
+  
+  return ergebnis
+  
+# Liefert den Clock-Speed in MHz
+def get_speed():
+  return str(round(machine.freq()/1000000,1))
+               
+# Beispielverwendung: Finde alle Primzahlen bis 1000
+
+print(f'Durchgang #1 mit {get_speed()}MHz')
+
+limit = 10000
+ergebnis1 = berechnung(limit)
+laufzeit1 = ergebnis1['laufzeit']
+
+
+print(f'Laufzeit: {laufzeit1}ms')
+
+#Übertaktung auf 270MHz
+led.on()
+machine.freq(270000000)
+print(f'Durchgang #2 mit {get_speed()}MHz')
+ergebnis2 = berechnung(limit)
+
+
+laufzeit2 = ergebnis2['laufzeit']
+primzahlen = ergebnis2['primzahlen']
+led.off()
+machine.freq(125000000)
+
+print(f'Primzahlen bis {limit}: {primzahlen}')
+print(f'Laufzeit: {laufzeit2}ms')
+p = (laufzeit1 -laufzeit2) / laufzeit1 *100
+print(f' prozentualer Unterschied: {p}%%')