Lineære transformationer

import matplotlib
if not hasattr(matplotlib.RcParams, "_get"):
    matplotlib.RcParams._get = dict.get

Lineære transformationer#

Opsætning#

Vi importerer de nødvendige python-pakker.

import numpy as np
import matplotlib.pyplot as plt

Indledning#

Fra jeres sædvanlige matematikundervisning kender I funktioner:

\[ f(x)=x^{2}, \qquad x\in\mathbb{R}, \qquad (f:\mathbb{R}\to \mathbb{R}). \]

Det betyder at til en værdi \(x\in\mathbb{R}\) finder vi en \(y\)-værdi \(f(x)\). Hvis \(x=3\), så er \(f(3)=9\).

Værdimængden for funktionen er

\[ \mathrm{Vm}(f)=[0,\infty[ . \]

hvilket betyder, at ikke alle \(y\)-værdier kan rammes af en \(x\)-værdi.

Overvej hvorfor?

Har \(f\) en invers funktion?

Vi vil nu definere en særlig type funktioner, som tager vektorer, og hvor værdien også er vektorer. F.eks.

\[f:\mathbb{R}^{2}\to\mathbb{R}^{2}.\]

Inden vi definerer disse nye funktioner, skal vi indføre et nyt begreb kaldet matricer.

Matricer#

Eksempler#

En reel \(2\times 2\) matrix er et skema med tal:

\[\begin{split} M_1 = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \qquad \text{er en $2\times 2$ matrix.} \end{split}\]

Et andet eksempel:

\[\begin{split} M_{2}=\begin{bmatrix}1 & 2 & 3 \\ 4 & 5 & 6\end{bmatrix}\qquad\text{er en }2\times 3\text{ matrix.} \end{split}\]

Vi taler om søjler og rækker i matricer.

\(M_{2}\) har 2 rækker:

\[ \begin{bmatrix} 1 & 2 & 3 \end{bmatrix} \quad \text{er række 1,} \qquad \begin{bmatrix} 4 & 5 & 6 \end{bmatrix} \quad \text{er række 2.} \]

\(M_{2}\) har 3 søjler:

\[\begin{split} \begin{bmatrix} 1 \\ 4 \end{bmatrix} \quad \text{er søjle 1,} \qquad \begin{bmatrix} 2 \\ 5 \end{bmatrix} \quad \text{er søjle 2,} \qquad \begin{bmatrix} 3 \\ 6 \end{bmatrix} \quad \text{er søjle 3.} \end{split}\]

Matrix-vektor produkt#

Vi indfører nu et matrix-vektor produkt.

\[\begin{split} M = \begin{bmatrix} \text{---} & \boldsymbol{r}_1 & \text{---} \\ \text{---} & \boldsymbol{r}_2 & \text{---} \\ &\vdots \\ \text{---} & \boldsymbol{r}_m & \text{---} \end{bmatrix}_{m \text{ rækker}, \; n \text{ søjler}} \qquad \boldsymbol{v} = \begin{bmatrix} v_{1} \\ v_{2} \\ \vdots \\ v_{n} \end{bmatrix}_{n \text{ rækker}, \; 1 \text{ søjle}}. \end{split}\]

Her er \(\;\boldsymbol{r}_1,\dots,\boldsymbol{r}_m\;\) de \(m\) rækker i \(M\).

\[\begin{split} M\boldsymbol{v} = \begin{bmatrix} \boldsymbol{r}_1 \cdot \boldsymbol{v} \\ \boldsymbol{r}_2 \cdot \boldsymbol{v} \\ \vdots \\ \boldsymbol{r}_m \cdot \boldsymbol{v} \end{bmatrix}. \end{split}\]

hvor hver række består af det sædvanlige skalarprodukt mellem den tilsvarende række i \(M\) og vektoren \(\boldsymbol{v}\).

Bemærk: Antallet af søjler i \(M\) skal matche antallet af rækker i \(\boldsymbol{v}\).

Betragt for eksempel matricen og vektoren

\[\begin{split} M=\begin{bmatrix}1 & 2 \\ 3 & 4\end{bmatrix}, \qquad \boldsymbol{v}=\begin{bmatrix}-1 \\ 1\end{bmatrix}. \end{split}\]

Vi kan beregne produktet som

\[\begin{split} M \boldsymbol{v} = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \begin{bmatrix} -1 \\ 1 \end{bmatrix} = \begin{bmatrix} 1\cdot(-1)+2\cdot 1 \\ 3\cdot(-1)+4\cdot 1 \end{bmatrix} = \begin{bmatrix} 1 \\ 1 \end{bmatrix}. \end{split}\]

I python beregnes det som følgende.

M = np.array([[1,2],[3,4]])
v = np.array([-1,1])
print(M @ v)

Lad os prøve. Betragt de fire følgende matrix-vektorpar:

\[\begin{split} M_{1} = \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix}, \quad \boldsymbol{v}_{1} = \begin{bmatrix} 2 \\ 3 \end{bmatrix}. \end{split}\]
\[\begin{split} M_{2} = \begin{bmatrix} 1 & 0 & 2 \\ 0 & -2 & 3 \end{bmatrix}, \quad \boldsymbol{v}_{2} = \begin{bmatrix} 2 \\ 3 \end{bmatrix}. \end{split}\]
\[\begin{split} M_{3} = \begin{bmatrix} 1 & 0 & 2 \\ 0 & -2 & 3 \end{bmatrix}, \quad \boldsymbol{v}_{3} = \begin{bmatrix} -1 \\ -2 \\ 3 \end{bmatrix}. \end{split}\]
\[\begin{split} M_{4} = \begin{bmatrix} 1 & 2 \\ 3 & 0 \\ -1 & 4 \end{bmatrix}, \quad \boldsymbol{v}_{4} = \begin{bmatrix} 2 \\ 3 \end{bmatrix}. \end{split}\]

Prøv at udføre hver matrix-vektorprodukt i hånden, og afgør hvilken af de 4 der ikke kan udføres.

Brug den følgende kodecelle til at se om du får det samme resultat i Python.

# Beregn matrix-vektorprodukterne her

Kan du lave en regel for antallet af rækker og søjler i produktet \(M\boldsymbol{v}\) ud fra kendskab til antallet af søjler og rækker i \(M\) og \(v\) hver især?

Tilbage til funktioner#

Vi vender nu tilbage til funktionerne. Lad \(A\) være en \(2\times 2\) matrix.

Lineær afbildning#

Et eksempel på en lineær afbilding er

\[ f : \mathbb{R}^2 \to \mathbb{R}^2, \qquad f(\boldsymbol{v}) = A \boldsymbol{v}. \]

Vi kan se, at det altid går godt: Enhver vektor \(\boldsymbol{v}\in\mathbb{R}^2\) kan ganges på en \(2\times 2\) matrix.

Spørgsmålet er nu: Hvilke værdier kan funktionen antage?
(De ligger selvfølgelig i \(\mathbb{R}^2\).)

Vi ved allerede, at vektoren

\[\begin{split} \begin{bmatrix} 0 \\ 0 \end{bmatrix} \end{split}\]

altid ligger i værdimængden (som kaldes billedrummet).

Hvorfor?

Bemærk, at vi kan skrive

\[\begin{split} f(\mathbf{v}) = \begin{bmatrix} | & | \\ s_1 & s_2 \\ | & | \end{bmatrix} \begin{bmatrix} v_{1} \\ v_{2} \end{bmatrix} = \begin{bmatrix} | \\ s_{1} \\ | \end{bmatrix} v_{1} + \begin{bmatrix} | \\ s_{2} \\ | \end{bmatrix} v_{2}, \end{split}\]

hvor \(s_1\) og \(s_2\) er søjlerne i \(A\).

Kan du forklare, hvorfor det gælder?

Dette giver anledning til figuren, der dannes i følgende kodecelle.

# --- input (experimentér med talværdierne her) ---
s1 = np.array([1, 3])   # første søjle
s2 = np.array([2, 0.5])   # anden søjle
v1, v2 = 2, 3           # elementer i vektoren
# ------------------------------------------

f_v = v1*s1 + v2*s2

fig, ax = plt.subplots()

# tegner søjleprodukterne
ax.quiver(0, 0, *v1*s1, angles='xy', scale_units='xy', scale=1, color="blue")
ax.text(*v1*s1/2, r'$v_1\mathbf{s}_1$', fontsize=12, color="k", ha='left', va='top')
ax.plot([v1*s1[0], f_v[0]], [v1*s1[1], f_v[1]], 'b--', linewidth=1)
ax.quiver(0, 0, *v2*s2, angles='xy', scale_units='xy', scale=1, color="blue")
ax.text(*v2*s2/2, r'$v_2\mathbf{s}_2$', fontsize=12, color="k", ha='left', va='top')
ax.plot([v2*s2[0], f_v[0]], [v2*s2[1], f_v[1]], 'b--', linewidth=1)

# tegner søjlerne
ax.quiver(0, 0, *s1, angles='xy', scale_units='xy', scale=1, color="green")
ax.text(*s1/2, r'$\mathbf{s}_1$', fontsize=12, color="k", ha='right', va='bottom')
ax.quiver(0, 0, *s2, angles='xy', scale_units='xy', scale=1, color="green")
ax.text(*s2/2, r'$\mathbf{s}_2$', fontsize=12, color="k", ha='right', va='bottom')

# tegner f(v)
ax.quiver(0, 0, *f_v, angles='xy', scale_units='xy', scale=1, color="r")
ax.text(*f_v/2, r'$f(\mathbf{v})$', fontsize=12, color="k", ha='right', va='bottom')

# plot udseende
ax.axhline(0, color="black", linewidth=1)
ax.axvline(0, color="black", linewidth=1)
ax.set_aspect("equal")
ax.set_xlim(min(v1*s1[0], v2*s2[0], f_v[0], 0) - 1, max(v1*s1[0], v2*s2[0], f_v[0], 0) + 1)
ax.set_ylim(min(v1*s1[1], v2*s2[1], f_v[1], 0) - 1, max(v1*s1[1], v2*s2[1], f_v[1], 0) + 1)
ax.grid(True, which='both', linestyle='--', linewidth=0.5)
ax.set_xlabel("$x$")
ax.set_ylabel("$y$")

plt.show()

Forklar ud fra figuren hvorfor værdimængden enten er punktet \((0,0)\), en ret linje gennem origo, eller hele \(\mathbb{R}^2\).
Vink: Hvad sker der, hvis de to søjler er parallelle? Tjek evt. ved at ændre talværdierne for figuren.

Opgave#

Lad

\[\begin{split} A = \begin{bmatrix}0 & 0 \\ 0 & 0\end{bmatrix}, \quad B = \begin{bmatrix}1 & 1 \\ -1 & 1\end{bmatrix}, \quad C = \begin{bmatrix}1 & -2 \\ -1 & 2\end{bmatrix} \end{split}\]

og

\[\begin{split} \boldsymbol{v}_{1} = \begin{bmatrix}1 \\ 1\end{bmatrix}, \quad \boldsymbol{v}_{2} = \begin{bmatrix}-1 \\ 1\end{bmatrix}. \end{split}\]

Definér funktionerne \(f_A(\boldsymbol{v})=A\boldsymbol{v}\), \(f_B(\boldsymbol{v})=B\boldsymbol{v}\), \(f_C(\boldsymbol{v})=C \boldsymbol{v}\).

Opstil i følgende kodecelle matricerne \(A,\;B\) og \(C\) samt vektorerne \(\boldsymbol{v}_1\) og \(\boldsymbol{v}_2\).

#

Bestem \(f_{A}(v_{1})\), \(f_{A}(v_{2})\), \(f_{B}(v_{1})\), \(f_{B}(v_{2})\), \(f_{C}(v_{1})\) og \(f_{C}(v_{2})\) og inspicér resultaterne vha. print.

print(s1)

Lad os prøve at visualisere det. I den følgende kodecelle defineres funktionen draw_vectors, som vi kan bruge til at vise vektorer i et koordinatsystem.

def draw_vectors(vector_list):
    # input: liste af 2D-vektorer som numpy arrays

    fig, ax = plt.subplots()
    
    # tegner vektorerne
    for v in vector_list:
        ax.quiver(0, 0, *v, angles='xy', scale_units='xy', scale=1, color="blue")
        #ax.text(*(v/2), f"({v[0]}, {v[1]})",fontsize=10, color="k", ha='right', va='bottom')
    
    # sætter plottets størrelse
    all_x = [v[0] for v in vector_list] + [0]
    all_y = [v[1] for v in vector_list] + [0]
    ax.set_xlim(min(all_x) - 1, max(all_x) + 1)
    ax.set_ylim(min(all_y) - 1, max(all_y) + 1)

    # plot udseende
    ax.axhline(0, color="black", linewidth=1)
    ax.axvline(0, color="black", linewidth=1)
    ax.set_aspect("equal")
    ax.grid(True, which='both', linestyle='--', linewidth=0.5)
    ax.set_xlabel("$x$")
    ax.set_ylabel("$y$")

    plt.show()

Brug funktionen til at vise billedvektorerne i samme koordinatsystem.

vektor_liste = [np.array([1,0]), np.array([0,1])]
draw_vectors(vektor_liste)

Prøv at beskrive værdimængden af de tre funktioner. Overvej hvilke vektorer i \(\mathbb{R}^2\), der kan rammes af \(f_A\), \(f_B\) og \(f_C\) når \(\boldsymbol{v} \in \mathbb{R}^2\)?

Rang#

Vi vil introducere begrebet rang af en matrix.

Spørg din favorit-AI om begrebet rang.

I Python kan rangen af en matrix beregnes med funktionen np.linalg.matrix_rank(M).

Bestem \(\;\text{rang}(A),\;\text{rang}(B)\) og \(\text{rang}(C)\).

#

Bemærk: Det er kun for funktionen \(f_B\), at vi kan finde en invers funktion.

Hvorfor?

Rotationer#

Vi betragter nu en særlig klasse af funktioner:

\[\begin{split} f(\boldsymbol{v})=M\boldsymbol{v},\qquad M = \begin{bmatrix}\cos\theta & -\sin\theta \\ \sin\theta & \cos\theta\end{bmatrix}, \qquad -\pi \le \theta \le \pi. \end{split}\]

\(M\) drejer en vektor \(\boldsymbol{v}\), \(\theta\) radianer i positiv omløbsretning. I den følgende kodecelle drejer vi vektoren \(\boldsymbol{e}_1=\begin{bmatrix} 1\\0\end{bmatrix}\) med \(\frac{\pi}{4}\) radianer (\(45^{\circ}\)).

e1 = np.array([1,0])
theta = np.pi/4
M = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])
draw_vectors([e1, M @ e1])

Opgave#

Ud af følgende 5 matricer svarer nogle til en drejning som ovenfor.

\[\begin{split} M_{1}=\begin{bmatrix}0 & -1 \\ 1 & 0\end{bmatrix}, \quad M_{2}=\begin{bmatrix}1 & 0 \\ 0 & 1\end{bmatrix}, \quad M_{3}=\begin{bmatrix}\tfrac{1}{\sqrt{2}} & -\tfrac{1}{\sqrt{2}} \\ \tfrac{1}{\sqrt{2}} & \tfrac{1}{\sqrt{2}}\end{bmatrix}, \end{split}\]
\[\begin{split} M_{4}=\begin{bmatrix}1 & -1 \\ 1 & 1\end{bmatrix}, \quad M_{5}=\begin{bmatrix}\tfrac{1}{2} & \tfrac{\sqrt{3}}{2} \\ -\tfrac{\sqrt{3}}{2} & \tfrac{1}{2}\end{bmatrix}. \end{split}\]

Hvilke gør det, og hvilken vinkel svarer de til?

Prøv for hver af matricerne at indtegne en vektor \(\boldsymbol{v}\) og billedvektoren \(f(\boldsymbol{v})\) i samme koordinatsystem (brug gerne draw_vectors som ovenfor).
Ser vinklen ud til at passe?

#

Vi kan med fordel definere en Python-funktion, der returnerer en rotationsmatrix for en given vinkel \(\theta\).

Færdiggør funktionen rotation_matrix i følgende kodecelle.

def rotation_matrix(theta):
    """
    Returnerer en 2D rotationsmatrix for en rotation med vinklen theta (i radianer).
    """
    # EGEN KODE: Definer rotationsmatricen M
    M =

    return M

Med denne funktion kan vi nu definere en rotationsmatrix \(M\) som M=rotation_matrix(theta).

Afprøv din funktion ved at genskabe en af de fem matricer ovenfor ved hjælp af den vinkel, du har fundet. Vink: I Python fås \(\pi\) ved np.pi.

#

Forklaring: hvorfor svarer \(f\) til en drejning (kan evt. overspringes)#

En vektor \(v\) kan opfattes som en længde og en retning, vi kan skrive

\[\begin{split} \boldsymbol{v} = |\boldsymbol{v}|\begin{bmatrix} \cos\alpha \\ \sin\alpha \end{bmatrix}, \end{split}\]

hvor \(\alpha\) svarer til vinklen mellem vektoren og \(x\)-aksen (den positive retning).

Prøv nu at udføre matrix-vektorproduktet:

\[\begin{split} M \boldsymbol{v} = |\boldsymbol{v}|\begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix} \begin{bmatrix} \cos\alpha \\ \sin\alpha \end{bmatrix}. \end{split}\]

Prøv at spørg din favorit-AI hvad additionsformlerne er for noget,
og se om du ved hjælp af disse kan besvare spørgsmålet:
Hvorfor svarer \(f\) til en drejning på \(\theta\) radianer i positiv omløbsretning?

Hvordan kan det være, at \(|\boldsymbol{v}|\) kunne flyttes uden for selve matrixproduktet?

Matrix-matrix produkt#

Vi definerer i lighed med matrix-vektor produktet et matrix-matrix produkt.

Lad

\[\begin{split} M= \left[ \begin{array}{cccc} m_{11} & m_{12} & \cdots & m_{1n}\\ m_{21} & m_{22} & \cdots & m_{2n}\\ \vdots & \vdots & \ddots & \vdots\\ m_{m1} & m_{m2} & \cdots & m_{mn} \end{array} \right] \qquad \begin{array}{l} \text{$n$ søjler}\\ \text{$m$ rækker} \end{array} \end{split}\]

og

\[\begin{split} N= \left[ \begin{array}{cccc} n_{11} & n_{12} & \cdots & n_{1k}\\ \vdots & \vdots & \ddots & \vdots\\ n_{n1} & n_{n2} & \cdots & n_{nk} \end{array} \right] \qquad \begin{array}{l} \text{$k$ søjler}\\ \text{$n$ rækker} \end{array} \end{split}\]

Da er

\[\begin{split} M\,N = \left[ \begin{array}{cccc} \alpha_{11} & \alpha_{12} & \cdots & \alpha_{1k}\\ \alpha_{21} & \alpha_{22} & \cdots & \alpha_{2k}\\ \vdots & \vdots & \ddots & \vdots\\ \alpha_{m1} & \alpha_{m2} & \cdots & \alpha_{mk} \end{array} \right], \end{split}\]

hvor \(\alpha_{ij}\) er lig skalarprodukt mellem række \(i\) i \(M\) og søjle \(j\) i \(N\).

Får vi med matrix–matrixproduktet det samme som matrix–vektorproduktet i det særlige tilfælde, hvor \(N\) kun har én søjle (\(k=1\))?

Eksempel#

Betragt matrix-matrixproduktet

\[\begin{split} \begin{bmatrix} 1 & 2\\ 3 & 4 \end{bmatrix} \begin{bmatrix} 1 & 0 & 2\\ -1 & 3 & 1 \end{bmatrix} = \begin{bmatrix} -1 & 6 & 4\\ -1 & 12 & 10 \end{bmatrix}. \end{split}\]

Kan du få de samme værdier i produktmatricen som i eksemplet?

I Python udføres matrix-matrixproduktet i samme stil som matrix-vektorproduktet ved at bruge @.

Verificer det ovenstående resultat i følgende kodecelle.

#

Tilbage til rotationer#

Opgave#

Brug den nedenstående kodecelle til at besvare opgaven. Angiv en \(2\times2\) matrix \(M_{1}\) der roterer en vektor i positiv omløbsretning med \(\tfrac{\pi}{4}\) radianer,
og en anden \(M_{2}\) der roterer en vektor i negativ omløbsretning med \(\tfrac{\pi}{2}\) radianer:

Vælg nu en vektor \(v\in\mathbb{R}^{2}\).

  1. Roter først vektoren ved hjælp af \(M_1\):

\[ \boldsymbol{v}_1 = M_1 \boldsymbol{v}. \]

  1. Roter derefter \(v_1\) ved hjælp af \(M_2\):

\[ \boldsymbol{v}_2 = M_2 \boldsymbol{v}_1. \]

  1. (Sammenlign) Beregn også

\[ \boldsymbol{v}_2' = (M_2 M_1) \boldsymbol{v} \]

og sammenlign \(\boldsymbol{v}_2'\) med \(\boldsymbol{v}_2\) (f.eks. i et plot eller ved brug af print).

  1. Prøv at formulere i ord, hvad du ser!

M1 = 
M2 = 
v =

Sammensætning af rotationer forklaring (kan evt. overspringes)#

Lad

\[\begin{split} M_{1}= \begin{bmatrix} \cos\theta_{1} & -\sin\theta_{1}\\ \sin\theta_{1} & \ \cos\theta_{1} \end{bmatrix} \qquad\text{og}\qquad M_{2}= \begin{bmatrix} \cos\theta_{2} & -\sin\theta_{2}\\ \sin\theta_{2} & \ \cos\theta_{2} \end{bmatrix}. \end{split}\]

være to rotationsmatricer.

Udregn \(M_{1}M_{2}\) i hånden.

Brug nu additionsformlerne fra tidligere til at vise, at \(M_{1}M_{2}\) har samme virkning som en rotation med vinklen \(\theta_{1}+\theta_{2}\) på en vilkårlig vektor i \(\mathbb{R}^{2}\).

Eksempel: Refleksion#

Betragt matricen

\[\begin{split} M = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} \end{split}\]

og lad \(f\) være funktionen \(f(\boldsymbol{v}) = M \boldsymbol{v}\).

Prøv med forskellige vektorer \(\boldsymbol{v}\) at finde billedvektoren \(f(\boldsymbol{v})\).
Hvilken virkning har matricen \(M\) på en vektor?

Bemærk at virkningen af \(M\) ikke svarer til en rotation i positiv omløbsretning som beskrevet ovenfor, det vil sige \(M\) kan ikke bringes på formen

\[\begin{split} \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}. \end{split}\]

Hvorfor ikke?

Virkningen af \(M\) på vektoren \(\boldsymbol{v}\) kaldes en refleksion, (i dette tilfælde en refleksion i linjen udspændt af vektoren \(\boldsymbol{w} = (1,1)\) ).

Invers matrix#

Vi betragter igen en rotation, givet ved

\[\begin{split} M = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix}. \end{split}\]

\(M\) roterer altså \(\boldsymbol{v}\), \(\theta\) radianer i positiv omløbsretning.

Betragt nu den rotationsmatrix der roterer en vektor \(\boldsymbol{v}\), \(\theta\) radianer i negativ omløbsretning:

\[\begin{split} M^{-1} = \begin{bmatrix} \cos(-\theta) & -\sin(-\theta) \\ \sin(-\theta) & \cos(-\theta) \end{bmatrix} = \begin{bmatrix} \cos\theta & \sin\theta \\ -\sin\theta & \cos\theta \end{bmatrix}. \end{split}\]

Forklar hvorfor de to ovennævnte matricer netop ser ud som de gør.

Det er klart ud fra definitionen på \(M\) og \(M^{-1}\), at

\[ M^{-1}(M\boldsymbol{v}) = M(M^{-1}\boldsymbol{v}) = \boldsymbol{v}. \]

Prøv med forskellige forskellige vinkler og vektorer at eftervise ovenstående identiteter.

Prøv nu med de samme vinkler at udregne matrix-matrixprodukterne \(M^{-1}M\) og \(MM^{-1}\).
Hvad ser du?

Vi kalder

\[\begin{split} \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \end{split}\]

identitetsmatricen \(I\).

Hvilken virkning har den på en vektor?

Vi siger at en matrix \(M\) med lige antal søjler og rækker har en invers matrix hvis der findes en matrix \(M^{-1}\) med egenskaben

\[ M^{-1}M = MM^{-1} = I. \]

Diagonal matrix#

En matrix på formen

\[\begin{split} D = \begin{bmatrix} m_{11} & 0 & 0 & \cdots & 0 \\ 0 & m_{22} & 0 & \cdots & 0 \\ 0 & 0 & \ddots & \ddots & 0 \\ \vdots & \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & 0 & \cdots & m_{nn} \end{bmatrix}, \end{split}\]

hvor kun diagonalelementerne er forskellige fra nul (bemærk at vi kalder diagonalen den linje, der går fra øverste venstre hjørne til nederste højre hjørne i matricen).

Identitetsmatricen er en diagonal­matrix – hvorfor?

Betragt de fire følgende eksempler på \(2\times 2\) diagonalmatricer:

\[\begin{split} D_{1} = \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix}, \quad D_{2} = \begin{bmatrix} 2 & 0 \\ 0 & 3 \end{bmatrix}, \quad D_{3} = \begin{bmatrix} \frac{1}{2} & 0 \\ 0 & \frac{1}{3} \end{bmatrix}, \quad D_{4} = \begin{bmatrix} 0 & 0 \\ 0 & 2 \end{bmatrix}. \end{split}\]

Prøv at finde den inverse matrix (hvis muligt) til de fire diagonalmatricer.

Matricen

\[\begin{split} V = \begin{bmatrix} 0 & -1 \\ \frac{1}{2} & 0 \end{bmatrix} \end{split}\]

er ikke en diagonalmatrix.

Hvorfor ikke?

Kan du finde en invers til \(V\)?

For at se virkningen af en diagonal­matrix på en vektor \(\boldsymbol{v}\) betragter vi nu igen funktionen

\[ f(\boldsymbol{v}) = N_i \boldsymbol{v}, \]

hvor

\[\begin{split} N_{1} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}, \quad N_{2} = \begin{bmatrix} 2 & 0 \\ 0 & 2 \end{bmatrix}, \quad N_{3} = \begin{bmatrix} 1 & 0 \\ 0 & 2 \end{bmatrix}, \quad N_{4} = \begin{bmatrix} 0 & 1 \\ -1 & 0 \end{bmatrix}. \end{split}\]

Beregn \(f(\boldsymbol{v})\) i disse 4 tilfælde, brug forskellige \(\boldsymbol{v}\)’er.

#

Kan du forklare virkningen på en vektor \(\boldsymbol{v}\) i de 4 tilfælde?

Sammensætning af rotationer og diagonalmatricer#

Vi betragter igen de 4 matricer ovenfor.
Lad \(M\) være matricen

\[\begin{split} M = \begin{bmatrix} \cos\left(\tfrac{\pi}{4}\right) & -\sin\left(\tfrac{\pi}{4}\right) \\ \sin\left(\tfrac{\pi}{4}\right) & \cos\left(\tfrac{\pi}{4}\right) \end{bmatrix}. \end{split}\]

Udregn nu \(M^{-1}N_iM\) og forklar resultatet ved hjælp af et plot.

#

Gælder der samme regler som for tal, at faktorernes orden er ligegyldig, altså er det korrekt at:

\[ M^{-1}N_iM = N_iM^{-1}M = N_i I = N_i \, ? \]

Hvis ikke det gælder generelt, er det så altid forkert?

Drejning af koordinatsystem og skift af koordinater#

Vi betragter nu to koordinatsystemer, vores sædvanlige \(x\)-\(y\) koordinatsystem og så et nyt drejet \(x'\)-\(y'\) koordinatsystem. Figuren genereres ved at køre følgende kodecelle.

# Rotationsvinkel
theta = np.pi / 6 

# Akse definitioner
x_axis = np.array([1, 0])
y_axis = np.array([0, 1])
x_prime = np.array([np.cos(theta), np.sin(theta)])
y_prime = np.array([-np.sin(theta), np.cos(theta)])

# Vektoren v
v = np.array([np.cos(np.pi/4), np.sin(np.pi/4)])

fig, ax = plt.subplots(figsize=(5, 5))

# Plotter akserne
axes_width = 0.004
ax.quiver(0, 0, *x_axis, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(1.05, -0.05, "$x$", fontsize=12)

ax.quiver(0, 0, *y_axis, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(-0.05, 1.05, "$y$", fontsize=12)

ax.quiver(0, 0, *x_prime, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(x_prime[0]+0.05, x_prime[1], "$x'$", fontsize=12)

ax.quiver(0, 0, *y_prime, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(y_prime[0]-0.1, y_prime[1], "$y'$", fontsize=12)

# Plot vektoren v
ax.quiver(0, 0, *v, angles="xy", scale_units="xy", scale=1, color="black", width=0.006)
ax.text(v[0]+0.05, v[1]+0.05, r"vektoren $\mathbf{v}$", fontsize=12)

# Vinkelbue for theta
arc = np.linspace(0, theta, 100)
ax.plot(0.4*np.cos(arc), 0.4*np.sin(arc), color="black",linewidth=1)
ax.text(0.5*np.cos(theta/2), 0.5*np.sin(theta/2), r"$\theta$", fontsize=12)

# Plot udseende
ax.set_aspect('equal')
ax.set_xlim(-1, 1.5)
ax.set_ylim(-0.5, 1.5)
ax.axis("off")

plt.show()

Opgaven er nu, hvis vi kender koordinaterne for \(\boldsymbol{v}\) i det sædvanlige koordinatsystem, at finde koordinaterne i det drejede koordinatsystem og omvendt.

Først et let eksempel: Lad os dreje \(x'\)-\(y'\)-koordinatsystemet \(\tfrac{\pi}{2}\) radianer i forhold til \(x\)-\(y\)-koordinatsystemet.

# Rotationsvinkel
theta = np.pi / 2

# Akse definitioner
x_axis = np.array([2, 0])
y_axis = np.array([0, 2])
x_prime = 2*np.array([np.cos(theta), np.sin(theta)])
y_prime = 2*np.array([-np.sin(theta), np.cos(theta)])

# Vektoren v
v = np.sqrt(2)*np.array([np.cos(np.pi/4), np.sin(np.pi/4)])

fig, ax = plt.subplots(figsize=(5, 5))

# Plotter akserne
axes_width = 0.004
ax.quiver(0, 0, *x_axis, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(x_axis[0]+0.05, x_axis[1], "$x$", fontsize=12)

ax.quiver(0, 0, *y_axis, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(y_axis[0]-0.1, y_axis[1], "$y$", fontsize=12)

ax.quiver(0, 0, *x_prime, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(x_prime[0]+0.05, x_prime[1], "$x'$", fontsize=12)

ax.quiver(0, 0, *y_prime, angles="xy", scale_units="xy", scale=1, color="black", width=axes_width)
ax.text(y_prime[0]-0.1, y_prime[1], "$y'$", fontsize=12)

# Plot vektoren v og projektioner på x- og y-aksen
ax.quiver(0, 0, *v, angles="xy", scale_units="xy", scale=1, color="black", width=0.006)
ax.text(v[0]+0.05, v[1]+0.05, r"$\mathbf{v}$", fontsize=12)
ax.plot([v[0], v[0]], [-0.05, v[1]], 'k--', linewidth=0.5)  # vertical from x-axis to tip
ax.plot([-0.05, v[0]], [v[1], v[1]], 'k--', linewidth=0.5)  # horizontal from y-axis to tip
ax.text(v[0], -0.1, "1", fontsize=10, ha='center', va='top')
ax.text(-0.1, v[1], "1", fontsize=10, ha='right', va='center')

# Plot udseende
ax.axis('off')
ax.set_aspect('equal')
ax.set_xlim(-2.5, 2.5)
ax.set_ylim(-1, 3)

plt.show()

Koordinaterne for \(\boldsymbol{v}\) med hensyn til \(x\)-\(y\)-koordinatsystemet er

\[ (1,1). \]

Koordinaterne for \(\boldsymbol{v}\) med hensyn til \(x'\)-\(y'\)-koordinatsystemet er

\[ (1,-1). \]

Forklar hvorfor, brug figuren.

Nu vender vi tilbage til det oprindelige problem.

Lad os sige, at koordinaterne for \(\boldsymbol{v}\) med hensyn til \(x'\)-\(y'\)-koordinatsystemet er

\[ (v_1',v_2'), \]

Forestil jer nu, at de to koordinatsystemer er sammenfaldende til at starte med, og vi så begynder at dreje \(x'\)-\(y'\)-koordinatsystemet \(\theta\) radianer i positiv omløbsretning med vektoren \(\boldsymbol{v}\) fastholdt til \(x'\)-\(y'\)-koordinatsystemet.

Dette svarer til at dreje vektoren \(\boldsymbol{v}\) \(\theta\) radianer, så koordinaterne i \(x\)-\(y\)-koordinatsystemet er

\[\begin{split} \begin{pmatrix} x \\[0.3em] y \end{pmatrix} = \begin{bmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{bmatrix} \begin{pmatrix} x' \\[0.3em] y' \end{pmatrix}. \end{split}\]

Drejningen den modsatte vej er givet ved

\[\begin{split} \begin{pmatrix} x'\\[0.2em] y' \end{pmatrix} = \begin{bmatrix} \cos\theta & \sin\theta\\ -\sin\theta & \cos\theta \end{bmatrix} \begin{pmatrix} x\\[0.2em] y \end{pmatrix}. \end{split}\]

Forklar hvorfor!

Vi kalder de to indgående matricer for koordinatskiftematricer.

Opgave

Vælg nu en drejningsvinkel på \(\tfrac{\pi}{4}\) radianer.

  1. Betragt en vektor \(\boldsymbol{v}\) med koordinater

\[\begin{split} \begin{pmatrix} x \\ y \end{pmatrix} = \begin{pmatrix} 1 \\ 2 \end{pmatrix}. \end{split}\]

Find \(x'\)-\(y'\)-koordinaterne.

#

  1. Betragt en vektor \(\boldsymbol{w}'\) med koordinater

\[\begin{split} \begin{pmatrix} x' \\ y' \end{pmatrix} = \begin{pmatrix} \sqrt{2} \\ \sqrt{2} \end{pmatrix}. \end{split}\]

Find \(x\)-\(y\)-koordinaterne.

#

  1. Lad os prøve at visualisere denne drejning. I følgende kodecelle genereres to koordinatsystemer i hhv. \((x,y)\)- og \((x',y')\)-koordinater. I hvert koordinatsystem er også plottet et eksempel på en vektor med kodelinjen:

ax.quiver(0, 0, *np.array([1,1/2]), angles="xy", scale_units="xy", scale=1, color="red", width=0.006)

Foretag ændringer i plottet, så vi får følgende:

  • I (\(x,y\))-koordinatsystem vises vektorerne \(\boldsymbol{v}\) og \(\boldsymbol{w}\).

  • I (\(x',y'\))-koordinatsystem vises vektorerne \(\boldsymbol{v}'\) og \(\boldsymbol{w}'\).

  • \(\boldsymbol{v}\) og \(\boldsymbol{v}'\) er plottet med samme farve, mens \(\boldsymbol{w}\) og \(\boldsymbol{w}'\) har en anden fælles farve.

# Rotationsvinkel
theta = np.pi / 4

# Akse definitioner
x_prime = 2*np.array([np.cos(theta), np.sin(theta)])
y_prime = 2*np.array([-np.sin(theta), np.cos(theta)])

fig, axs = plt.subplots( 1, 2, figsize = (10,10)) # laver to plots side om side (1x2)

# fælles plot udseende
for ax in axs:
    ax.grid()
    ax.set_aspect('equal')
    ax.set_xlim(-1.75, 2.25)
    ax.set_ylim(-1, 2.5)
    ax.axhline(0, color="black", linewidth=1)
    ax.axvline(0, color="black", linewidth=1)

# venstre subplot (x-y koordinatsystem) ----------------------------
ax = axs[0]

# sætter akse-labels og titel
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_title('($x$, $y$) koordinatsystem')

# plotter x'-y'-askerne
ax.quiver(0, 0, *x_prime, angles="xy", scale_units="xy", scale=1, color="black", width=0.004)
ax.text(x_prime[0]+0.05, x_prime[1], "$x'$", fontsize=12)
ax.quiver(0, 0, *y_prime, angles="xy", scale_units="xy", scale=1, color="black", width=0.004)
ax.text(y_prime[0]-0.1, y_prime[1], "$y'$", fontsize=12)

# EGEN KODE: plotter vektorerne v og w (x-y koordinater)
ax.quiver(0, 0, *np.array([1,1/2]), angles="xy", scale_units="xy", scale=1, color="red", width=0.006) # eksempel (fjern denne)

# højre subplot (x'-y' koordinatsystem) ----------------------------
ax = axs[1]

# sætter akse-labels og titel
ax.set_xlabel("$x'$")
ax.set_ylabel("$y'$")
ax.set_title("($x'$, $y'$) koordinatsystem")

# EGEN KODE: plotter vektorerne v' og w' (x'-y' koordinater)
ax.quiver(0, 0, *np.array([1,1/2]), angles="xy", scale_units="xy", scale=1, color="blue", width=0.006) # eksempel (fjern denne)

plt.show()
Contents