Matrizenberechnung

[HTLEisenstadt]

Hallo,
bin neu hier, habe für eine Diplomarbeit folgendes Problem bei der Python-Programmierung:

- Ich habe N+1 Gleichungen mit ebenso vielen unbekannten, die ich in Matrix-Form aufschreiben will, nur weiß ich leider nicht wie.
- Ich kann simple Matrizen schreiben und rechnen, nur mit N+1 bin ich überfordert.
Es sieht dann quasi so aus: (oder soll so aussehen )

Matrix A: Mit N Werte einer Funktion und -1 an letzer Stelle für die N+1 Bedingung. D.h., N+1 Zeilen und auch Spalten.
Diese wird dann mit der Matrix g multipliziert: 1Spalte und N+1 Zeilen

Ich weiß, dass ist etwas unübersichtlich geschrieben, hat vil. dennoch wer eine Idee?
Kann mir da irgendwer bitte helfen?

Danke schon im Voraus für die Antworten...
PS: Ich könnte auch ein Bild anhängen, wenn wir jemand sagt, wie das geht?

LG Burak

[EyDu]

Hallo und willkommen im Forum!

Und was genau ist jetzt das Problem?

[HTLEisenstadt]

Hallo Ey Du,

woow, bin überrascht über die schnelle Antwort!

Naja, das Problem ist, dass ich nicht weiß, mit welchem Befehl ich diese Matrizen eingeben kann/soll? (np.array?)
Nur wie geb ich diese N+1 ein? in einer Schleife? Sodas es Python akzeptiert und es richtig ist?

Sorry für die Fragen, ich weiß was manche denken werden, bin wirklich in Programmieranfänger und verstehe das nicht ganz!

LG und DANKE, Burak

[EyDu]

Code: Alles auswählen

>>> n = 5
>>> m = np.matrix(np.zeros((n+1, n+1)))
>>> for i in range(n+1):
...     for j in range(n+1):
...         m[i,j] = i*j
... 
>>> m
matrix([[  0.,   0.,   0.,   0.,   0.,   0.],
        [  0.,   1.,   2.,   3.,   4.,   5.],
        [  0.,   2.,   4.,   6.,   8.,  10.],
        [  0.,   3.,   6.,   9.,  12.,  15.],
        [  0.,   4.,   8.,  12.,  16.,  20.],
        [  0.,   5.,  10.,  15.,  20.,  25.]])

Wenn du die Eingabe von n und den Werten nicht selber schaffst, dann solltest du dringend das Tutorial durcharbeiten.

Hilfreich könnte auch der Code sein:

Code: Alles auswählen

>>> np.array([1,2,3,4,5,6,7,8,9]).reshape((3, 3))
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

[HTLEisenstadt]

Hallo,

also bis jetzt hab ich das von meinem Programm:

Code: Alles auswählen

import scipy as sp
import numpy as np
import math
import csv
from numpy import *
from scipy import linalg
from scipy import mat
import matplotlib.pyplot as plt
stelle1 = float(input("Geben Sie bitte die erste Ziffer Ihres Profils ein: "))
stelle2 = float(input("Geben Sie bitte die zweite Ziffer Ihres Profils ein: "))
stelle3 = float(input("Geben Sie bitte die letzten zwei Ziffern Ihres Profils ein: "))
laenge =  float(input("Geben Sie bitte die Länge Ihres Profiles ein: "))
stelle11=int(stelle1)
stelle22=int(stelle2)
stelle33=int(stelle3)
f=stelle1
xf=stelle2
d=stelle3
a0=1.4845
a1=-0.63
a2=-1.758
a3=1.4215
a4=-0.5075
print "ihr Profil lautet: NACA", stelle11, stelle22 ,stelle33
N=input("Anzahl der Panels =  ")
N=int (N)
xs=np.zeros((N+1),dtype=np.float)
ys=np.zeros((N+1),dtype=np.float)
xp=np.zeros((N+1),dtype=np.float)
yp=np.zeros((N+1),dtype=np.float)
yd=np.zeros((N+1),dtype=np.float)
xm=np.zeros((N+1),dtype=np.float)
ym=np.zeros((N+1),dtype=np.float)
xq=np.zeros((N+1),dtype=np.float)
yq=np.zeros((N+1),dtype=np.float)
tx=np.zeros((N+1),dtype=np.float)
ty=np.zeros((N+1),dtype=np.float)
Lj=np.zeros((N+1),dtype=np.float)
FF=np.zeros((N+1),dtype=np.float)
x=np.zeros((N+1),dtype=np.float)
y=np.zeros((N+1),dtype=np.float)

def FF(i,x,y):
    if yq!=0:
        FF=1/(4*math.pi)*((2*yq)*(math.atan((Lj-xq)/yq)+math.atan(xq/yq)+((Lj-xq)*math.log(math.pow((Lj-xq),2)+math.pow(yq,2)))+(xq*math.log(math.pow(xq,2)+math.pow(yq,2)))-(2*Lj)))
    else:
        FF=1/(4*math.pi)*((2*(Lj-xq)*math.log((abs(Lj-xq)))+((2*xq)*math.log(abs(xq))-(2+Lj))))
for i in range (1, N+1, 1):
    xs[i]=(1+math.cos(2*math.pi*(i-1)/N))/2
    if xs[i]<xf:
        ys[i]=f*(2*xs[i]/xf-math.pow((xs[i]/xf),2))
        tg=2*f/xf*(1-xs[i]/xf)
    else:
        ys[i]=f*(1-math.pow((xs[i]-xf)/(1-xf),2))
        tg=-2*f*(xs[i]-xf)/math.pow((1-xf),2)
    cos=1/math.sqrt(1+tg*tg)
    sin=tg*cos
    yd[i]=d*(a0*math.sqrt(xs[i])+a1*xs[i]+a2*math.pow(xs[i],2)+a3*math.pow(xs[i],3)+
         a4*math.pow(xs[i],4))
    if (i>(N+1)/2):
        xp[i]=xs[i]+yd[i]*sin
        yp[i]=ys[i]-yd[i]*cos
    else:
        xp[i]=xs[i]-yd[i]*sin
        yp[i]=ys[i]+yd[i]*cos
for i in range (1,N,1): 
    xm[i]=(xp[i+1]+xp[i])/2
    ym[i]=(yp[i+1]+yp[i])/2
Lj=math.sqrt(math.pow((xp[i]-xp[i+1]),2)+math.pow((yp[i]-yp[i+1]),2))
tx=(xp[i]-xp[i+1])/Lj
ty=(yp[i]-yp[i+1])/Lj
nx=-ty
ny=tx
xq=(x-xp[i+1])*tx+(y-yp[i+1])*ty

Funktioniert auch soweit!
Nun probier ich deine Matrix!

-Was bedeutet n=5 am Beginn deines Codes?

Den Rest probier ich mal - vielen Dank einstweilen!

[HTLEisenstadt]

Hallo nochmal,

irgendwie ist das nicht genau das, was ich wollte, wie kann man denn Bilder einfügen hier?

-Ich habe eine N+1 Zeilen/Spalten Matrix, die ich A nenne! Jeder dieser Werte der N+1 Zeilen/Spalten in dieser Matrix sind eine lange Funktion, die ich vorher schon definiert habe! (Funktion FF)
(F[1,1], F[1,2]......F[1,N]-1)
(F[2,1], F[2,2]......F[2,N]-1)
(....................................)
(F[N,1], F[N,2]......F[N,3]-1)
(1,0,0,........................1,0)
Jede dieser F ist ein Funktion.

-Dann eine N+1 Zeilen/1-Spaltenmatrix, die ich g nenne! All diese Werte in dieser Matrix sind unbekannt!
(Gamma1)
(Gamma2)
(...........)
(GammaN)
( C )
Dann hab ich weitere in einer Matrix (b genannt) aufgeschriebenen Gleichungen mit N+1 Zeilen, die alle bekannt sind, jedoch variiren!
(u*x1-u*y1)
(u*x2-u*y2)
(...............)
(u*xN-u*yN)
( 0 )

Jetzt möchte ich, dass ich die Matrix g (unbekannten) mit g=A^-1*b ausrechne....
Geht das, wenn Ja, wie genau?

Grüße Burak

[gkuhl]

Jetzt möchte ich, dass ich die Matrix g (unbekannten) mit g=A^-1*b ausrechne....
Geht das, wenn Ja, wie genau?

Ja, das geht mit numpy:

Code: Alles auswählen

import numpy as np

# mit Matrizen:
A = np.matrix(np.eye(3))
b = np.matrix([1.,1.,1.]).T
g = A.I * b

# mit Arrays:
A = np.eye(3)
b = np.array([1.,1.,1.])
g = np.linalg.solve(A,b)

Das kannst du am besten in einem interaktiven Shell (am besten IPython (http://ipython.org/)) ausprobieren.

Grüße
Gerrit

[HTLEisenstadt]

Hallo gkuhl,

vielen Dank, hab das probiert und bin dem ganzen schon einen Schritt näher...

Nur bekomme ich eine Fehlermeldung:
-----------------------------------
Traceback (most recent call last):
File "C:\Users\xxxxxxxxxxxx\Desktop\uebung.py", line 83, in <module>
g=A.I*b
File "C:\Python26\lib\site-packages\numpy\matrixlib\defmatrix.py", line 319, in __mul__
return N.dot(self, asmatrix(other))
ValueError: matrices are not aligned
------------------------------------
Was könnte da sein?
Der 3er nach dem np.eye bedeutet die Reihenanzahl oder? Die weiß ich aber nicht, also geb ich da N+1 ein oder?
Und wie gebe ich für die Matrix b die Formeln in der Matrix ein, also die u*x1-u*y1 bis u*xN-u*yN und als letzte Zeile 0 ? So wies ich vorher gepostet hab...

Die Formel ist jetzt verständlich, aber die Eingabe der 3 Matrizen noch nicht ganz... Kann mir da bitte noch jemand helfen?

Grüße Burak

[gkuhl]

ValueError: matrices are not aligned
------------------------------------
Was könnte da sein?

Ich würde mal sagen, die Dimensionen der Matrizen passen nicht zusammen, z.B. weil "b" ein Zeilenvektor ist.

Die Formel ist jetzt verständlich, aber die Eingabe der 3 Matrizen noch nicht ganz... Kann mir da bitte noch jemand helfen?

Wie das am besten geht hängt von den Einträgen deiner Matrix hab. Wenn du die Elemente in Abhängigkeit von Zeile und Spalte ausdrücken kannst, kannst du, wie von EyDu schon gezeigt, über Zeilen- und Spaltennummer iterieren und die Matrix auffüllen. Alternativ könnte man die Matrix auch aus Spalten- oder Zeilenvektoren aufbauen (mit np.concatenate), die Diagonalen befüllen (bei Bandmatrizen), etc.

[BlackJack]

@HTLEisenstadt: Was die drei als Argument für die `eye()`-Funktion bedeutet, kann man in der Dokumentation nachlesen. Und gkuhl hatte ja auch schon den Tipp gegeben solche Sachen in einer Python-Shell auszuprobieren.

Die Fehlermeldung ist ziemlich deutlich. Die Matrizen passen nicht zusammen für die Operation die da ausgeführt werden soll. Also in diesem Fall das Kreuzprodukt. Also lass Dir mal Deine beiden Matrizen ausgeben und schau Dir an wie die aussehen.

Wenn ich mir Deine `FF()`-Funktion so anschaue die das gleichnamige `FF`-Arrayobjekt verdeckt und einen lokalen Namen `FF` definiert, eine ``if``-Bedingung enthält die auf den ersten Blick sinnfrei erscheint, und auf den zweiten Blick einen `ValueError` zur Folge hat, und letztendlich überhaupt keinen Effekt hat wenn man sie aufrufen würde (und der Fehler nicht da wäre), dann solltest Du vielleicht mal einen Schritt zurück gehen, das zu lösende Problem beisite legen, und erst einmal die Grundlagen von der Programmiersprache lernen.

Die Namen sind so ziemlich alle reichlich nichtssagend und es gibt wohl auch zu viele davon. Diese nummerierten `stelle*`-Namen beispielsweise. Da verwirrt mich auch der Text in der Benutzerinteraktion im Kontrast zu dem was mit der Eingabe dann passiert. Der Benutzer wird aufgefordert *eine* *Ziffer* einzugeben und die Eingabe wird in eine *Fliesskommazahl* umgewandelt? Und diese dann an einen anderen Namen gebunden in eine ganze Zahl. Und die Fliesskommazahl wird noch einmal an einen anderen Namen gebunden, wobei der erste danach nie wieder verwendet wird.

Wenn man anfängt Namen zu nummerieren, will man in 99% der Fälle eigentlich *einen* Namen und die Werte in einer passenden Datenstruktur. Zum Beispiel eine Liste.

Bei den ``import``\en sollte man mal aufräumen. Es wird nicht alles verwendet, und der Sternchenimport bei `numpy` sollte weg. Sternchenimporte sind in Ausnahmefällen und in einer interaktiven Shell okay, aber nicht bei Modulen die Unmengen an Namen in den aktuellen Modulnamensraum holen. Das führt zu undurchsichtigen Programmen.

Die eine oder andere Leerzeile wäre auch nicht schlecht. Und Funktionen statt das alles in einem Block runter zu schreiben. Dabei auf eine Trennung zwischen Benutzerinteraktion und Programmlogik/Berechnung achten.

Bei den ganzen ``for``-Schleifen und den ständigen Indexzugriffen stellt sich die Frage warum überhaupt `numpy` verwendet wird, beziehungsweise warum es *nicht* verwendet wird.

[HTLEisenstadt]

Hallo,

naja, ich habe das so gemacht, wie du das gesagt hast, aber irgendwie funkt das nicht...
Es ist so extrem kompliziert für mich das zu erklären.
Wie kann ich eine Matrix schreiben, wenn ich nicht mal weiß wie groß die ist? Also die Größe hängt von der Eingabe am Anfang des Programmes (N) ab! Die Matrizen (g,A,b) werden dann N+1 Zeilen bzw Spalten Groß, bis auch die Matrix g, die wird N+1 Zeilen groß, aber nur eine Spalte!
Und wie gebe ich diese Formel in eine Matrix ein: u*x1-u*y1 ........ bis ....... u*xN-u*yN und als letzte Zeile 0?
Wie kann ich hier im Forum ein Bild einfügen, vil. ist es dann verständlich was ich will?

Grüße und Danke...

[BlackJack]

@HTLEisenstadt: Du willst wirklich ganz dringend mal Abstand von Matrizen nehmen und die Grundlagen von der Programmiersprache lernen. Denn diese Frage wie man eine erst zur Laufzeit bekannte Anzahl von Werten eingibt, sollte man nach jedem vernünftigen Grundlagentutorial eigentlich problemlos selbst beantworten können. So etwas wie „Schreiben sie ein Programm, welches den Benutzer nach der Anzahl der einzugebenden Werte fragt; dann diese Werte vom Benutzer erfragt und in einer Datenstruktur speichert; nach der Eingabe die Werte noch einmal ausgibt; und zum Schluss die Summe und den Durchschnitt der Werte ausgibt.” ist eine ganz typische Programmieraufgabe für Anfänger.

[HTLEisenstadt]

Okay... Kannst du mir was empfehlen zum durchackern?
Na Gut - in der Schule hatte ich schon die größten Probleme nur eine Fakultät etc. zu programmieren, da hatte ich die größten Schwierigkeiten beim mitdenken...

LG

[snafu]

in der Schule hatte ich schon die größten Probleme nur eine Fakultät etc. zu programmieren, da hatte ich die größten Schwierigkeiten beim mitdenken...

Einfach nur, weil ich's nicht lassen kann...

Code: Alles auswählen

from operator import mul

def fac(n):
    return reduce(mul, xrange(1, n + 1), 1)

Wobei da theoretisch noch eine Vorprüfung auf negative, sowie auf nicht-ganze Zahlen rein müsste.

[BlackJack]

@HTLEisenstadt: In der Python-Dokumenation ist ein Tutorial und für Anfänger ist Learn Python The Hard Way etwas das öfter empfohlen wird. Und nach Python-Grundlagen wäre ein `numpy`-Tutorial hilfreich um den Umgang mit den Array- und Matrizentypen kennen zu lernen.