Hallo zusammen!
Ich bearbeite gerade ein projekt in Python.
Unter anderem beinhaltet es ein bdf-verfahren mit newton iterationen.
Da ich seit kurzem erst mit python programmiere, habe ich probleme;
eines davon ist
Q = array([[g1u(x, h, a, d),g1v(x, h, a, d)],[ g2u(x, h, b),g2v(x, h, b)]])
ValueError: setting an array element with a sequence.
Das programm macht einen schritt aber beim nächsten kommt dieser fehler.
Dabei wird der neue wert x (2 dimensionaler vektor ), der nach dem ersten schritt neu berechnet wurde, übergeben und nun kann das prog plötzlich nicht mehr mit ihm weiterrechnen und der fehler erscheint!
Ich bitte dringend um Hilfe,
und bedanke mich schonmal dafür!
gruß
ValueError: setting an array element with a sequence.
-
BlackJack
@x1n1: Irgendeine der Funktionen gibt etwas mit einer anderen Dimension als die anderen zurück. Wobei ich jetzt übrigens mal davon ausgehe, dass `array` von `numpy` kommt und zum Beispiel nicht aus der Standardbibliothek. So etwas solltest Du in Zukunft dazusagen.
Mal so als Beispiel etwas das funktioniert und etwas das diese Ausnahme auslöst:
Mal so als Beispiel etwas das funktioniert und etwas das diese Ausnahme auslöst:
Code: Alles auswählen
In [82]: np.array([[1,2],[3,4]])
Out[82]:
array([[1, 2],
[3, 4]])
In [83]: np.array([[1,2],[3,[4,5]]])
---------------------------------------------------------------------------
<type 'exceptions.ValueError'> Traceback (most recent call last)
/home/bj/<ipython console> in <module>()
<type 'exceptions.ValueError'>: setting an array element with a sequence.
Ja ich habe numpy importiert.
Es ist nur sehr verwirrend, da das Prog mit anderen Funktionen ohne Probleme läuft.
Vielleicht erläuter ich mal genauer das Problem:
also
g1u(x, h, a, d), g1v(x, h, a, d) , g2u(x, h, b) , g2v(x, h, b)
sind Funktionen, die als Input a,b,d,h reelle Zahlen Floats haben
und x ein 2dim. Vektor, also zb. array([2.3,5.3],float)
Die Funktionen liefern aber jeweils nur eine reelle Zahl, Float wieder!
Q = array([[g1u(x, h, a, d),g1v(x, h, a, d)],[ g2u(x, h, b),g2v(x, h, b)]])
Soll jetzt eine Matrix sein, mit den vier reellen Einträgen aus den Funktionen.
Das klappt auch ohne Probleme eine Iteration, sobald sich aber das x verändert, dann kann er das neue Q nicht mehr berrechnen, obwohl x immer noch ein 2dim vektor ist!
@HWK danke, aber die arbeit muss und will ich mir machen
Es ist nur sehr verwirrend, da das Prog mit anderen Funktionen ohne Probleme läuft.
Vielleicht erläuter ich mal genauer das Problem:
also
g1u(x, h, a, d), g1v(x, h, a, d) , g2u(x, h, b) , g2v(x, h, b)
sind Funktionen, die als Input a,b,d,h reelle Zahlen Floats haben
und x ein 2dim. Vektor, also zb. array([2.3,5.3],float)
Die Funktionen liefern aber jeweils nur eine reelle Zahl, Float wieder!
Q = array([[g1u(x, h, a, d),g1v(x, h, a, d)],[ g2u(x, h, b),g2v(x, h, b)]])
Soll jetzt eine Matrix sein, mit den vier reellen Einträgen aus den Funktionen.
Das klappt auch ohne Probleme eine Iteration, sobald sich aber das x verändert, dann kann er das neue Q nicht mehr berrechnen, obwohl x immer noch ein 2dim vektor ist!
@HWK danke, aber die arbeit muss und will ich mir machen
Ich habe mir zwischenwerte angeben lassen und habe jetzt den Punkt gefunden welches das Problem darstellt.
Das Prog liefert:
sol1= [ 0.5 0.5]
g1u= 1.90816326531
g1v= 1.42857142857
g2u= -0.1
g2v= 1.6
[[ 1.90816327 1.42857143]
[-0.1 1.6 ]]
g1= 0.855242038286
g2= 0.372650654
b= [ 0.85524204 0.37265065]
(1, array([ 0.26118178, 0.24923052]), 0.00088001252901764859, 3)
Lösung des Newtonverfahrens y= [ 0.23881822 0.25076948] Anzahl der der Schlaufendurchläufe j= 1
sol1= [ 0.23881822 0.25076948]
g1u= 1.49854964548
g1v= 1.08846082716
g2u= [-0.94298216 -0.41088125]
g2v= [ 2.44084034 1.90994801]
A = jacobimatrix(sol1, a, b, d, h)
...
[e3,e4]])
ValueError: setting an array element with a sequence.
Der Fehler ist nun das plötzlich g2u und g2v 2dim arrays sind; sollen aber reelle zahlen sein, was sie auch beim ersten Schritt sind (siehe Output).
Warum wandelt Python meine Funktionsauswertungen nach einem Durchgang in 2dim arrays um?
Das Prog liefert:
sol1= [ 0.5 0.5]
g1u= 1.90816326531
g1v= 1.42857142857
g2u= -0.1
g2v= 1.6
[[ 1.90816327 1.42857143]
[-0.1 1.6 ]]
g1= 0.855242038286
g2= 0.372650654
b= [ 0.85524204 0.37265065]
(1, array([ 0.26118178, 0.24923052]), 0.00088001252901764859, 3)
Lösung des Newtonverfahrens y= [ 0.23881822 0.25076948] Anzahl der der Schlaufendurchläufe j= 1
sol1= [ 0.23881822 0.25076948]
g1u= 1.49854964548
g1v= 1.08846082716
g2u= [-0.94298216 -0.41088125]
g2v= [ 2.44084034 1.90994801]
A = jacobimatrix(sol1, a, b, d, h)
...
[e3,e4]])
ValueError: setting an array element with a sequence.
Der Fehler ist nun das plötzlich g2u und g2v 2dim arrays sind; sollen aber reelle zahlen sein, was sie auch beim ersten Schritt sind (siehe Output).
Warum wandelt Python meine Funktionsauswertungen nach einem Durchgang in 2dim arrays um?
-
BlackJack
@x1n1: Diese Ausgabe sagt uns natürlich nicht sehr viel, weil wir nicht wissen wie sie zustande kommt.
Wie kommen denn `g2u` und `g2v` im ersten Durchlauf zustande? Anders als im zweiten? Im ersten vielleicht durch direkte Zuweisung von Werten und in allen Folgenden durch eine Berechnung mit den vorherigen Werten? Und diese Berechnung gibt ein keinen Skalar zurück, auch wenn Du das behauptest und erwartest!?
Wie kommen denn `g2u` und `g2v` im ersten Durchlauf zustande? Anders als im zweiten? Im ersten vielleicht durch direkte Zuweisung von Werten und in allen Folgenden durch eine Berechnung mit den vorherigen Werten? Und diese Berechnung gibt ein keinen Skalar zurück, auch wenn Du das behauptest und erwartest!?
Ja genau, bei der ersten Berechnung werden feste Werte zugewiesen
und bei den folgenden nimmt er den neuberechnetet Wert für die Funktionsauswertung.
Hier die Problem-Funktionen:
g2u und g2v sollen als output/return eine reelle Zahl haben.
und bei den folgenden nimmt er den neuberechnetet Wert für die Funktionsauswertung.
Hier die Problem-Funktionen:
Code: Alles auswählen
def g2u(x, h, b):
g = (((x[1]**2)*h*b*-1.)/(x[0]**2))
print "g2u=", g
return g
def g2v(x, h, b):
l = ((3./2.)-h*b+2.*h*b)*(x[1]/x[0])
print "g2v=", l
return l
"Erstellen der Jacobimatrix"
def jacobimatrix(x, a, b, d, h):
e1 = g1u(x, h, a, d)
e2 = g1v(x, h, a, d)
e3 = g2u(x, h, b)
e4 = g2v(x, h, b)
A = array([[e1,e2],
[e3,e4]])
return Ag2u und g2v sollen als output/return eine reelle Zahl haben.
Zuletzt geändert von x1n1 am Sonntag 7. Februar 2010, 17:37, insgesamt 2-mal geändert.
So sieht der gesamte Quelltext des Unterprogs aus:
Code: Alles auswählen
from scipy.linalg import *
from scipy.linalg import gmres
from numpy import *
"Funktionen F"
def g1(x, x_1, x_2, h, a, d):
c = x[0]*((3./2.)-h+h*x[0]) + ((h*a*x[0]*x[1])/(x[0]+d)) - 2.*x_1[0] + \
0.5*x_2[0]
print "g1=", c
return c
def g2(x, x_1, x_2, h, b):
d = x[1]*((3./2.)-h*b) + h*b*(x[1]**2./x[0]) - 2.*x_1[1] + 0.5*x_2[1]
print "g2=", d
return d
"Ableitungs-Funnktionen der Jacobimatrix DF"
def g1u(x, h, a, d):
e = (3./2.)-h+2.*h*x[0]+((h*a*x[1]*(x[0]+d)-h*a*x[0]*x[1])/(x[0]+d)**2)
print "g1u=", e
return e
def g1v(x, h, a, d):
f = (h*a*x[0])/(x[0]+d)
print "g1v=", f
return f
def g2u(x, h, b):
f = (((x[1]**2.)*h*b*-1.)/(x[0]**2.))
print "g2u=", f
return f
def g2v(x, h, b):
l = ((3./2.)-h*b+2.*h*b)*(x[1]/x[0])
print "g2v=", l
return l
"Erstellen der Jacobimatrix"
def jacobimatrix(x, a, b, d, h):
e1 = g1u(x, h, a, d)
e2 = g1v(x, h, a, d)
e3 = g2u(x, h, b)
e4 = g2v(x, h, b)
A = array([[e1,e2],
[e3,e4]])
return A
# Gauss-Seidel Verfahren fuer die Loesung des Gleichungssystems Ax = b
"Aus der Numerik-1-Übung"
def gauss_seidel(A,b,x0,tol=1.0e-3,maxiter = 3000):
"""Gauss-Seidel Verfahren fuer die Loesung des Gleichungssystems Ax = b
Input: Matrix A, rechte Seite b, Anfangsloesung x0, Toleranz tol
und Maximale Anzahl von
Iterationen maxiter.
Das Verfahren wird abgebrochen, falls die Maximale Anzahl von Iterationen
ist erreicht
oder der relative Fehler in der rechten Seite ist kleiner oder gleich tol.
"""
sol = x0
res = norm(b-dot(A,x0))/norm(b)
n = x0.shape[0]
N = 0
while (res > tol) and (N <= maxiter):
newsol = zeros(n)
for i in xrange(n):
sum = 0.0
for j in xrange(i):
sum = sum + A[i][j]*newsol[j]
for j in range(i+1,n):
sum = sum + A[i][j]*sol[j]
newsol[i] = 1.0/A[i][i]*(b[i]-sum)
N = N + 1
sol = newsol
res = norm(b-dot(A,sol))/norm(b)
if res <= tol:
return 1,sol,res,N
else:
return 0,sol,res,N
"Testen des Verfahrens"
#TEST
"Toleranz für das Newtonverfahren!"
tol2 = 1.0e-5
"Anfangswert"
a = 2.
b = 0.1
d = 0.2
h = 1.
x = array([0.5, 0.5],float)
x0 = array([0.5, 0.5],float)
x_1 = array([0.254521838, 0.251174673],float)
x_2 = array([0.3, 0.25],float)
"Schritte des Newtonverfahrens bis zur gewünschten Genauigkeit"
y = x0
nor = 1.
j = 0
while (nor > tol2):
sol1 = y
print "sol1=", sol1
A = jacobimatrix(sol1, a, b, d, h)
print "A=", A
b = array([ g1(sol1,x_1,x_2, h, a, d), g2(sol1,x_1,x_2, h, b)], float)
print "b=", b
gssol = gauss_seidel(A,b,x0,maxiter=3000)
print gssol
y = y + gssol[1]*-1.
"Abbruchkriterium wird aktualisiert"
nor = norm(gssol[1])
j = j + 1
print "Lösung des Newtonverfahrens y=", y,
print "Anzahl der der Schlaufendurchläufe j=", j-
BlackJack
@x1n1: Was mir da so nur mal beim drüberschauen auffällt: `b` wird in Zeile 91 an einen skalaren Wert gebunden und damit wird `jacobimatrix()` aufgerufen und in Zeile 108 wird `b` dann an ein Array mit zwei Einträgen gebunden für die weiteren Aufrufe. Soll das so sein?
Und wieder einmal wurde die Wichtigkeit einer sinnvollen Namensvergabe für Bezeichner eindrucksvoll demonstriert. Danke dafür.x1n1 hat geschrieben:Es lag daran, dass dieses eine b mit dem anderen nichts zu tun hatte!