# Affine Abbildungen 2d

Mathematik in wxMaxima www.mathematik-verstehen.de Haftendorn Jan 2011

### Handling

Achtung: Durch Anklicken der linken Zellmarkierung kann man die 
Abschnitte und auch einzelne Zellen aufklappen und auch wieder zuklappen.

Endung *.wxmx ist komfortabel. Ist die Endung *.wxm muss man 
erst noch alle Ausgaben neu erzeugen. Mit Strg r  werden alle aufgeklappten Zellen ausgewertet.
Zum Lernen ist es besser die Zellen einzeln (mit Shift+Enter) auszuwerten.

Werte einzelne Zellen aus mit Shift-Enter. 
Auswertung in einem Rutsch: Falte alle Abschnitte auf,
werte alle Zellen mit Strg r aus ( auch Menu Cell Alle Zellen auswerten).

### Dieses ist das Einführungsbeispiel

### Inhalt

## Urbild

### Definition

Urbild

myUr:transpose(matrix([2,0],[2,1],[1,1],[1,3],[0,3],[0,0],[2,0],[1,1/2]));

### Zeichnen

load(draw)$

xmin:0$ xmax:7 $ ymin:0$ ymax:5$

urbild:gr2d(xrange = [xmin,xmax], yrange = [ymin,ymax],points_joined = true,color=green,
             line_width    = 7,  point_size    = 1, point_type    = up_triangle,
             grid=true,points(myUr)   )$

draw(urbild)$

## Abbildung 

### Abbildung der Einheitsvektoren

A:transpose(matrix([3/2,1/2],[1/2,3/4]));

startbild:gr2d(xrange = [xmin,xmax], yrange = [ymin,ymax],
             points_joined = true,color=green,
             line_width    = 7,  point_size    = 1, point_type    = up_triangle,
             grid=true,points(myUr) ,
             grid=true, line_width=2,point_size=1, head_length=0.2,
             color=blue,vector([0,0],[A[1,1],A[2,1]]), 
             color=black,vector([0,0],[A[1,2],A[2,2]]))$

draw(startbild)$

Der blaue    Vektor ist das Bild des x-Einheitsvektors.
Der schwarze Vektor ist das Bild des y-Einheitsvektors.

### Abbildungsgleichung für einen Punkt

Definition der Translation

tx:3$ ty:2$

tv:transpose(matrix([tx,ty]));

Allgemeine affine Abbildung

f(xv):=A.xv+tv;

f(xv);

Abbildung eines beliebigen Punktes

pv:transpose(matrix([px,py]));

f(pv);

Abbildung eines konkreten Punktes

pv:transpose(matrix([2,1]));

Nur affine Verzerrung

A.pv;

gesamt

f(pv);
%,numer;

### Affine Verzerrung für das ganze Urbild

myUr;
myABild:A.myUr;
%,numer;

ABild:gr2d(xrange = [xmin,xmax], yrange = [ymin,ymax],
             points_joined = true,color=green,
             line_width    = 7,  point_size    = 1, point_type    = up_triangle,
             grid=true,points(myUr) ,
             grid=true, line_width=2,point_size=1, head_length=0.2,
             color=blue,vector([0,0],[A[1,1],A[2,1]]), 
             color=black,vector([0,0],[A[1,2],A[2,2]]),
             line_width=7,point_size=1, color=red,
             points(myABild) 
)$  draw(ABild)$

### Ganze affine Abbildung für das Urbild

Nun muss zu jedem dieser Bildpunkte der Translationsvektor
addiert werden. Dazu muss man ihn passend "aufblähen" zu einer
Transformationsmatrix.

npk:length(transpose(myUr));

mtv(tv):=block ([m],
                 m:tv,for i:1 thru npk-1 do ( m:addcol(m,tv)),return( m))$

mtv(tv);

Gesamte Abbildung des Urbildes

fm(myUr):=A.myUr+mtv(tv);

myBild:fm(myUr);
%,numer;

Bild:gr2d(xrange = [xmin,xmax], yrange = [ymin,ymax],
             points_joined = true,color=green,
             line_width    = 7,  point_size    = 1, point_type    = up_triangle,
             grid=true,points(myUr) ,
             grid=true, line_width=2,point_size=1, head_length=0.2,
             color=blue,vector([0,0],[A[1,1],A[2,1]]), 
             color=black,vector([0,0],[A[1,2],A[2,2]]),
             line_width=2,point_size=1, color=pink,
             points(myABild) ,
              color=red,vector([0,0],[tv[1,1],tv[2,1]]),
             line_width=7,color=red,
             points(myBild) 
)$  draw(Bild)$

## Eigenwerte und Eigenvektoren

### Vorgefertigte Beschaffung

eigenvalues(A);

ev_all: eigenvectors(A);

Die Liste ist so zu deuten:
Erste Unterliste: die beiden Eigenwerte, dann ihre Vielfachheiten.
Zweite Unterliste: erster Eigenvektor, zweiter Eigenvektor

### Beschaffung von Hand

A;

E: matrix( [1,0],  [0,1]);

A-x*E;

determinant(A-x*E);

Auch dieses geht direkt

charpoly(A,x);

solve(charpoly(A,x)=0,x);

Hier sieht man die beiden Eigenwerte.

### Darstellung, geometrische Bedeutung

ew:ev_all[1][1]; ev1:ev_all[2][1][1];ev2:ev_all[2][2][1];

evBild:gr2d(xrange        = [-1,7], yrange        = [-2,5],
             points_joined = true,color=green, line_width=2,
             points(myUr),
             grid=true, line_width=2,point_size=1, head_length=0.1,
             line_type=dots,  color=orange,
             vector([0,0],[ev1[1],ev1[2]]), 
             color=red,vector([0,0],[ev2[1],ev2[2]]),head_length=0.2,
             color=orange,
             vector([0,0],ew[1]*[ev1[1],ev1[2]]), 
             color=red,vector([0,0],ew[2]*[ev2[1],ev2[2]]),
             line_width=2,point_size=1, color=red,
             points(myABild) 
             )$  draw(evBild)$

Die großen Pfeilspitzen bezeichnen die Bilder der
Eigenvektoren.

Bei dem Einführungsbeispiel sieht man, dass der eine Eigenwert
seinen Eigenvektor (orange) knapp verdoppelt *7/4, der andere
halbiert ihn (1/2).

## Wirkung einer Linearen Abbildung

### Urbild des Einheitskreises?

A;

S:A.A;

pt:matrix([x,y]); p:transpose(pt);ellipseS:facsum(pt.S.p=1);

draw(gr2d(line_width=3, color=red,grid=true,
             implicit(ellipseS, x, -1.5,1.5, y, -2,2),color=blue,
             implicit(x^2+y^2=1, x, -1.5,1.5, y, -2,2),

 grid=true, line_width=2,point_size=1, head_length=0.1,
             line_type=dots,  color=orange,
             vector([0,0],[ev1[1],ev1[2]]/sqrt(5/4)), 
             color=red,vector([0,0],[ev2[1],ev2[2]]/sqrt(5)),head_length=0.2,
             color=orange,
             vector([0,0],ew[1]^-1*[ev1[1],ev1[2]]/sqrt(5/4)), 
             color=red,vector([0,0],ew[2]^-1*[ev2[1],ev2[2]]/sqrt(5))

            ))$

charpoly(S,x);

evs:eigenvectors(S);

Dies passt zur Thoerie bei symmetrischem A: Eigenwerte quadriert,
dieselben Eigenvektoren

### Transformationsmatrix

evs[2][1][1];

Tt:matrix(evs[2][1][1]/sqrt(5/4),evs[2][2][1]/sqrt(5));T:transpose(Tt)$

facsum(T.S.Tt);

Diesen Schritt braucht man nicht wirklich zu machen, denn die Theorie
garantiert hier eine Diagonalmatrix mit den Eigenwerten in der 
Hauptdiagonalen.

elliS:(49/16*x^2+1/4*y^2=1);

### Bild des Einheitskreises

Auf welche Punkte wird der Einheitskreis abgebildet?

A^^-1;

Die Inverse einer symmetrischen Matrix ist symmetrisch

Q:A^^-2;

ellipseQ:facsum(pt.Q.p=1);

draw(gr2d(line_width=3, color=red,grid=true,
             implicit(ellipseQ, x, -2,2, y, -2,2),color=blue,
             implicit(x^2+y^2=1, x, -1.5,1.5, y, -2,2),

 grid=true, line_width=2,point_size=1, head_length=0.1,
             line_type=dots,  color=orange,
             vector([0,0],[ev1[1],ev1[2]]/sqrt(5/4)), 
             color=red,vector([0,0],[ev2[1],ev2[2]]/sqrt(5)),head_length=0.2,
             color=orange,
             vector([0,0],ew[1]*[ev1[1],ev1[2]]/sqrt(5/4)), 
             color=red,vector([0,0],ew[2]*[ev2[1],ev2[2]]/sqrt(5))

            ))$

charpoly(Q,x);

evs:eigenvectors(Q);

Dies passt zur Thoerie bei symmetrischem A: Kehrwerte der
Eigenwerte quadriert,dieselben Eigenvektoren