keg:=matrix([[5*x^2 + 6*x*y + 5*y^2 -26*sqrt(2)*x -6*sqrt(2)*y + 74]])
Ellipse Klausur in allgemeiner Lage
Prof. Dr. Dörte Haftendorn: Mathematik mit MuPAD 4 Juli 07 Update 11.07.07
Web: https://mathe.web.leuphana.de www.mathematik-verstehen.de ######################################################
Ganzzahlige Eigenwerte, Staatsexamen, März 2001
-----------------------------------
keg:=matrix([[5*x^2 + 6*x*y + 5*y^2 -26*sqrt(2)*x -6*sqrt(2)*y + 74]])
kegp:=plot::Implicit2d(keg[1]=0,x=0..8,y=-4..1,
GridVisible=TRUE, LineWidth=1):
plot(kegp,Scaling=Constrained):
Dieser Kegelschnitt ist offenbar eine Ellipse.
Durchführung einer Hauptachsentransformation
A:= matrix([[5,3],[3,5]]);
a:=matrix([-26*sqrt(2),-6*sqrt(2)]): at:=linalg::transpose(a);
d:=74;
Bestimmung der Achsenrichtungen:
evli:=linalg::eigenvectors(A)
Eigenwerte mit ihrer Vielfachheit und ihrem Eigenvektor.
ev1:=-evli[1][3][1]; // negativ genommen,Rechtssystem!
ev2:=evli[2][3][1];
ew1:=evli[1][1];
ew2:=evli[2][1];
linalg::det(ev1.ev2)
Wenn diese Determinate negativ ist, tauft man besser die Eigenwerte und
Eigenvektoren um. Oder man dreht einen herum, haupsache es wird ein Rechtssystem.
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 es zwei quadratisches Glieder mit positivem Vorzeichen gibt.
Damit muss es sich um eine Ellipse handeln, wenn es nicht ein entarteter Sonderfall wird.
Da wir oben schon gezeichnet haben, war ja schon klar, dass es eine Ellipse ist.
Soll die gegebene blaue Ellipse 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=-3..7,y=-4..3,
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 positive
Drehung um den Ursprung handelt.
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=-1..7,y=-2..2,
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(2*(x-5)^2);expand(xterm);
yterm:=hold(8*(y-2)^2);expand(yterm);
dd:=-50-32+d
Also
kegSDK:=xterm+yterm+dd
expand(kegSDK) //Probe
passt.
Letzter Teil der Hauptachsentransformation ist die Translation t
t:=matrix([ -5,-2])
also
Das ergibt:
kegH:=ew1*x^2+ew2*y^2+dd
Angabe der Gleichung in der üblichen Form:
hold(x^2/4+y^2=1)
kegHp:=plot::Implicit2d(kegH,x=-3..4,y=-2..3, 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:=2: //auf der x-Achse
rur:=r*ev1n+m;
mp:=plot::Point2d(m, PointColor=[0,1,1]):
msp:=plot::Point2d(-t, PointColor=[0,1,1]):
rurp:=plot::Point2d(rur):
rp:=plot::Point2d([r,0]):
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,rp,tp,
ev1urp,ev2urp,PointSize=2,Scaling=Constrained)
