Holger Nobach - nambis.de

Python

Matlab/Octave

Vorbereitung (Laden von Modulen/Paketen)

from numpy import *

Simplex

f (x)

: Funktion, deren Nullstelle zu bestimmen ist

x_{l}

und

x_{r}

: die ersten beiden Teststellen, links und rechts der zu bestimmenden Nullstelle

x=[]

while (xl<(xl+xr)/2) and ((xl+xr)/2<xr):

  x.append((xl+xr)/2)

  if f(x[len(x)-1])*f(xl)>0:

    xl=x[len(x)-1]

  else:

    xr=x[len(x)-1]

x=[];

while (xl<(xl+xr)/2) && ((xl+xr)/2<xr)

x(end+1)=(xl+xr)/2;

if f(x(end))*f(xl)>0

xl=x(end);

else

xr=x(end);

end

end

Sekantenverfahren

f (x)

: Funktion, deren Nullstelle zu bestimmen ist

x_{1}

und

x_{2}

: die ersten beiden Teststellen

x=[x1,x2]

while (x[len(x)-1]!=x[len(x)-2]) and ((len(x)<3) or (abs(f(x[len(x)-1]))<abs(f(x[len(x)-2])))):

  x.append(x[len(x)-1]-(x[len(x)-1]-x[len(x)-2])/(f(x[len(x)-1])-f(x[len(x)-2]))*f(x[len(x)-1]));

x=[x1 x2];

while (x(end)&tilde=x(end-1)) && ((length(x)<3) || (abs(f(x(end)))<abs(f(x(end-1)))))

x(end+1)=x(end)-(x(end)-x(end-1))/(f(x(end))-f(x(end-1)))*f(x(end));

end

Newton-Verfahren (Tangentenverfahren) mit algebraischer Ableitung

f (x)

: Funktion, deren Nullstelle zu bestimmen ist

f' (x)

: Ableitung der Funktion

f (x)

x_{0}

: die erste Teststelle

x=[x0]

while (len(x)<2) or ((x[len(x)-1]!=x[len(x)-2]) and (abs(f(x[len(x)-1]))<abs(f(x[len(x)-2])))):

  x.append(x[len(x)-1]-f(x[len(x)-1])/fp(x[len(x)-1]))

x=[x0];

while (length(x)<2) || ((x(end)˜=x(end-1)) && (abs(f(x(end)))<abs(f(x(end-1)))))

x(end+1)=x(end)-f(x(end))/fp(x(end));

end

Newton-Verfahren (Tangentenverfahren) mit numerischer Ableitung

f (x)

: Funktion, deren Nullstelle zu bestimmen ist

ε

: Schrittweite für die numerische Ableitung

x_{0}

: die erste Teststellen

x=[x0]

while (len(x)<2) or ((x[len(x)-1]!=x[len(x)-2]) and (abs(f(x[len(x)-1]))<abs(f(x[len(x)-2])))):

  x.append(x[len(x)-1]-epsilon*f(x[len(x)-1])/(f(x[len(x)-1]+epsilon/2.0)-f(x[len(x)-1]-epsilon/2.0)))

x=[x0];

while (length(x)<2) || ((x(end)˜=x(end-1)) && (abs(f(x(end)))<abs(f(x(end-1)))))

x(end+1)=x(end)-epsilon*f(x(end))/(f(x(end)+epsilon/2)-f(x(end)-epsilon/2));

end

mehrdimensionales Newton-Verfahren (Tangentenverfahren) mit algebraischer Ableitung

f (x)

: mehrdimensionale (vektorielle) Funktion, deren (mehrdimensionale, vektorielle) Nullstelle zu bestimmen ist

f' (x)

: Matrix mit allen Ableitungen der Funktion

f (x)

(Jacobi-Matrix)

x_{0}

: die erste (vektorielle) Teststellen

from scipy.linalg import *

x=array(x0).reshape((size(x0),1))

while (len(x[0,:])<2) or ((sum(abs(x[:,-1]-x[:,-2]))>0) and (sum(abs(array(f(x[:,-1]))))<sum(abs(array(f(x[:,-2])))))):

  x=array(hstack((x,matrix(x)[:,-1]-dot(inv(fp(x[:,-1])),f(x[:,-1])))))

x=x0;

while (length(x(1,:))<2) || ((x(:,end)˜=x(:,end-1)) && (sum(abs(f(x(:,end))))<sum(abs(f(x(:,end-1))))))

x=[x,x(:,end)-inv(fp(x(:,end)))*f(x(:,end))];

end

mehrdimensionales Newton-Verfahren (Tangentenverfahren) mit numerischer Ableitung

f (x)

: mehrdimensionale (vektorielle) Funktion, deren (mehrdimensionale, vektorielle) Nullstelle zu bestimmen ist

ε

: Schrittweite für die numerische Ableitung

x_{0}

: die erste (vektorielle) Teststellen

from scipy.linalg import *

x=array(x0).reshape((size(x0),1))

while (len(x[0,:])<2) or ((sum(abs(x[:,-1]-x[:,-2]))>0) and (sum(abs(array(f(x[:,-1]))))<sum(abs(array(f(x[:,-2])))))):

  fp=zeros([len(f(x[:,-1])),len(f(x[:,-1]))])

  for j in range(0,len(f(x[:,-1]))):

    vx=zeros([size(x[:,-1]),1])

    vx[j]=epsilon/2

    fp[:,j]=((array(f(matrix(x)[:,-1]+vx))-array(f(matrix(x)[:,-1]-vx)))/epsilon).reshape(size(x0))

  

  x=array(hstack((x,matrix(x)[:,-1]-dot(inv(fp),f(x[:,-1])))))

x=x0(:);

while (length(x(1,:))<2) || ((x(:,end)˜=x(:,end-1)) && (sum(abs(f(x(:,end))))<sum(abs(f(x(:,end-1))))))

fp=zeros(length(f(x(:,end))),length(f(x(:,end))));

for j=1:length(f(x(:,end)))

vx=zeros(size(x(:,end)));

vx(j)=epsilon/2;

fp(:,j)=(f(x(:,end)+vx)-f(x(:,end)-vx))/epsilon;

end

x=[x,x(:,end)-inv(fp)*f(x(:,end))];

end

iterative Parameteroptimierung am Beispiel der Anpassung einer Exponentialfunktion mit einer überlagerten Konstanten

(x, y)

: Vektoren mit Wertepaaren

p_{0}

: Vektor mit den Startwerten der Parameter

from scipy.linalg import *

def de(p):

  return [[sum(2*(p[0]*exp(p[1]*x)+p[2]-y)*exp(p[1]*x))],[sum(2*(p[0*exp(p[1]*x)+p[2]-y)*p[0]*exp(p[1]*x)*x)],[sum(2*(p[0]*exp(p[1]*x)+p[2]-y))]]

def dep(p):

  return [[sum(2*exp(2*p[1]*x)),sum(2*p[0]*exp(2*p[1]*x)*x+2*(p[0]*exp(p[1]*x)+p[2]-y)*exp(p[1]*x)*x),sum(2*exp(p[1]*x))],[sum(2*p[0*exp(2*p[1]*x)*x+2*(p[0]*exp(p[1]*x)+p[2]-y)*exp(p[1]*x)*x),sum(2*p[0]**2*exp(2*p[1]*x)*x**2+2*(p[0]*exp(p[1]*x)+p[2]-y)*p[0]*exp(p[1]*x)*x**2),sum(2*p[0]*exp(p[1]*x)*x)],[sum(2*exp(p[1]*x)),sum(2*p[0]*exp(p[1]*x)*x),2*len(x)]]

p=array(p0).reshape((size(p0),1))

while (len(p[0,:])<2) or ((sum(abs(p[:,-1]-p[:,-2]))>0) and (sum(abs(array(de(p[:,-1]))))<sum(abs(array(de(p[:,-2])))))):

  p=array(hstack((p,matrix(p)[:,-1]-dot(inv(dep(p[:,-1])),de(p[:,-1])))))

de=@(p)([sum(2*(p(1)*exp(p(2)*x)+p(3)-y).*exp(p(2)*x));sum(2*(p(1)*exp(p(2)*x)+p(3)-y)*p(1).*exp(p(2)*x).*x);sum(2*(p(1)*exp(p(2)*x)+p(3)-y))]);

dep=@(p)([sum(2*exp(2*p(2)*x)),sum(2*p(1)*exp(2*p(2)*x).*x+2*(p(1)*exp(p(2)*x)+p(3)-y).*exp(p(2)*x).*x),sum(2*exp(p(2)*x));sum(2*p(1)*exp(2*p(2)*x).*x+2*(p(1)*exp(p(2)*x)+p(3)-y).*exp(p(2)*x).*x),sum(2*p(1)^2*exp(2*p(2)*x).*x.^2+2*(p(1)*exp(p(2)*x)+p(3)-y)*p(1).*exp(p(2)*x).*x.^2),sum(2*p(1)*exp(p(2)*x).*x);sum(2*exp(p(2)*x)),sum(2*p(1)*exp(p(2)*x).*x),2*length(x)]);

p=p0(:);

while (length(p(1,:))<2) || ((p(:,end)˜=p(:,end-1)) && (sum(abs(de(p(:,end))))<sum(abs(de(p(:,end-1))))))

p=[p,p(:,end)-inv(dep(p(:,end)))*de(p(:,end))];

end