keg:=matrix([[x^2 + 4*x*y + 4*x + 4*y^2 + 18*y + 34]])
Parabel in allgemeiner Lage, Beispiel 1
Prof. Dr. Dörte Haftendorn: Mathematik mit MuPAD 4 Juli 07 Update .07.07
Web: https://mathe.web.leuphana.de www.mathematik-verstehen.de ######################################################
Ganzzahliger Eigenwert, ein Eigenwert 0,
-----------------------------------
keg:=matrix([[x^2 + 4*x*y + 4*x + 4*y^2 + 18*y + 34]])
kegp:=plot::Implicit2d(keg[1],x=-1..8,y=-10..1, LineWidth=1):
plot(kegp,Scaling=Constrained);
Dieser Kegelschnitt ist eventuell eine Parabel. Eine Ellipse kommt nach Sicht auch infrage.
Durchführung einer Hauptachsentransformation
A:= matrix([[1,2],[2,4]]);
a:=matrix([4,18]): at:=linalg::transpose(a);
d:=34;
Bestimmung der Achsenrichtungen:
evli:=linalg::eigenvectors(A)
Eigenwerte mit ihrer Vielfachheit und ihrem Eigenvektor.
Ein Eigenwert ist 0, daher ist es Parabel und nicht Ellipse.
Damit später y=a x^2 herauskommt, wird hier die Nummerierung geändert.
ev2:=evli[1][3][1]; //Nummerierung vertauscht
ev1:=evli[2][3][1];
ew2:=evli[1][1];
ew1:=evli[2][1];
linalg::det(ev1.ev2)
Wenn diese Determinate neagtiv ist, tauscht man die EV besser um.
Oder man nimmt einen der EV andersherum, Rechtsystem ist günstig.
Anderenfalls ist noch eineSpiegelung im Spiel.
float(ev1),float(ev2)
Einzeichnen der Eigenvektoren:
ev1p:=plot::Arrow2d(ev1):
ev2p:=plot::Arrow2d(ev2):
plot(kegp,ev1p,ev2p, Scaling=Constrained)
Wie erwartet sind die Eigenvektoren die Richtungen der Hauptachsen des Kegelschnittes.
---------------------------------------------------
Bestimmung der Kegelschnittgleichung
Die Theorie sagt, dass die Eigenwerte nun die Faktoren der quadratischen Glieder werden.
Das heißt hier, dass man nun schon sieht, dass es nur ein quadratisches Glied gibt.
Damit muss es sich um eine Parabel handeln, wenn nach der Transformation noch die andere
Variable linear vorkommt. Da wir oben schon gezeichnet haben, war ja schon klar, dass es eine Parabel ist.
Soll die gegebene blaue Parabel in Hauptachsenlage abgebildet werden,
so kann das geschehen durch eine Drehung um den Ursprung, evt. verknüpft mit einer
Achsenspiegelung an einer der Koordinatenachsen, gefolgt von einer Verschiebung.
und
Aus den normierten Eigenvektoren erstellt man eine Matrix P.
Die Eigenvektoren stehen gleich von alleine senkrecht aufeinander, wenn die Eigenwerte verschieden sind.
P ist dann eine Orthonormal-Matrix. Für solche ist die inverse Matrix
gleich der transponierten Matrix, bezeichnet mit Pt (oder mit hochstelltem T).
Die Transformationsmatrix, die den Kegelschnitt in eine Lage bewegt, bei der die Hauptachsen parallel
zu den Koordinatenachsen sind, ist Pt.
Die Theorie sagt nun, dass Pt*A*P die Diagonalmatrix aus den Eigenwerten ist.
Davon kann man sich hier überzeugen:
ev1n:=linalg::normalize(ev1):
ev2n:=linalg::normalize(ev2):
P:=ev1n.ev2n
float(P);
Pt:=linalg::transpose(P)
float(Pt)
Diagonalisierung, die klappt immer, wenn die EV eine ONB bilden,
wenn man also so ein P aufstellen kann.
Simplify(Pt*A*P);
float(Pt*A*P)
Evt. winzige 10^-19 Werte sind numerisch 0.
---------------------------------------------------------------
Vektorschreibweise für die Abbildung und die
Quadrikgleichungen, die sich durch Einsetzen ergeben:
Abbildung der linearen Terme erfordert also
at
atb:=at*P
kegSD:=ew1*x^2+ew2*y^2+atb[1]*x+atb[2]*y+d
kegSDp:=plot::Implicit2d(kegSD=0,x=-6..7,y=-10..1,
LineWidth=1,LineColor=[0,1,0],GridVisible=TRUE):
plot(kegp,kegSDp, Scaling=Constrained)
Bei der Betrachtung dieses Bildes fällt auf, dass es sich um eine negative
Drehung um den Ursprung handelt.
Pt*A*P
P
at
at*P
Pt, float(Pt);
Dr:=phi->matrix([[cos(phi),-sin(phi)],[sin(phi),cos(phi)]]): Dr(`ϕ`);
Der Vergleich mit der allgemeinen Drehmatrix ergibt, dass es mit dem Anpassen
von phi klappen kann:
cos(phi)=float(Pt[1,1]);sin(phi)=float(Pt[2,1]);
arccos((Pt[1,1]));
wi:=arcsin((Pt[2,1]));
Daraus folgt umgerechnet ins Winkelmaß:
float(arccos((Pt[1,1]))/PI*180);
wig:=float(arcsin((Pt[2,1]))/PI*180);
Damit kann die gemeinsame Lösung nur der negative Winkel wi sein.
So passt es auch zur Zeichnung.
Einzeichnen des Zwischenbildes:
p:=matrix([x,y]);
pt:=linalg::transpose(p);
float(Dr(wi)),float(Pt)
Beachte, dass die inverse Drehung die ist, die um den negativen Winkel dreht.
kegD:=simplify(pt*Dr(wi)*A*Dr(-wi)*p+at*Dr(-wi)*p+d);
Dieses hat man ja auch als transformierte Gleichung erhalten.
kegSD
kegDp:=plot::Implicit2d(kegD[1],x=-6..5,y=-8..1,
LineWidth=1,LineColor=[1,0,1],LineStyle=Dashed,GridVisible=TRUE):
plot(kegp,kegSDp,kegDp,Scaling=Constrained)
##############################
Bestimmung der Translation:
kegSD
Die Arbeitsweise ist dieselbe wie bei der Herstellung der Scheitelform einer Parabel.
Hier durch Hinsehen:
xterm:=hold(5*(x+4/5*sqrt(5))^2);expand(xterm);
d-16
yterm:=hold(2*sqrt(5)*(y+9/(sqrt(5))));expand(yterm);
Also
kegSDK:=xterm+yterm
expand(kegSDK) //Probe
Letzter Teil der Hauptachsentransformation ist die Translation t
t:=matrix([4/5*sqrt(5),9/5*sqrt(5)])
also
Das ergibt:
kegH:=ew1*x^2+2*sqrt(5)*y
Angabe der Gleichung in der üblichen Form:
hold(y=-sqrt(5)/2*y^2)
kegHp:=plot::Implicit2d(kegH,x=-1.7..7,y=-8..1, LineWidth=1,LineColor=[1,0,0],GridVisible=TRUE):
plot(kegp,kegSDp,kegDp,kegHp,Scaling=Constrained)
Bestimmung des ursprünglichen Scheitelpunktes:
m:=P*(-t);float(m)
Bestimmung des Urbildes des eines Punktes der Parabelachse:
Mit ev1 rechts ist hier der normierte 1
. Eigenvektor gemeint.P
r:=-1: //auf der y-Achse
rs:=Pt*rur:
rur:=r*ev2n+m;
Nach der Rückwärtskonstruktion liegt Q=(4,-3) auf der Parabel.
q:=matrix([4,-3]); qs:=Pt*q; qss:=qs+t;
mp:=plot::Point2d(m, PointColor=[0,1,1]):
msp:=plot::Point2d(-t, PointColor=[0,1,1]):
rurp:=plot::Point2d(rur):
rsp:=plot::Point2d(rs):
rp:=plot::Point2d([0,r]):
qp:=plot::Point2d(q, PointColor=[1,0.5,0],PointSize=3, PointStyle=XCrosses):
qsp:=plot::Point2d(qs, PointColor=[1,0.5,0],PointSize=3, PointStyle=XCrosses):
qssp:=plot::Point2d(qss, PointColor=[1,0.5,0],PointSize=3, PointStyle=XCrosses):
ev1urp:=plot::Arrow2d(m,m+ev1):
ev2urp:=plot::Arrow2d(m,m+ev2):
tp:=plot::Arrow2d(-t,[0,0]):
plot(kegp,kegSDp,kegDp,kegHp, mp,msp,rurp,rsp,rp,tp,qsp,qssp,qp,
ev1urp,ev2urp,PointSize=2,Scaling=Constrained)
