Signal- und Messdatenverarbeitung


Codes für stochastisch abgetastete, reelle, periodische Einzelsignale, ohne Gewichtung

Python Matlab/Octave
Vorbereitung (Laden von Modulen/Paketen)
from numpy import *
from numpy.random import *
from matplotlib.pyplot import *
Generieren von Wertepaaren (ti,xi) mit den Messzeitpunkten ti und den Messwerten xi (Superposition zweier harmonischer Signale als Beispiel, mit Erwartungswert verschieden von null)
T=1000.0
dr=5.0
mxs=3.0
axs=1.5
t=[]
x=[]
te=0.0
while te<T:
  tp=exponential(1.0/dr)
  te+=tp
  if te<T:
    t.append(te)
    x.append(axs*sin(0.1*pi*te)+axs*sin(0.05*pi*te)+mxs)
  

t=array(t)
x=array(x)
plot(t,x,'o')
show()
T=1000;
dr=5;
mxs=3;
axs=1.5;
t=[];
x=[];
te=0;
while te<T
tp=-log(1-rand())/dr;
te=te+tp;
if te<T
t(end+1)=te;
x(end+1)=axs*sin(0.1*pi*te)+axs*sin(0.05*pi*te)+mxs;
end
end
plot(t,x,'o')
Mittelwert x=1Ni=0N1xi
mean(x)
mean(x)
Varianz (ohne Bessel-Korrektur, asymptotisch erwartungstreu) s2=1Ni=0N1(xix)2=(1Ni=0N1xi2)x2
var(x)
var(x,1)
Autokorrelationsfunktion und Leistungsspektrum über Slotkorrelation (ohne Selbstprodukte durch bk(0)=0, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall ist) Rk=R(τk)=i=0N1j=0N1bk(tjti)xixji=0N1j=0N1bk(tjti)
bk(t)={1falls 0<|t+cT|<Δt/2 für irgendein ganzes c0sonst
τk=kΔt
k=K/2(K1)/2
K=[T/Δt]
Pj=P(fj)=1KFFT{Rk}=1Kk=K/2(K1)/2Rk𝐞2π𝐢jk/K
(imaginäre Einheit 𝐢)
fj=jKΔt
j=K/2(K1)/2
from numpy.fft import *
N=len(t)
dt=1.0
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R1=zeros(K)
R0=zeros(K)
for i in range(1,N):
  for j in range(0,i):
    k=int(round((t[j]-t[i]-T*round((t[j]-t[i])/float(T)))/float(dt)))
    R1[k]+=x[i]*x[j]
    R0[k]+=1.0
  

for k in range(-(K//2),1):
  R1[k]+=R1[-k]
  R0[k]+=R0[-k]

for k in range(1,(K+1)//2):
  R1[k]=R1[-k]
  R0[k]=R0[-k]

R=R1/R0
plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R1=zeros(1,K);
R0=zeros(1,K);
for i=2:N
for j=1:i-1
k=round((t(j)-t(i)-T*round((t(j)-t(i))/T))/dt);
R1(mod(K+k,K)+1)=R1(mod(K+k,K)+1)+x(i)*x(j);
R0(mod(K+k,K)+1)=R0(mod(K+k,K)+1)+1;
end
end
R1(1)=2*R1(1);
R0(1)=2*R0(1);
for k=fix((K+1)/2)+1:K
R1(k)=R1(k)+R1(K-k+2);
R0(k)=R0(k)+R0(K-k+2);
end
for k=2:fix((K+1)/2)
R1(k)=R1(K-k+2);
R0(k)=R0(K-k+2);
end
R=R1./R0;
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über Slotkorrelation (ohne Selbstprodukte durch bk(0)=0, mit lokaler Normierung, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall ist) Rk=R(τk)=s2[i=0N1j=0N1bk(tjti)(xix)(xjx)][i=0N1j=0N1bk(tjti)(xix)2][i=0N1j=0N1bk(tjti)(xjx)2]+x2
bk(t)={1falls 0<|t+cT|<Δt/2 für irgendein ganzes c0sonst
τk=kΔt
k=K/2(K1)/2
K=[T/Δt]
Pj=P(fj)=1KFFT{Rk}=1Kk=K/2(K1)/2Rk𝐞2π𝐢jk/K
(imaginäre Einheit 𝐢)
fj=jKΔt
j=K/2(K1)/2
from numpy.fft import *
N=len(t)
dt=1.0
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
mxe=mean(x)
vxe=var(x)
R1=zeros(K)
R2=zeros(K)
R3=zeros(K)
for i in range(1,N):
  for j in range(0,i):
    k=int(round((t[j]-t[i]-T*round((t[j]-t[i])/float(T)))/float(dt)))
    R1[k]+=(x[i]-mxe)*(x[j]-mxe)
    R2[k]+=(x[i]-mxe)**2
    R3[k]+=(x[j]-mxe)**2
  

for k in range(-(K//2),1):
  R1[k]+=R1[-k]
  R2[k]+=R3[-k]
  if k%K!=(-k)%K:
    R3[k]+=R2[-k]
  else:
    R3[k]=R2[-k]

for k in range(1,(K+1)//2):
  R1[k]=R1[-k]
  R2[k]=R3[-k]
  R3[k]=R2[-k]

R=vxe*R1/sqrt(R2*R3)+mxe**2
plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
mxe=mean(x);
vxe=var(x,1);
R1=zeros(1,K);
R2=zeros(1,K);
R3=zeros(1,K);
for i=2:N
for j=1:i-1
k=round((t(j)-t(i)-T*round((t(j)-t(i))/T))/dt);
R1(mod(K+k,K)+1)=R1(mod(K+k,K)+1)+(x(i)-mxe)*(x(j)-mxe);
R2(mod(K+k,K)+1)=R2(mod(K+k,K)+1)+(x(i)-mxe)^2;
R3(mod(K+k,K)+1)=R3(mod(K+k,K)+1)+(x(j)-mxe)^2;
end
end
R1(1)=2*R1(1);
R2(1)=R2(1)+R3(1);
R3(1)=R2(1);
for k=fix((K+1)/2)+1:K
R1(k)=R1(k)+R1(K-k+2);
R2(k)=R2(k)+R3(K-k+2);
if mod(k,K)~=mod(K-k+2,K)
R3(k)=R3(k)+R2(K-k+2);
else
R3(k)=R2(K-k+2);
end
end
for k=2:fix((K+1)/2)
R1(k)=R1(K-k+2);
R2(k)=R3(K-k+2);
R3(k)=R2(K-k+2);
end
R=vxe*R1./sqrt(R2.*R3)+mxe^2;
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über direkte Spektralschätzung (Fourier-Transformation, mit Abzug der Selbstprodukte, ohne Normierung) Ej=E(fj)=T2N(N1){|Xj|2i=0N1xi2}
Xj=i=0N1xi𝐞2π𝐢fjti
(imaginäre Einheit 𝐢)
fj=jJΔt
j=J/2(J1)/2
J=[T/Δt]
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
Rk=R(τk)=1TRE,k
τk=kΔt
k=K/2(K1)/2
K=J=[T/Δt]
Pj=P(fj)=1KFFT{Rk}=1Kk=K/2(K1)/2Rk𝐞2π𝐢jk/K
fj=jKΔt
j=K/2(K1)/2
from numpy.fft import *
N=len(t)
dt=1.0
J=int(round(T/float(dt)))
fp=arange(0,J//2+1)/float(J*dt)
X=zeros(size(fp))+0j
for i in range(0,N):
  X+=x[i]*exp(-2j*pi*fp*t[i])

E=zeros(J)
for k in range(0,J//2+1):
  E[k]=T**2*(abs(X[k])**2-sum(x**2))/float(N**2-N)

for k in range(-(J//2-1),0):
  E[k]=E[-k]

RE=real(ifft(E))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=RE[k]/float(T)

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
J=round(T/dt);
fp=(0:fix(J/2))/(J*dt);
X=zeros(size(fp))+0j;
for i=1:N
X=X+x(i)*exp(-2j*pi*fp*t(i));
end
E=zeros([1,J]);
for k=1:fix(J/2)+1
E(k)=T^2*(abs(X(k)).^2-sum(x.^2))/(N^2-N);
end
for k=fix(J/2)+2:J
E(k)=E(J-k+2);
end
RE=real(ifft(E))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=RE(k)/T;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über direkte Spektralschätzung (Fourier-Transformation, mit Abzug der Selbstprodukte, mit Normierung, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall ist) Ej=E(fj)=T2N(N1){|Xj|2i=0N1xi2}
Ej=E(fj)=T2N(N1){|Xj|2N}
Xj=i=0N1xi𝐞2π𝐢fjti
Xj=i=0N1𝐞2π𝐢fjti
(imaginäre Einheit 𝐢)
fj=jJΔt
j=J/2(J1)/2
J=[T/Δt]
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
Rk=R(τk)=RE,kRE,k
τk=kΔt
k=K/2(K1)/2
K=J=[T/Δt]
Pj=P(fj)=1KFFT{Rk}=1Kk=K/2(K1)/2Rk𝐞2π𝐢jk/K
fj=jKΔt
j=K/2(K1)/2
from numpy.fft import *
N=len(t)
dt=1.0
J=int(round(T/float(dt)))
fp=arange(0,J//2+1)/float(J*dt)
X=zeros(size(fp))+0j
Xp=zeros(size(fp))+0j
for i in range(0,N):
  X+=x[i]*exp(-2j*pi*fp*t[i])
  Xp+=exp(-2j*pi*fp*t[i])

E=zeros(J)
Ep=zeros(J)
for k in range(0,J//2+1):
  E[k]=T**2*(abs(X[k])**2-sum(x**2))/float(N**2-N)
  Ep[k]=T**2*(abs(Xp[k])**2-N)/float(N**2-N)

for k in range(-(J//2-1),0):
  E[k]=E[-k]
  Ep[k]=Ep[-k]

RE=real(ifft(E))/float(dt)
REp=real(ifft(Ep))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=RE[k]/float(REp[k])

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
J=round(T/dt);
fp=(0:fix(J/2))/(J*dt);
X=zeros(size(fp))+0j;
Xp=zeros(size(fp))+0j;
for i=1:N
X=X+x(i)*exp(-2j*pi*fp*t(i));
Xp=Xp+exp(-2j*pi*fp*t(i));
end
E=zeros([1,J]);
Ep=zeros([1,J]);
for k=1:fix(J/2)+1
E(k)=T^2*(abs(X(k)).^2-sum(x.^2))/(N^2-N);
Ep(k)=T^2*(abs(Xp(k)).^2-N)/(N^2-N);
end
for k=fix(J/2)+2:J
E(k)=E(J-k+2);
Ep(k)=Ep(J-k+2);
end
RE=real(ifft(E))/dt;
REp=real(ifft(Ep))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=RE(k)/REp(k);
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über direkte Spektralschätzung (Fourier-Transformation, mit Abzug der Selbstprodukte, mit lokaler Normierung, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall ist) Ej=E(fj)=T2N(N1){|Xj|2i=0N1(xix)2}
Ej=E(fj)=T2N(N1){Xj*Xji=0N1(xix)2}
Ej=E(fj)=T2N(N1){Xj*Xji=0N1(xix)2}
Xj=i=0N1(xix)𝐞2π𝐢fjti
Xj=i=0N1𝐞2π𝐢fjti
Xj=i=0N1(xix)2𝐞2π𝐢fjti
(imaginäre Einheit 𝐢)
fj=jJΔt
j=J/2(J1)/2
J=[T/Δt]
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
RE,k=RE(τk)=1ΔtIFFT{Ej}=1JΔtj=J/2(J1)/2Ej𝐞2π𝐢fjτk/J
Rk=R(τk)=s2RE,kRE,kRE,k+x2
τk=kΔt
k=K/2(K1)/2
K=J=[T/Δt]
Pj=P(fj)=1KFFT{Rk}=1Kk=K/2(K1)/2Rk𝐞2π𝐢jk/K
fj=jKΔt
j=K/2(K1)/2
from numpy.fft import *
N=len(t)
dt=1.0
mxe=mean(x)
vxe=var(x)
J=int(round(T/float(dt)))
fp=arange(0,J//2+1)/float(J*dt)
X=zeros(size(fp))+0j
Xp=zeros(size(fp))+0j
Xpp=zeros(size(fp))+0j
for i in range(0,N):
  X+=(x[i]-mxe)*exp(-2j*pi*fp*t[i])
  Xp+=exp(-2j*pi*fp*t[i])
  Xpp+=(x[i]-mxe)**2*exp(-2j*pi*fp*t[i])

E=zeros(J)
Ep=zeros(J)
Epp=zeros(J)
for k in range(0,J//2+1):
  E[k]=T**2*(abs(X[k])**2-sum((x-mxe)**2))/float(N**2-N)
  Ep[k]=T**2*(conj(Xpp[k])*Xp[k]-sum((x-mxe)**2))/float(N**2-N)
  Epp[k]=T**2*(conj(Xp[k])*Xpp[k]-sum((x-mxe)**2))/float(N**2-N)

for k in range(-(J//2-1),0):
  E[k]=E[-k]
  Ep[k]=Ep[-k]
  Epp[k]=Epp[-k]

RE=real(ifft(E))/float(dt)
REp=real(ifft(Ep))/float(dt)
REpp=real(ifft(Epp))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=vxe*RE[k]/sqrt(REp[k]*REpp[k])+mxe**2

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
mxe=mean(x);
vxe=var(x,1);
J=round(T/dt);
fp=(0:fix(J/2))/(J*dt);
X=zeros(size(fp))+0j;
Xp=zeros(size(fp))+0j;
Xpp=zeros(size(fp))+0j;
for i=1:N
X=X+(x(i)-mxe)*exp(-2j*pi*fp*t(i));
Xp=Xp+exp(-2j*pi*fp*t(i));
Xpp=Xpp+(x(i)-mxe)^2*exp(-2j*pi*fp*t(i));
end
E=zeros([1,J]);
Ep=zeros([1,J]);
Epp=zeros([1,J]);
for k=1:fix(J/2)+1
E(k)=T^2*(abs(X(k)).^2-sum((x-mxe).^2))/(N^2-N);
Ep(k)=T^2*(conj(Xpp(k))*Xp(k)-sum((x-mxe).^2))/(N^2-N);
Epp(k)=T^2*(conj(Xp(k))*Xpp(k)-sum((x-mxe).^2))/(N^2-N);
end
for k=fix(J/2)+2:J
E(k)=E(J-k+2);
Ep(k)=Ep(J-k+2);
Epp(k)=Epp(J-k+2);
end
RE=real(ifft(E))/dt;
REp=real(ifft(Ep))/dt;
REpp=real(ifft(Epp))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=vxe*RE(k)/sqrt(REp(k)*REpp(k))+mxe^2;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über direkte Spektralschätzung (Lomb-Scargle-Methode, mit Abzug der Selbstprodukte, ohne Normierung, ohne Korrektur des dynamischen Fehlers)
from numpy.fft import *
import scipy.signal as scisig
N=len(x)
dt=1.0
mxe=mean(x)
J=int(round(T/float(dt)))
fp=arange(1,J//2+1)/float(J*dt)
X=scisig.lombscargle(t,x-mxe,2*pi*fp)
E=zeros(J)
for k in range(0,J//2+1):
  E[k]=T**2*(N*X[k-1]-sum((x-mxe)**2))/float(N**2-N)

for k in range(-((J-1)//2),0):
  E[k]=E[-k]

RE=real(ifft(E))/float(dt)+T*mxe**2
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=RE[k]/float(T)

plot(tau,R,'o')
show()
f=roll(arange(-(len(R)//2),(len(R)+1)//2)/float(len(R)*dt),(len(R)+1)//2)
P=real(fft(R))/float(len(R))
plot(f,P,'o')
show()
N=length(x);
dt=1.0;
mxe=mean(x);
J=round(T/dt);
fp=(1:fix(J/2)+1)/(J*dt);
X=plomb(x-mxe,t,fp)/2;
E=zeros(1,J);
for k=2:fix(J/2)+1
E(k)=T^2*(N^2*X(k-1)/T-sum((x-mxe).^2))/(N^2-N);
end
for k=fix(J/2)+2:J
E(k)=E(J-k+2);
end
RE=real(ifft(E))/dt+T*mxe^2;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros(1,K);
for k=1:fix(K/2)+1
R(k)=RE(k)/T;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(length(R)/2):fix((length(R)-1)/2))/(length(R)*dt),[0;fix((length(R)+1)/2)]);
P=real(fft(R))/length(R);
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über Zeitquantisierung (mit Abzug der Selbstprodukte, ohne Normierung)
from numpy.fft import *
N=len(t)
dt=1.0
J=int(round(T/float(dt)))
x1=zeros(J)
for i in range(0,N):
  j=int(floor((t[i]-T*floor(t[i]/float(T)))/float(dt)))
  x1[j]+=x[i];

X=fft(x1)
E=T**2*(abs(X)**2-sum(x**2))/float(N**2-N)
RE=real(ifft(E))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=RE[k]/float(T)

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
J=round(T/dt);
x1=zeros([1,J]);
for i=1:N
j=fix((t(i)-T*fix(t(i)/T))/dt)+1;
x1(j)=x1(j)+x(i);
end
X=fft(x1);
E=T^2*(abs(X).^2-sum(x.^2))/(N^2-N);
RE=real(ifft(E))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=RE(k)/T;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über Zeitquantisierung (mit Abzug der Selbstprodukte, mit Normierung, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall ist)
from numpy.fft import *
N=len(t)
dt=1.0
J=int(round(T/float(dt)))
x0=zeros(J)
x1=zeros(J)
for i in range(0,N):
  j=int(floor((t[i]-T*floor(t[i]/float(T)))/float(dt)))
  x0[j]+=1.0;
  x1[j]+=x[i];

X=fft(x1)
Xp=fft(x0)
E=T**2*(abs(X)**2-sum(x**2))/float(N**2-N)
Ep=T**2*(abs(Xp)**2-N)/float(N**2-N)
RE=real(ifft(E))/float(dt)
REp=real(ifft(Ep))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=RE[k]/float(REp[k])

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
J=round(T/dt);
x0=zeros([1,J]);
x1=zeros([1,J]);
for i=1:N
j=fix((t(i)-T*fix(t(i)/T))/dt)+1;
x0(j)=x0(j)+1;
x1(j)=x1(j)+x(i);
end
X=fft(x1);
Xp=fft(x0);
E=T^2*(abs(X).^2-sum(x.^2))/(N^2-N);
Ep=T^2*(abs(Xp).^2-N)/(N^2-N);
RE=real(ifft(E))/dt;
REp=real(ifft(Ep))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=RE(k)/REp(k);
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über Zeitquantisierung (mit Abzug der Selbstprodukte, mit lokaler Normierun, auch für den Fall, dass die anzuwendende Periode kleiner als das Beobachtungsintervall istg)
from numpy.fft import *
N=len(t)
dt=1.0
mxe=mean(x)
vxe=var(x)
J=int(round(T/float(dt)))
x0=zeros(J)
x1=zeros(J)
x2=zeros(J)
for i in range(0,N):
  j=int(floor((t[i]-T*floor(t[i]/float(T)))/float(dt)))
  x0[j]+=1.0;
  x1[j]+=x[i]-mxe;
  x2[j]+=(x[i]-mxe)**2;

X=fft(x1)
Xp=fft(x0)
Xpp=fft(x2)
E=T**2*(abs(X)**2-sum((x-mxe)**2))/float(N**2-N)
Ep=T**2*(conj(Xpp)*Xp-sum((x-mxe)**2))/float(N**2-N)
Epp=T**2*(conj(Xp)*Xpp-sum((x-mxe)**2))/float(N**2-N)
RE=real(ifft(E))/float(dt)
REp=real(ifft(Ep))/float(dt)
REpp=real(ifft(Epp))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
for k in range(-(K//2),(K+1)//2):
  R[k]=vxe*RE[k]/sqrt(REp[k]*REpp[k])+mxe**2

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
mxe=mean(x);
vxe=var(x,1);
J=round(T/dt);
x0=zeros([1,J]);
x1=zeros([1,J]);
x2=zeros([1,J]);
for i=1:N
j=fix((t(i)-T*fix(t(i)/T))/dt)+1;
x0(j)=x0(j)+1;
x1(j)=x1(j)+x(i)-mxe;
x2(j)=x2(j)+(x(i)-mxe)^2;
end
X=fft(x1);
Xp=fft(x0);
Xpp=fft(x2);
E=T^2*(abs(X).^2-sum((x-mxe).^2))/(N^2-N);
Ep=T^2*(conj(Xpp).*Xp-sum((x-mxe).^2))/(N^2-N);
Epp=T^2*(conj(Xp).*Xpp-sum((x-mxe).^2))/(N^2-N);
RE=real(ifft(E))/dt;
REp=real(ifft(Ep))/dt;
REpp=real(ifft(Epp))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
for k=1:fix(K/2)+1
R(k)=vxe*RE(k)/sqrt(REp(k)*REpp(k))+mxe^2;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')
Autokorrelationsfunktion und Leistungsspektrum über Interpolation (Sample-and-Hold, mit Filterkorrektur, ohne Normierung)
from numpy.fft import *
N=len(t)
dt=1.0
J=int(round(T/float(dt)))
xp=x[N-1]*ones(J)
for i in range(0,N-1):
  for j in range(int(floor(t[i]/float(dt)))+1,int(floor(t[i+1]/float(dt)))+1):
    if j<J:
      xp[j]=x[i]
    
  

Xp=fft(xp)
Ep=dt**2*abs(Xp)**2
REp=real(ifft(Ep))/float(dt)
K=int(round(T/float(dt)))
tau=roll(arange(-(K//2),(K+1)//2)*dt,(K+1)//2)
R=zeros(K)
c=exp(-dd/float(dt))/(1-exp(-dd/float(dt)))**2
for k in range(-(K//2),(K+1)//2):
  if k==0:
    R[k]=REp[k]/float(T)
  else:
    R[k]=((2*c+1)*REp[k]-c*REp[k-1]-c*REp[k+1])/float(T)
  

plot(tau,R,'o')
show()
f=roll(arange(-(K//2),(K+1)//2)/float(K*dt),(K+1)//2)
P=real(fft(R))/float(K)
plot(f,P,'o')
show()
N=length(t);
dt=1.0;
J=round(T/dt);
xp=x(N)*ones([1,J]);
for i=1:N-1
for j=fix(t(i)/dt)+2:fix(t(i+1)/dt)+1
if j<=J
xp(j)=x(i);
end
end
end
Xp=fft(xp);
Ep=dt^2*abs(Xp).^2;
REp=real(ifft(Ep))/dt;
K=round(T/dt);
tau=circshift((-fix(K/2):fix((K-1)/2))*dt,[0;fix((K+1)/2)]);
R=zeros([1,K]);
c=exp(-dd/dt)/(1-exp(-dd/dt))^2;
R(1)=REp(1)/T;
for k=2:fix(K/2)+1
R(k)=((2*c+1)*REp(k)-c*REp(k-1)-c*REp(k+1))/T;
end
for k=fix(K/2)+2:K
R(k)=R(K-k+2);
end
plot(tau,R,'o')
f=circshift((-fix(K/2):fix((K-1)/2))/(K*dt),[0;fix((K+1)/2)]);
P=real(fft(R))/K;
plot(f,P,'o')