Das ist schon korrekt so (ich gehe davon aus, dass nur Phi von beta abhängt).

Du kannst hier die Summenregel anwenden:



Das erste Integral wurde dann ausgewertet und das zweite weiter vereinfacht.

Mit grosser Wahrscheinlichkeit. In meinem Fall gab es viele Wahlfächer in diese Richtung und wenige Fächer die obligatorisch waren und das Thema bloß ankratzten.

Es ist jedoch anderes programmieren als z.B. ein Applikationsentwickler lernt: Es wird darum gehen, dass du physikalische Probleme mithilfe von womöglich Python oder Matlab lösen kannst.

Edit: Oder scheinbar auch C++, wie hier manche schreiben ^^

Hallo, ich gehe mal davon aus, dass du das immer noch in Python lösen möchtest.

Ich verstehe nicht, wieso du das Signal in mehrere Stücke zerlegst. Eine Schleife ist jedoch nützlich, um die Fourier Koeffizienten zu berechnen.

Setzte z.B. hier an:

import numpy as np
import matplotlib.pyplot as plt

# define parameters and some signal in t-domain
fs = 100
dt = 1/fs
t = np.arange(0, 1+dt, dt)

f1 = 5;  A1 = 1
f2 = 10; A2 = 2
w = 2*np.pi
x = A1*np.sin(w*f1*t) + A2*np.sin(w*f2*t)

# compute signal in f-domain
n_max = int(fs/2)  # up to Nyquist frequency
a = np.zeros(n_max)
b = np.zeros(n_max)

a0 = 2 * np.sum(x) * dt
for i in range(n_max):
    n = i+1
    a[i] = 2 * np.sum(x*np.cos(n*w*t)) * dt
    b[i] = 2 * np.sum(x*np.sin(n*w*t)) * dt

c = [np.sqrt(a0**2), *np.sqrt(a**2 + b**2)]

# plot
fig, [ax1, ax2] = plt.subplots(2, 1)
fig.tight_layout()
ax1.plot(t, x)
ax1.set_xlabel('t')
ax1.grid()
ax2.stem(c)
ax2.set_xlabel('f')
ax2.grid()
plt.show()

Wenn du ein "echtes" Signal transformierst, musst du aufpassen, dass in deinem Signal keine Frequenzen enthalten sind, die grösser als die Nyquist Frequenz sind (wegen Aliasing).

Ich kann den code nicht laufen lasse, da ich die Module (mfrc522, RPi) nicht installiert habe (ich kenne die auch nicht, kann also nicht beurteilen, ob du sie richtig verwendest). Was mir ansonsten vom ansehen auffällt:

Deine Struktur wird nicht aufgehen:

while True:
  if ...:
    ...
    break
    continue
  else:
    ...
    break
    continue
  if ...:
     ...  

• Bezüglich break - continue: In dieser Reihenfolge, kann in deinem code nur break erreicht werden (da es vor continue aufgerufen wird). Du benötigst wohl eher continue. Hier findest du z.B. Erklärungen.
• In dem while loop wird entweder der erste if Block oder der else Block aufgerufen und dann wird der loop mit break verlassen. Der untere if Block kann also gar nicht erreicht werden.

Andere Dinge:

• im if und else Block verwendest du "id", das sollte wohl "gescannte_id" sein
• ich würde dir dazu raten, keine ä, ö, ü etc. zu verwenden (tür_öffner_ids)
• verpack die gescannte_id Zuweisung doch in eine Zeile (ist übersichtlicher):

gescannte_id = int(input('gescannte id: '))

• hier möchtest du wahrscheinlich die Länge der Liste failed_entries ermitteln, nicht die ganze Liste ausgeben:

print('Fehlgeschlagen versuche: ' + str(failed_entries))

• text kannst du auch z.B. wie folgt formatieren (mehr dazu):

open_door.append('Tür geöffnet von: {} Uhrzeit: {}'.format(
  gescannte_id, datetime.now()))

wurden mit zahlreichen Teleskopen viele viele tausende planeten entdeckt

Ein Grossteil der entdeckten Exoplaneten sind nicht erdähnlich (siehe hier, die Erde ist "terrestrial"), was mit Limitationen der Messmethoden zusammen hängt. Nur schon damit bleiben relativ wenige entdeckte Exoplaneten, die erdähnliches Leben aufweisen könnten.

ALLE unbewohnbar! Laut NASA

Laut NASA gibt es mindestens einen Kandidaten: https://www.nasa.gov/press-release/earth-size-habitable-zone-planet-found-hidden-in-early-nasa-kepler-data

Hallo, die Frage ist zwar schon älter, aber falls du immer noch ein paar Tipps gebrauchen kannst:

Pygame hat eine sehr ausführliche Dokumentation. Zum Einstieg rate ich dir hier und hier rein zu schauen.

Danach hat es mir sehr geholfen, die Dokumentation von ein paar pygame Modulen/Klassen anzusehen:

• Surface
• Rect
• (Sprite nützlich, aber optional)
• Event
• Mouse / Key
• Display

Wenn du dann einen Überblick davon hast, was dir zu Verfügung steht, kannst du dich deinem Problem widmen.

Hier ein einfaches Beispiel, das ergänzt/angepasst werden könnte:

import pygame
import sys

size = (1200, 640)
screen = pygame.display.set_mode(size)

surf = pygame.Surface((40, 40))
surf.fill((0, 0, 150))
x = []
y = size[1]/2

gray = (100, 100, 100)

pygame.event.set_blocked(None)
pygame.event.set_allowed([pygame.QUIT, pygame.KEYDOWN])
while True:
    for i, xi in enumerate(x):
        x[i] += 1  # move all by one
        if x[i] > size[0]:
            x.pop(i)  # delete if out of window

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == 32:  # space bar
                x.append(0)  # add a square at x = 0

    # draw
    screen.fill(gray)
    for xi in x:
        screen.blit(surf, (xi, y))
    pygame.display.flip()

(Es tut was es soll - Rechtecke nach rechts "schiessen" - aber keine Garantie auf Effizienz etc., habe auch erst letztens mit Pygame angefangen.)

Hallo, Ich kann deine Verwirrung gut verstehen, Der Begriff "Kontinentalplatte" wird eher umgangssprachlich verwendet und ist (meiner Meinung nach) auch keine gute Umschreibung.

Der Fachbegriff von "Kontinentalplatten" ist Lithosphären-Platten. Der Begriff Lithosphäre bezeichnet die starre/feste oberste Schicht der Erde (darunter kommt die Asthenosphäre und dann der Erdkern). Es ist also die Lithosphäre, die in mehrer Teile aufgebrochen ist, die sogenannten Platten.

Die Lithosphäre kann weiter unterteilt werden in Krusten-Anteil und Mantel-Anteil: Die Oberfläche besteht aus Krusten-Material (ozeanische oder kontinentale Kruste) und der untere Teil besteht aus "angefrorenem" Mantel-Material (ist Teil des oberen Erdmantels). (Der ganze Block ist ein Ausschnitt von einer Lithosphären-Platte.)

Hier ein Karte von den "Kontinentalplatten", oder eben Lithosphären-Platten: Du siehst, dass die meisten Platten sowohl kontinentale Kruste (Kontinente und Kontinentalschelf) und ozeanische Kruste besitzen. Die Begriffe "kontinental" und "ozeanisch" beziehen sich also nur auf die Krusten-Anteile, oder auf den Teil der Platte der ozeanische oder kontinentale Kruste drauf hat, aber nicht auf eine ganze Platte. Man spricht z.B. von einem kontinentalen Plattenrand oder einem ozeanischen Plattenrand, aber nicht von kontinentalen/ozeanischen Platten.

Bei der diskreten Fourier Transformation muss einiges beachtet werden. Du solltest vor allem wissen...

• welche Frequenzen im Signal zu erwarte sind und deine "Abtastrate" (= der Abstand in Zeit zwischen zwei Punkten im diskreten Signal) entsprechend wählen (Aliasing)
• über welche Frequenzen das transformierte Signal spannt (hängt von Länge des Signals und der Abtastrate ab)
• wie du das transformierte Signal Normst (um die tatsächlichen Amplituden zu erhalten, falls diese relevant sind)

Python bietet libraries an für die fast fourier transformation (fft), diese berechnet dir die diskrete Fourier Transformation. Bei der fft sollte das input Signal mit Nullen auf eine Zahl^2 (512, 1024, ...) "erweitert" werden (zero padding).

Ein Beispiel mit numpy:

import numpy as np
import matplotlib.pyplot as plt

# make some signal
N = 256
fs = 64  # Abtastrate
t = np.arange(N)/fs

A1 = 1; f1 = 10;
A2 = 3; f2 = 20;
x = A1*np.sin(2*np.pi*f1*t) + A2*np.sin(2*np.pi*f2*t)

# compute fft
Np = 1024  # zero padding
X = abs(np.fft.fft(x, Np)) * 2/N
f = np.fft.fftfreq(Np)*fs

X_half = X[:int(Np/2+1)]
f_half = f[:int(Np/2+1)]

# plot
plt.figure(figsize=(8, 6))
plt.subplot(211)
plt.plot(t, x)
plt.xlabel('t')
plt.subplot(212)
plt.plot(f_half, X_half)
plt.xlabel('f')
plt.grid()
plt.show()

Bezüglich deinem Code würde ich dir empfehlen, ihn mal für ein einfaches künstliches Signal laufen zu lassen, von dem du die Frequenzen kennst (wie mein Signal im Beispiel). Dann kannst du klar erkennen ob deine Berechnung stimmt.

Bei der Fouriertransformation kommt das Signal immer so "gespiegelt" raus, du kannst dir einfach die erste Hälfte anschauen (beide "Seiten" haben genau den gleichen Informationsgehalt).

Wenn du nur blabla() aus file1 am selben Ort verwenden möchtest, dann geht das so. Wenn du blabla() aus file1 und aus file2 verwenden möchtest, gibt es meines Wissens zwei Optionen:

1. die files importieren (import file1 und import file2) und dann die Funktionen mit file1.blabla() und file2.blabla() aufrufen.
2. die Fuktionen beim import umbenennen: e.g. from file1 import blabla as blabla1 und from file2 import blabla as blabla2

Ich würde das in diese Richtung lösen:

options = ['Milch', 'Kekse', 'Brot']
choice = int(input('Was willst du?\n0 - {}\n1 - {}\n2 - {}\n'.format(*options)))

amount = input('Wie viel {} willst du? '.format(options[choice]))

Am besten lässt du es mal bei dir laufen, dann siehst du was die Textformatierung macht (\n beginnt eine neue Zeile und string.format() fügt Gegebenes bei {} ein).

Da die Eingabe 0, 1 oder 2 sein soll, kannst du das gleich verwenden um in der options Liste zu finden was ausgesucht wurde (z.B. options[0] = 'Milch').

(Der code löst einen Fehler aus, wenn die erste Eingabe nicht 0, 1 oder 2 ist.)

np.reshape() geht nur, wenn der input array und gewünschte output array die gleiche Anzahl Elemente haben. Du musst also zuerst die Null zu deiner Liste hinzufügen und dann kannst du reshape() verwenden.

Beispiel:

array = list(range(7))

# Null anhängen, wenn nötig
if len(array) % 2 > 0:
    array.append(0)

# umformen
array = np.reshape(array, (int(len(array)/2), 2))

Kannst z.B. den folgenden code anpassen:

import time

print('loading', end='')

i = 0
while i < 5:
    print('.', end='')
    time.sleep(1)
    i += 1

print('\ndone')

Ein möglicher Ansatz:

data = ['<0.04', '0.09', 'element', '0.07']

for element in data:
    element = element.replace('<', '')

    try:
        element = float(element) * 5
    except ValueError:  # is raised if element can't be converted to float
        element = None

    print(element)

Falls du nicht weisst, wie du vom kompletten Datensatz zu einer Liste mit den "Hauptdaten" kommst (Erklärung dazu hier):

with open('DeinDatensatz.txt', 'r') as file:
    lines = file.read().split('\n')
    Hauptdaten = [line.split(',')[1].strip() for line in lines]

Mit Dy = numAbleitung(@f, x, h) berechnet matlab die Funktion numAbleitung(f, x, h) für die gegebenen Inputs: f = @f (linkt zur Funktion mit dem namen "f"), x=x und h=h.

Deinen Definitionen zufolge berechnet es also Dy = (f(x+h)-f(x))/h, mit f(x) = (x-2)^2



Damit dein Programm so läuft, musst du x als eine einzelne Zahl definieren, nicht als array. Berechnet wird dann die Steigung der Funktion y=(x-2)^2 zwischen den zwei Stellen x=x und x=x+h.

Um den Differentialquotient an Stelle x zu berechnen, müsstest du h gegen 0 streben lassen:

für f(x) = (x-2)^2

Das kannst du z.B. wie folgt lösen:

n = -1           # <- letzte Zeile
separator = ' '  # <- musst du evtl. für dein txt file anpassen

with open('text.txt', 'r') as file:
    lines = file.read().split('\n')
    nth_column = [line.split(separator)[n].strip() for line in lines]

line.split(separator)[n] unterteilt hier die jeweilige Zeile (line) bei den "separators" und wählt das n-te Element.

Mit n = -1 wird jeweils das letzte Element jeder Zeile gewählt. Falls du weisst, dass dein txt file z.B. 5 Zeilen hat, kannst du auch n = 4 angeben (das Zählen beginnt bei 0, daher 4 und nicht 5).

strip() löscht hier Leerschläge am Anfang und Ende des ausgewählten Elements. Das ist nützlich, wenn die Spalten eine unterschiedliche Anzahl von Leerschlägen dazwischen haben.

Um diesen Error zu beheben musst du bloss nach while True: noch eins weiter einrücken.

Vielleicht hilft dir diese Erklärung weiter. Ich kenne mich zwar nicht mit dem Thema aus, aber meinen Erfahrungen nach kann Wiki bei solchen Fragen manchmal helfen.

Versuche es mal mit beiden ifs in derselben on_message():

async def on_message(message):

    if message.content.startswith("!trivial"):
        ...

    if message.content.startswith("!dot"):
        ...

die Thematik um die Seismologie ist sehr hart umstritten

Du meinst das wohl im Zusammenhang mit der Airgun / marine Tierwelt, so allgemein würde ich das nicht sagen ^^

 Ich würde gerne Wissen wie so eine Seismische Airgun funktioniert.

Ein Video zur Airgun.

Ansonsten, google mal nach "marin seismology sources", da findest du auch einiges dazu.

Wiki: Usually found in desert areas, these rocks form over thousands of years when wind erosion of an isolated rocky outcrop progresses at a different rate at its bottom than at its top. Abrasion by wind-borne grains of sand is most prevalent within the first three feet (0.9 m) above the ground, causing the bases of outcrops to erode more rapidly than their tops.

In kurz: Der Wind blast in Bodennähe Sand rum, daher wird der Fels unten stärker errodiert (mehr Material abgetragen) als oben und erhält diese "Pilzform".