From e5f1b8c80aebab0d27a3d0925eedd12e63f705ee Mon Sep 17 00:00:00 2001 From: Olli Graf Date: Fri, 9 Aug 2024 14:07:52 +0200 Subject: [PATCH] Programmcode aus dem Post. --- infinite-270-oc.py | 82 ++++++++++++++++++++++++++++++++++++++++++++ infinite-no-oc.py | 84 ++++++++++++++++++++++++++++++++++++++++++++++ sieve.py | 29 ++++++++++++++++ sieve_oc.py | 74 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 269 insertions(+) create mode 100644 infinite-270-oc.py create mode 100644 infinite-no-oc.py create mode 100644 sieve.py create mode 100644 sieve_oc.py diff --git a/infinite-270-oc.py b/infinite-270-oc.py new file mode 100644 index 0000000..9bb5ac9 --- /dev/null +++ b/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}%%') diff --git a/infinite-no-oc.py b/infinite-no-oc.py new file mode 100644 index 0000000..809d489 --- /dev/null +++ b/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}%%') diff --git a/sieve.py b/sieve.py new file mode 100644 index 0000000..9849850 --- /dev/null +++ b/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') diff --git a/sieve_oc.py b/sieve_oc.py new file mode 100644 index 0000000..53d28f6 --- /dev/null +++ b/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}%%') \ No newline at end of file