{
"cells": [
{
"cell_type": "markdown",
"id": "e64a5775",
"metadata": {},
"source": [
"# Lineære transformationer\n",
"\n",
"## Opsætning\n",
"Vi importerer de nødvendige python-pakker."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bc2aeed8",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"id": "9df09315",
"metadata": {},
"source": [
"\n",
"## Indledning\n",
"\n",
"Fra jeres sædvanlige matematikundervisning kender I funktioner:\n",
"\n",
"$$\n",
"f(x)=x^{2}, \\qquad x\\in\\mathbb{R}, \\qquad (f:\\mathbb{R}\\to \\mathbb{R}).\n",
"$$\n",
"\n",
"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$.\n",
"\n",
"Værdimængden for funktionen er\n",
"\n",
"$$\n",
"\\mathrm{Vm}(f)=[0,\\infty[ .\n",
"$$\n",
"\n",
"\n",
"\n",
"hvilket betyder, at ikke alle $y$-værdier kan rammes af en $x$-værdi.\n",
"\n",
">Overvej hvorfor?\n",
"\n",
">Har $f$ en invers funktion?\n",
"\n",
"Vi vil nu definere en særlig type funktioner, som tager vektorer, og hvor værdien også er vektorer. F.eks.\n",
"\n",
"$$f:\\mathbb{R}^{2}\\to\\mathbb{R}^{2}.$$\n",
"\n",
"Inden vi definerer disse nye funktioner, skal vi indføre et nyt begreb kaldet **matricer**.\n",
"\n",
"\n",
"\n",
"## Matricer\n",
"\n",
"### Eksempler\n",
"En reel $2\\times 2$ matrix er et skema med tal:\n",
"\n",
"$$\n",
"M_1 = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix} \\qquad \\text{er en $2\\times 2$ matrix.}\n",
"$$\n",
"\n",
"\n",
"Et andet eksempel:\n",
"\n",
"$$\n",
"M_{2}=\\begin{bmatrix}1 & 2 & 3 \\\\ 4 & 5 & 6\\end{bmatrix}\\qquad\\text{er en }2\\times 3\\text{ matrix.}\n",
"$$\n",
"\n",
"\n",
"Vi taler om *søjler* og *rækker* i matricer. \n",
"\n",
"$M_{2}$ har 2 rækker: \n",
"\n",
"$$\n",
"\\begin{bmatrix} 1 & 2 & 3 \\end{bmatrix} \\quad \\text{er række 1,} \\qquad\n",
"\\begin{bmatrix} 4 & 5 & 6 \\end{bmatrix} \\quad \\text{er række 2.}\n",
"$$\n",
"\n",
"$M_{2}$ har 3 søjler: \n",
"\n",
"$$\n",
"\\begin{bmatrix} 1 \\\\ 4 \\end{bmatrix} \\quad \\text{er søjle 1,} \\qquad\n",
"\\begin{bmatrix} 2 \\\\ 5 \\end{bmatrix} \\quad \\text{er søjle 2,} \\qquad\n",
"\\begin{bmatrix} 3 \\\\ 6 \\end{bmatrix} \\quad \\text{er søjle 3.}\n",
"$$\n",
" \n",
"\n",
"\n",
"### Matrix-vektor produkt\n",
"Vi indfører nu et matrix-vektor produkt. \n",
"\n",
"$$\n",
"M =\n",
"\\begin{bmatrix}\n",
"\\text{---} & \\boldsymbol{r}_1 & \\text{---} \\\\\n",
"\\text{---} & \\boldsymbol{r}_2 & \\text{---} \\\\\n",
"&\\vdots \\\\\n",
"\\text{---} & \\boldsymbol{r}_m & \\text{---}\n",
"\\end{bmatrix}_{m \\text{ rækker}, \\; n \\text{ søjler}}\n",
"\\qquad\n",
"\\boldsymbol{v} =\n",
"\\begin{bmatrix}\n",
"v_{1} \\\\\n",
"v_{2} \\\\\n",
"\\vdots \\\\\n",
"v_{n}\n",
"\\end{bmatrix}_{n \\text{ rækker}, \\; 1 \\text{ søjle}}.\n",
"$$\n",
"\n",
"Her er $\\;\\boldsymbol{r}_1,\\dots,\\boldsymbol{r}_m\\;$ de $m$ rækker i $M$.\n",
"\n",
"$$\n",
"M\\boldsymbol{v} =\n",
"\\begin{bmatrix}\n",
"\\boldsymbol{r}_1 \\cdot \\boldsymbol{v} \\\\\n",
"\\boldsymbol{r}_2 \\cdot \\boldsymbol{v} \\\\\n",
"\\vdots \\\\\n",
"\\boldsymbol{r}_m \\cdot \\boldsymbol{v}\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"\n",
"\n",
"hvor hver række består af det sædvanlige skalarprodukt mellem den tilsvarende række i $M$ og vektoren $\\boldsymbol{v}$.\n",
"\n",
"***Bemærk:*** Antallet af søjler i $M$ skal matche antallet af rækker i $\\boldsymbol{v}$.\n",
"\n",
"\n",
"\n",
"Betragt for eksempel matricen og vektoren\n",
"\n",
"$$\n",
"M=\\begin{bmatrix}1 & 2 \\\\ 3 & 4\\end{bmatrix}, \\qquad \\boldsymbol{v}=\\begin{bmatrix}-1 \\\\ 1\\end{bmatrix}.\n",
"$$\n",
"\n",
"Vi kan beregne produktet som\n",
"\n",
"$$\n",
"M \\boldsymbol{v} =\n",
"\\begin{bmatrix}\n",
"1 & 2 \\\\\n",
"3 & 4\n",
"\\end{bmatrix}\n",
"\\begin{bmatrix}\n",
"-1 \\\\\n",
"1\n",
"\\end{bmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"1\\cdot(-1)+2\\cdot 1 \\\\\n",
"3\\cdot(-1)+4\\cdot 1\n",
"\\end{bmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"1 \\\\\n",
"1\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"I python beregnes det som følgende."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eb77265a",
"metadata": {},
"outputs": [],
"source": [
"M = np.array([[1,2],[3,4]])\n",
"v = np.array([-1,1])\n",
"print(M @ v)"
]
},
{
"cell_type": "markdown",
"id": "200a6ee9",
"metadata": {},
"source": [
"Lad os prøve. Betragt de fire følgende matrix-vektorpar:\n",
"\n",
"$$\n",
"M_{1} =\n",
"\\begin{bmatrix}\n",
"-1 & 0 \\\\\n",
"0 & 1\n",
"\\end{bmatrix},\n",
"\\quad\n",
"\\boldsymbol{v}_{1} =\n",
"\\begin{bmatrix}\n",
"2 \\\\\n",
"3\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"$$\n",
"M_{2} =\n",
"\\begin{bmatrix}\n",
"1 & 0 & 2 \\\\\n",
"0 & -2 & 3\n",
"\\end{bmatrix},\n",
"\\quad\n",
"\\boldsymbol{v}_{2} =\n",
"\\begin{bmatrix}\n",
"2 \\\\\n",
"3\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"$$\n",
"M_{3} =\n",
"\\begin{bmatrix}\n",
"1 & 0 & 2 \\\\\n",
"0 & -2 & 3\n",
"\\end{bmatrix},\n",
"\\quad\n",
"\\boldsymbol{v}_{3} =\n",
"\\begin{bmatrix}\n",
"-1 \\\\\n",
"-2 \\\\\n",
"3\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"$$\n",
"M_{4} =\n",
"\\begin{bmatrix}\n",
"1 & 2 \\\\\n",
"3 & 0 \\\\\n",
"-1 & 4\n",
"\\end{bmatrix},\n",
"\\quad\n",
"\\boldsymbol{v}_{4} =\n",
"\\begin{bmatrix}\n",
"2 \\\\\n",
"3\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Prøv at udføre hver matrix-vektorprodukt i hånden, og afgør hvilken af de 4 der ikke kan udføres.\n",
"\n",
">Brug den følgende kodecelle til at se om du får det samme resultat i Python."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d99c5c0f",
"metadata": {},
"outputs": [],
"source": [
"# Beregn matrix-vektorprodukterne her"
]
},
{
"cell_type": "markdown",
"id": "3ceb0164",
"metadata": {},
"source": [
">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?\n",
"\n",
"\n",
"## Tilbage til funktioner\n",
"Vi vender nu tilbage til funktionerne.\n",
"Lad $A$ være en $2\\times 2$ matrix.\n",
"\n",
"### Lineær afbildning\n",
"Et eksempel på en lineær afbilding er\n",
"\n",
"$$\n",
"f : \\mathbb{R}^2 \\to \\mathbb{R}^2, \\qquad f(\\boldsymbol{v}) = A \\boldsymbol{v}.\n",
"$$\n",
"\n",
"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. \n",
"\n",
"Spørgsmålet er nu: Hvilke værdier kan funktionen antage? \n",
"(De ligger selvfølgelig i $\\mathbb{R}^2$.)\n",
"\n",
"Vi ved allerede, at vektoren\n",
"\n",
"$$\n",
"\\begin{bmatrix} 0 \\\\ 0 \\end{bmatrix}\n",
"$$\n",
"\n",
"altid ligger i værdimængden (som kaldes billedrummet).\n",
"\n",
"\n",
">Hvorfor?\n",
"\n",
"\n",
"Bemærk, at vi kan skrive\n",
"\n",
"$$\n",
"f(\\mathbf{v}) =\n",
"\\begin{bmatrix}\n",
"| & | \\\\\n",
"s_1 & s_2 \\\\\n",
"| & |\n",
"\\end{bmatrix}\n",
"\\begin{bmatrix}\n",
"v_{1} \\\\\n",
"v_{2}\n",
"\\end{bmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"| \\\\\n",
"s_{1} \\\\\n",
"|\n",
"\\end{bmatrix} v_{1}\n",
"+\n",
"\\begin{bmatrix}\n",
"| \\\\\n",
"s_{2} \\\\\n",
"|\n",
"\\end{bmatrix} v_{2},\n",
"$$\n",
"\n",
"hvor $s_1$ og $s_2$ er søjlerne i $A$.\n",
"\n",
"\n",
">Kan du forklare, hvorfor det gælder?\n",
"\n",
"Dette giver anledning til figuren, der dannes i følgende kodecelle."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ccb3363c",
"metadata": {},
"outputs": [],
"source": [
"# --- input (experimentér med talværdierne her) ---\n",
"s1 = np.array([1, 3]) # første søjle\n",
"s2 = np.array([2, 0.5]) # anden søjle\n",
"v1, v2 = 2, 3 # elementer i vektoren\n",
"# ------------------------------------------\n",
"\n",
"f_v = v1*s1 + v2*s2\n",
"\n",
"fig, ax = plt.subplots()\n",
"\n",
"# tegner søjleprodukterne\n",
"ax.quiver(0, 0, *v1*s1, angles='xy', scale_units='xy', scale=1, color=\"blue\")\n",
"ax.text(*v1*s1/2, r'$v_1\\mathbf{s}_1$', fontsize=12, color=\"k\", ha='left', va='top')\n",
"ax.plot([v1*s1[0], f_v[0]], [v1*s1[1], f_v[1]], 'b--', linewidth=1)\n",
"ax.quiver(0, 0, *v2*s2, angles='xy', scale_units='xy', scale=1, color=\"blue\")\n",
"ax.text(*v2*s2/2, r'$v_2\\mathbf{s}_2$', fontsize=12, color=\"k\", ha='left', va='top')\n",
"ax.plot([v2*s2[0], f_v[0]], [v2*s2[1], f_v[1]], 'b--', linewidth=1)\n",
"\n",
"# tegner søjlerne\n",
"ax.quiver(0, 0, *s1, angles='xy', scale_units='xy', scale=1, color=\"green\")\n",
"ax.text(*s1/2, r'$\\mathbf{s}_1$', fontsize=12, color=\"k\", ha='right', va='bottom')\n",
"ax.quiver(0, 0, *s2, angles='xy', scale_units='xy', scale=1, color=\"green\")\n",
"ax.text(*s2/2, r'$\\mathbf{s}_2$', fontsize=12, color=\"k\", ha='right', va='bottom')\n",
"\n",
"# tegner f(v)\n",
"ax.quiver(0, 0, *f_v, angles='xy', scale_units='xy', scale=1, color=\"r\")\n",
"ax.text(*f_v/2, r'$f(\\mathbf{v})$', fontsize=12, color=\"k\", ha='right', va='bottom')\n",
"\n",
"# plot udseende\n",
"ax.axhline(0, color=\"black\", linewidth=1)\n",
"ax.axvline(0, color=\"black\", linewidth=1)\n",
"ax.set_aspect(\"equal\")\n",
"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)\n",
"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)\n",
"ax.grid(True, which='both', linestyle='--', linewidth=0.5)\n",
"ax.set_xlabel(\"$x$\")\n",
"ax.set_ylabel(\"$y$\")\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "d1b1f5a1",
"metadata": {},
"source": [
">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.\n",
"\n",
"\n",
"### Opgave\n",
"Lad\n",
"\n",
"$$\n",
"A = \\begin{bmatrix}0 & 0 \\\\ 0 & 0\\end{bmatrix}, \\quad\n",
"B = \\begin{bmatrix}1 & 1 \\\\ -1 & 1\\end{bmatrix}, \\quad\n",
"C = \\begin{bmatrix}1 & -2 \\\\ -1 & 2\\end{bmatrix}\n",
"$$\n",
"\n",
"og\n",
"\n",
"$$\n",
"\\boldsymbol{v}_{1} = \\begin{bmatrix}1 \\\\ 1\\end{bmatrix}, \\quad \n",
"\\boldsymbol{v}_{2} = \\begin{bmatrix}-1 \\\\ 1\\end{bmatrix}.\n",
"$$\n",
"\n",
"Definér funktionerne $f_A(\\boldsymbol{v})=A\\boldsymbol{v}$, $f_B(\\boldsymbol{v})=B\\boldsymbol{v}$, $f_C(\\boldsymbol{v})=C \\boldsymbol{v}$.\n",
"\n",
"\n",
"\n",
">Opstil i følgende kodecelle matricerne $A,\\;B$ og $C$ samt vektorerne $\\boldsymbol{v}_1$ og $\\boldsymbol{v}_2$."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "48090613",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "5776d541",
"metadata": {},
"source": [
">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`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7744f259",
"metadata": {},
"outputs": [],
"source": [
"print(s1)"
]
},
{
"cell_type": "markdown",
"id": "10105cfa",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e73b797c",
"metadata": {},
"outputs": [],
"source": [
"def draw_vectors(vector_list):\n",
" # input: liste af 2D-vektorer som numpy arrays\n",
"\n",
" fig, ax = plt.subplots()\n",
" \n",
" # tegner vektorerne\n",
" for v in vector_list:\n",
" ax.quiver(0, 0, *v, angles='xy', scale_units='xy', scale=1, color=\"blue\")\n",
" #ax.text(*(v/2), f\"({v[0]}, {v[1]})\",fontsize=10, color=\"k\", ha='right', va='bottom')\n",
" \n",
" # sætter plottets størrelse\n",
" all_x = [v[0] for v in vector_list] + [0]\n",
" all_y = [v[1] for v in vector_list] + [0]\n",
" ax.set_xlim(min(all_x) - 1, max(all_x) + 1)\n",
" ax.set_ylim(min(all_y) - 1, max(all_y) + 1)\n",
"\n",
" # plot udseende\n",
" ax.axhline(0, color=\"black\", linewidth=1)\n",
" ax.axvline(0, color=\"black\", linewidth=1)\n",
" ax.set_aspect(\"equal\")\n",
" ax.grid(True, which='both', linestyle='--', linewidth=0.5)\n",
" ax.set_xlabel(\"$x$\")\n",
" ax.set_ylabel(\"$y$\")\n",
"\n",
" plt.show()"
]
},
{
"cell_type": "markdown",
"id": "8976b685",
"metadata": {},
"source": [
">Brug funktionen til at vise billedvektorerne i samme koordinatsystem."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e6ac6b87",
"metadata": {},
"outputs": [],
"source": [
"vektor_liste = [np.array([1,0]), np.array([0,1])]\n",
"draw_vectors(vektor_liste)"
]
},
{
"cell_type": "markdown",
"id": "1a8a9b55",
"metadata": {},
"source": [
">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$?\n",
"\n",
"\n",
"\n",
"### Rang\n",
"Vi vil introducere begrebet **rang** af en matrix.\n",
">Spørg din favorit-AI om begrebet *rang*.\n",
"\n",
"I Python kan rangen af en matrix beregnes med funktionen `np.linalg.matrix_rank(M)`.\n",
"\n",
">Bestem $\\;\\text{rang}(A),\\;\\text{rang}(B)$ og $\\text{rang}(C)$."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "061e9a8f",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "dd09ffe3",
"metadata": {},
"source": [
"***Bemærk:*** Det er kun for funktionen $f_B$, at vi kan finde en invers funktion. \n",
">Hvorfor?\n",
"\n",
"\n",
"## Rotationer\n",
"\n",
"Vi betragter nu en særlig klasse af funktioner:\n",
"\n",
"$$\n",
"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.\n",
"$$\n",
"\n",
"$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}$)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e8f9d697",
"metadata": {},
"outputs": [],
"source": [
"e1 = np.array([1,0])\n",
"theta = np.pi/4\n",
"M = np.array([[np.cos(theta), -np.sin(theta)],\n",
" [np.sin(theta), np.cos(theta)]])\n",
"draw_vectors([e1, M @ e1])"
]
},
{
"cell_type": "markdown",
"id": "d2efe015",
"metadata": {},
"source": [
"### Opgave\n",
"Ud af følgende 5 matricer svarer nogle til en drejning som ovenfor. \n",
"\n",
"$$\n",
"M_{1}=\\begin{bmatrix}0 & -1 \\\\ 1 & 0\\end{bmatrix}, \\quad\n",
"M_{2}=\\begin{bmatrix}1 & 0 \\\\ 0 & 1\\end{bmatrix}, \\quad\n",
"M_{3}=\\begin{bmatrix}\\tfrac{1}{\\sqrt{2}} & -\\tfrac{1}{\\sqrt{2}} \\\\ \\tfrac{1}{\\sqrt{2}} & \\tfrac{1}{\\sqrt{2}}\\end{bmatrix},\n",
"$$\n",
"$$\n",
"M_{4}=\\begin{bmatrix}1 & -1 \\\\ 1 & 1\\end{bmatrix}, \\quad\n",
"M_{5}=\\begin{bmatrix}\\tfrac{1}{2} & \\tfrac{\\sqrt{3}}{2} \\\\ -\\tfrac{\\sqrt{3}}{2} & \\tfrac{1}{2}\\end{bmatrix}.\n",
"$$\n",
"\n",
">Hvilke gør det, og hvilken vinkel svarer de til?\n",
"\n",
">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?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0750c96f",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "6ba6abfc",
"metadata": {},
"source": [
"Vi kan med fordel definere en Python-funktion, der returnerer en rotationsmatrix for en given vinkel $\\theta$. \n",
">Færdiggør funktionen `rotation_matrix` i følgende kodecelle."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4db03a28",
"metadata": {},
"outputs": [],
"source": [
"def rotation_matrix(theta):\n",
" \"\"\"\n",
" Returnerer en 2D rotationsmatrix for en rotation med vinklen theta (i radianer).\n",
" \"\"\"\n",
" # EGEN KODE: Definer rotationsmatricen M\n",
" M =\n",
"\n",
" return M"
]
},
{
"cell_type": "markdown",
"id": "39f2e035",
"metadata": {},
"source": [
"Med denne funktion kan vi nu definere en rotationsmatrix $M$ som `M=rotation_matrix(theta)`. \n",
">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`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ab246f2b",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "88ffd46c",
"metadata": {},
"source": [
"### Forklaring: hvorfor svarer $f$ til en drejning (kan evt. overspringes)\n",
"\n",
"En vektor $v$ kan opfattes som en længde og en retning, vi kan skrive \n",
"\n",
"$$\n",
"\\boldsymbol{v} =\n",
"|\\boldsymbol{v}|\\begin{bmatrix}\n",
"\\cos\\alpha \\\\\n",
"\\sin\\alpha\n",
"\\end{bmatrix},\n",
"$$\n",
"\n",
"hvor $\\alpha$ svarer til vinklen mellem vektoren og $x$-aksen (den positive retning). \n",
"\n",
"Prøv nu at udføre matrix-vektorproduktet: \n",
"\n",
"$$\n",
"M \\boldsymbol{v} = \n",
"|\\boldsymbol{v}|\\begin{bmatrix}\n",
"\\cos\\theta & -\\sin\\theta \\\\\n",
"\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}\n",
"\\begin{bmatrix}\n",
"\\cos\\alpha \\\\\n",
"\\sin\\alpha\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"> Prøv at spørg din favorit-AI hvad *additionsformlerne* er for noget, \n",
"> og se om du ved hjælp af disse kan besvare spørgsmålet: \n",
"> Hvorfor svarer $f$ til en drejning på $\\theta$ radianer i positiv omløbsretning? \n",
"\n",
"> Hvordan kan det være, at $|\\boldsymbol{v}|$ kunne flyttes uden for selve matrixproduktet?\n",
"\n",
"\n",
"\n",
"## Matrix-matrix produkt\n",
"Vi definerer i lighed med matrix-vektor produktet et matrix-matrix produkt.\n",
"\n",
"Lad\n",
"\n",
"$$\n",
"M=\n",
"\\left[\n",
"\\begin{array}{cccc}\n",
"m_{11} & m_{12} & \\cdots & m_{1n}\\\\\n",
"m_{21} & m_{22} & \\cdots & m_{2n}\\\\\n",
"\\vdots & \\vdots & \\ddots & \\vdots\\\\\n",
"m_{m1} & m_{m2} & \\cdots & m_{mn}\n",
"\\end{array}\n",
"\\right]\n",
"\\qquad\n",
"\\begin{array}{l}\n",
"\\text{$n$ søjler}\\\\\n",
"\\text{$m$ rækker}\n",
"\\end{array}\n",
"$$\n",
"\n",
"og\n",
"\n",
"$$\n",
"N=\n",
"\\left[\n",
"\\begin{array}{cccc}\n",
"n_{11} & n_{12} & \\cdots & n_{1k}\\\\\n",
"\\vdots & \\vdots & \\ddots & \\vdots\\\\\n",
"n_{n1} & n_{n2} & \\cdots & n_{nk}\n",
"\\end{array}\n",
"\\right]\n",
"\\qquad\n",
"\\begin{array}{l}\n",
"\\text{$k$ søjler}\\\\\n",
"\\text{$n$ rækker}\n",
"\\end{array}\n",
"$$\n",
"\n",
"Da er\n",
"\n",
"$$\n",
"M\\,N =\n",
"\\left[\n",
"\\begin{array}{cccc}\n",
"\\alpha_{11} & \\alpha_{12} & \\cdots & \\alpha_{1k}\\\\\n",
"\\alpha_{21} & \\alpha_{22} & \\cdots & \\alpha_{2k}\\\\\n",
"\\vdots & \\vdots & \\ddots & \\vdots\\\\\n",
"\\alpha_{m1} & \\alpha_{m2} & \\cdots & \\alpha_{mk}\n",
"\\end{array}\n",
"\\right],\n",
"$$\n",
"\n",
"hvor $\\alpha_{ij}$ er lig skalarprodukt mellem række $i$ i $M$ og søjle $j$ i $N$.\n",
"\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$)?\n",
"\n",
"### Eksempel\n",
"Betragt matrix-matrixproduktet\n",
"\n",
"$$\n",
"\\begin{bmatrix}\n",
"1 & 2\\\\\n",
"3 & 4\n",
"\\end{bmatrix}\n",
"\\begin{bmatrix}\n",
"1 & 0 & 2\\\\\n",
"-1 & 3 & 1\n",
"\\end{bmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"-1 & 6 & 4\\\\\n",
"-1 & 12 & 10\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Kan du få de samme værdier i produktmatricen som i eksemplet?\n",
"\n",
"I Python udføres matrix-matrixproduktet i samme stil som matrix-vektorproduktet ved at bruge `@`. \n",
">Verificer det ovenstående resultat i følgende kodecelle."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8a66f2a1",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "80b05ab7",
"metadata": {},
"source": [
"## Tilbage til rotationer\n",
"\n",
"### Opgave\n",
"> 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, \n",
"> og en anden $M_{2}$ der roterer en vektor i negativ omløbsretning med $\\tfrac{\\pi}{2}$ radianer:\n",
"> \n",
"> Vælg nu en vektor $v\\in\\mathbb{R}^{2}$.\n",
"> \n",
"> 1. Roter først vektoren ved hjælp af $M_1$:\n",
"> \n",
"> $$\n",
" \\boldsymbol{v}_1 = M_1 \\boldsymbol{v}.\n",
" $$\n",
"> \n",
"> 2. Roter derefter $v_1$ ved hjælp af $M_2$:\n",
"> \n",
"> $$\n",
" \\boldsymbol{v}_2 = M_2 \\boldsymbol{v}_1.\n",
" $$\n",
"> \n",
"> 3. (**Sammenlign**) Beregn også\n",
"> \n",
"> $$\n",
" \\boldsymbol{v}_2' = (M_2 M_1) \\boldsymbol{v}\n",
" $$\n",
"> \n",
"> og sammenlign $\\boldsymbol{v}_2'$ med $\\boldsymbol{v}_2$ (f.eks. i et plot eller ved brug af `print`).\n",
"> \n",
"> 4. Prøv at formulere i ord, hvad du ser!"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "17c3bf1b",
"metadata": {},
"outputs": [],
"source": [
"M1 = \n",
"M2 = \n",
"v ="
]
},
{
"cell_type": "markdown",
"id": "30c24941",
"metadata": {},
"source": [
"### Sammensætning af rotationer forklaring (kan evt. overspringes)\n",
"Lad\n",
"\n",
"$$\n",
"M_{1}=\n",
"\\begin{bmatrix}\n",
"\\cos\\theta_{1} & -\\sin\\theta_{1}\\\\\n",
"\\sin\\theta_{1} & \\ \\cos\\theta_{1}\n",
"\\end{bmatrix}\n",
"\\qquad\\text{og}\\qquad\n",
"M_{2}=\n",
"\\begin{bmatrix}\n",
"\\cos\\theta_{2} & -\\sin\\theta_{2}\\\\\n",
"\\sin\\theta_{2} & \\ \\cos\\theta_{2}\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"være to rotationsmatricer.\n",
"\n",
">Udregn $M_{1}M_{2}$ i hånden.\n",
"\n",
">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}$.\n",
"\n",
"\n",
"### Eksempel: Refleksion\n",
"\n",
"Betragt matricen\n",
"\n",
"$$\n",
"M =\n",
"\\begin{bmatrix}\n",
"0 & 1 \\\\\n",
"1 & 0\n",
"\\end{bmatrix}\n",
"$$\n",
"\n",
"og lad $f$ være funktionen $f(\\boldsymbol{v}) = M \\boldsymbol{v}$.\n",
"\n",
">Prøv med forskellige vektorer $\\boldsymbol{v}$ at finde billedvektoren $f(\\boldsymbol{v})$.
Hvilken virkning har matricen $M$ på en vektor?\n",
"\n",
"Bemærk at virkningen af $M$ ikke svarer til en rotation i positiv omløbsretning som beskrevet ovenfor,\n",
"det vil sige $M$ kan ikke bringes på formen\n",
"\n",
"$$\n",
"\\begin{bmatrix}\n",
"\\cos\\theta & -\\sin\\theta \\\\\n",
"\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Hvorfor ikke?\n",
"\n",
"Virkningen af $M$ på vektoren $\\boldsymbol{v}$ kaldes en refleksion, \n",
"(i dette tilfælde en refleksion i linjen udspændt af vektoren \n",
"$\\boldsymbol{w} = (1,1)$ ).\n",
"\n",
"\n",
"## Invers matrix\n",
"\n",
"Vi betragter igen en rotation, givet ved\n",
"\n",
"$$\n",
"M =\n",
"\\begin{bmatrix}\n",
"\\cos\\theta & -\\sin\\theta \\\\\n",
"\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
"$M$ roterer altså $\\boldsymbol{v}$, $\\theta$ radianer i positiv omløbsretning.\n",
"\n",
"Betragt nu den rotationsmatrix der roterer en vektor $\\boldsymbol{v}$, $\\theta$ radianer i negativ omløbsretning:\n",
"\n",
"$$\n",
"M^{-1} =\n",
"\\begin{bmatrix}\n",
"\\cos(-\\theta) & -\\sin(-\\theta) \\\\\n",
"\\sin(-\\theta) & \\cos(-\\theta)\n",
"\\end{bmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"\\cos\\theta & \\sin\\theta \\\\\n",
"-\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Forklar hvorfor de to ovennævnte matricer netop ser ud som de gør. \n",
"\n",
"Det er klart ud fra definitionen på $M$ og $M^{-1}$, at\n",
"\n",
"$$\n",
"M^{-1}(M\\boldsymbol{v}) = M(M^{-1}\\boldsymbol{v}) = \\boldsymbol{v}.\n",
"$$\n",
"\n",
">Prøv med forskellige forskellige vinkler og vektorer at eftervise ovenstående identiteter. \n",
"\n",
">Prøv nu med de samme vinkler at udregne matrix-matrixprodukterne $M^{-1}M$ og $MM^{-1}$.
Hvad ser du?\n",
"\n",
"Vi kalder \n",
"\n",
"$$\n",
"\\begin{bmatrix}\n",
"1 & 0 \\\\\n",
"0 & 1\n",
"\\end{bmatrix}\n",
"$$\n",
"\n",
"identitetsmatricen $I$. \n",
">Hvilken virkning har den på en vektor?\n",
"\n",
"Vi siger at en matrix $M$ med lige antal søjler og rækker har en invers matrix\n",
"hvis der findes en matrix $M^{-1}$ med egenskaben\n",
"\n",
"$$\n",
"M^{-1}M = MM^{-1} = I.\n",
"$$\n",
"\n",
"\n",
"\n",
"## Diagonal matrix\n",
"En matrix på formen\n",
"\n",
"$$\n",
"D =\n",
"\\begin{bmatrix}\n",
"m_{11} & 0 & 0 & \\cdots & 0 \\\\\n",
"0 & m_{22} & 0 & \\cdots & 0 \\\\\n",
"0 & 0 & \\ddots & \\ddots & 0 \\\\\n",
"\\vdots & \\vdots & \\ddots & \\ddots & \\vdots \\\\\n",
"0 & 0 & 0 & \\cdots & m_{nn}\n",
"\\end{bmatrix},\n",
"$$\n",
"\n",
"hvor kun diagonalelementerne er forskellige fra nul (bemærk at vi kalder diagonalen \n",
"den linje, der går fra øverste venstre hjørne til nederste højre hjørne i matricen).\n",
"\n",
">Identitetsmatricen er en diagonalmatrix – hvorfor?\n",
"\n",
"Betragt de fire følgende eksempler på $2\\times 2$ diagonalmatricer:\n",
"\n",
"$$\n",
"D_{1} =\n",
"\\begin{bmatrix}\n",
"-1 & 0 \\\\\n",
"0 & 1\n",
"\\end{bmatrix}, \\quad\n",
"D_{2} =\n",
"\\begin{bmatrix}\n",
"2 & 0 \\\\\n",
"0 & 3\n",
"\\end{bmatrix}, \\quad\n",
"D_{3} =\n",
"\\begin{bmatrix}\n",
"\\frac{1}{2} & 0 \\\\\n",
"0 & \\frac{1}{3}\n",
"\\end{bmatrix}, \\quad\n",
"D_{4} =\n",
"\\begin{bmatrix}\n",
"0 & 0 \\\\\n",
"0 & 2\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Prøv at finde den inverse matrix (hvis muligt) til de fire diagonalmatricer.\n",
"\n",
"Matricen\n",
"\n",
"$$\n",
"V =\n",
"\\begin{bmatrix}\n",
"0 & -1 \\\\\n",
"\\frac{1}{2} & 0\n",
"\\end{bmatrix}\n",
"$$\n",
"\n",
"er ikke en diagonalmatrix. \n",
"\n",
">Hvorfor ikke?\n",
"\n",
">Kan du finde en invers til $V$? \n",
"\n",
"For at se virkningen af en diagonalmatrix på en vektor $\\boldsymbol{v}$ betragter vi nu igen funktionen\n",
"\n",
"$$\n",
"f(\\boldsymbol{v}) = N_i \\boldsymbol{v},\n",
"$$\n",
"\n",
"hvor\n",
"\n",
"$$\n",
"N_{1} =\n",
"\\begin{bmatrix}\n",
"1 & 0 \\\\\n",
"0 & 1\n",
"\\end{bmatrix}, \\quad\n",
"N_{2} =\n",
"\\begin{bmatrix}\n",
"2 & 0 \\\\\n",
"0 & 2\n",
"\\end{bmatrix}, \\quad\n",
"N_{3} =\n",
"\\begin{bmatrix}\n",
"1 & 0 \\\\\n",
"0 & 2\n",
"\\end{bmatrix}, \\quad\n",
"N_{4} =\n",
"\\begin{bmatrix}\n",
"0 & 1 \\\\\n",
"-1 & 0\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Beregn $f(\\boldsymbol{v})$ i disse 4 tilfælde, brug forskellige $\\boldsymbol{v}$'er."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f9f35a3b",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "a3cac082",
"metadata": {},
"source": [
">Kan du forklare virkningen på en vektor $\\boldsymbol{v}$ i de 4 tilfælde?\n",
"\n",
"\n",
"### Sammensætning af rotationer og diagonalmatricer\n",
"\n",
"Vi betragter igen de 4 matricer ovenfor. \n",
"Lad $M$ være matricen\n",
"\n",
"$$\n",
"M =\n",
"\\begin{bmatrix}\n",
"\\cos\\left(\\tfrac{\\pi}{4}\\right) & -\\sin\\left(\\tfrac{\\pi}{4}\\right) \\\\\n",
"\\sin\\left(\\tfrac{\\pi}{4}\\right) & \\cos\\left(\\tfrac{\\pi}{4}\\right)\n",
"\\end{bmatrix}.\n",
"$$\n",
"\n",
">Udregn nu $M^{-1}N_iM$ og forklar resultatet ved hjælp af et plot."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d732b9a6",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "9db6b50c",
"metadata": {},
"source": [
"> Gælder der samme regler som for tal, at faktorernes orden er ligegyldig, altså er det korrekt at: \n",
">\n",
"> $$\n",
" M^{-1}N_iM = N_iM^{-1}M = N_i I = N_i \\, ?\n",
" $$\n",
">\n",
"> Hvis ikke det gælder generelt, er det så altid forkert?\n",
"\n",
"\n",
"\n",
"## Drejning af koordinatsystem og skift af koordinater\n",
"\n",
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b78c2dbd",
"metadata": {},
"outputs": [],
"source": [
"# Rotationsvinkel\n",
"theta = np.pi / 6 \n",
"\n",
"# Akse definitioner\n",
"x_axis = np.array([1, 0])\n",
"y_axis = np.array([0, 1])\n",
"x_prime = np.array([np.cos(theta), np.sin(theta)])\n",
"y_prime = np.array([-np.sin(theta), np.cos(theta)])\n",
"\n",
"# Vektoren v\n",
"v = np.array([np.cos(np.pi/4), np.sin(np.pi/4)])\n",
"\n",
"fig, ax = plt.subplots(figsize=(5, 5))\n",
"\n",
"# Plotter akserne\n",
"axes_width = 0.004\n",
"ax.quiver(0, 0, *x_axis, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(1.05, -0.05, \"$x$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *y_axis, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(-0.05, 1.05, \"$y$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *x_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(x_prime[0]+0.05, x_prime[1], \"$x'$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *y_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(y_prime[0]-0.1, y_prime[1], \"$y'$\", fontsize=12)\n",
"\n",
"# Plot vektoren v\n",
"ax.quiver(0, 0, *v, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=0.006)\n",
"ax.text(v[0]+0.05, v[1]+0.05, r\"vektoren $\\mathbf{v}$\", fontsize=12)\n",
"\n",
"# Vinkelbue for theta\n",
"arc = np.linspace(0, theta, 100)\n",
"ax.plot(0.4*np.cos(arc), 0.4*np.sin(arc), color=\"black\",linewidth=1)\n",
"ax.text(0.5*np.cos(theta/2), 0.5*np.sin(theta/2), r\"$\\theta$\", fontsize=12)\n",
"\n",
"# Plot udseende\n",
"ax.set_aspect('equal')\n",
"ax.set_xlim(-1, 1.5)\n",
"ax.set_ylim(-0.5, 1.5)\n",
"ax.axis(\"off\")\n",
"\n",
"plt.show()\n"
]
},
{
"cell_type": "markdown",
"id": "93e73fab",
"metadata": {},
"source": [
"Opgaven er nu, hvis vi kender koordinaterne for $\\boldsymbol{v}$ i det sædvanlige koordinatsystem,\n",
"at finde koordinaterne i det drejede koordinatsystem og omvendt.\n",
"\n",
"---\n",
"\n",
"Først et let eksempel: Lad os dreje $x'$-$y'$-koordinatsystemet \n",
"$\\tfrac{\\pi}{2}$ radianer i forhold til $x$-$y$-koordinatsystemet."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e537bf79",
"metadata": {},
"outputs": [],
"source": [
"# Rotationsvinkel\n",
"theta = np.pi / 2\n",
"\n",
"# Akse definitioner\n",
"x_axis = np.array([2, 0])\n",
"y_axis = np.array([0, 2])\n",
"x_prime = 2*np.array([np.cos(theta), np.sin(theta)])\n",
"y_prime = 2*np.array([-np.sin(theta), np.cos(theta)])\n",
"\n",
"# Vektoren v\n",
"v = np.sqrt(2)*np.array([np.cos(np.pi/4), np.sin(np.pi/4)])\n",
"\n",
"fig, ax = plt.subplots(figsize=(5, 5))\n",
"\n",
"# Plotter akserne\n",
"axes_width = 0.004\n",
"ax.quiver(0, 0, *x_axis, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(x_axis[0]+0.05, x_axis[1], \"$x$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *y_axis, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(y_axis[0]-0.1, y_axis[1], \"$y$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *x_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(x_prime[0]+0.05, x_prime[1], \"$x'$\", fontsize=12)\n",
"\n",
"ax.quiver(0, 0, *y_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=axes_width)\n",
"ax.text(y_prime[0]-0.1, y_prime[1], \"$y'$\", fontsize=12)\n",
"\n",
"# Plot vektoren v og projektioner på x- og y-aksen\n",
"ax.quiver(0, 0, *v, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=0.006)\n",
"ax.text(v[0]+0.05, v[1]+0.05, r\"$\\mathbf{v}$\", fontsize=12)\n",
"ax.plot([v[0], v[0]], [-0.05, v[1]], 'k--', linewidth=0.5) # vertical from x-axis to tip\n",
"ax.plot([-0.05, v[0]], [v[1], v[1]], 'k--', linewidth=0.5) # horizontal from y-axis to tip\n",
"ax.text(v[0], -0.1, \"1\", fontsize=10, ha='center', va='top')\n",
"ax.text(-0.1, v[1], \"1\", fontsize=10, ha='right', va='center')\n",
"\n",
"# Plot udseende\n",
"ax.axis('off')\n",
"ax.set_aspect('equal')\n",
"ax.set_xlim(-2.5, 2.5)\n",
"ax.set_ylim(-1, 3)\n",
"\n",
"plt.show()\n"
]
},
{
"cell_type": "markdown",
"id": "5ecc9f22",
"metadata": {},
"source": [
"Koordinaterne for $\\boldsymbol{v}$ med hensyn til $x$-$y$-koordinatsystemet er \n",
"\n",
"$$\n",
"(1,1).\n",
"$$\n",
"\n",
"Koordinaterne for $\\boldsymbol{v}$ med hensyn til $x'$-$y'$-koordinatsystemet er \n",
"\n",
"$$\n",
"(1,-1).\n",
"$$\n",
"\n",
">Forklar hvorfor, brug figuren.\n",
"\n",
"---\n",
"\n",
"Nu vender vi tilbage til det oprindelige problem.\n",
"\n",
"Lad os sige, at koordinaterne for $\\boldsymbol{v}$ med hensyn til $x'$-$y'$-koordinatsystemet er \n",
"\n",
"$$\n",
"(v_1',v_2'),\n",
"$$\n",
"\n",
"Forestil jer nu, at de to koordinatsystemer er sammenfaldende til at starte med,\n",
"og vi så begynder at dreje $x'$-$y'$-koordinatsystemet $\\theta$ radianer i positiv omløbsretning\n",
"med vektoren $\\boldsymbol{v}$ fastholdt til $x'$-$y'$-koordinatsystemet. \n",
"\n",
"Dette svarer til at dreje vektoren $\\boldsymbol{v}$ $\\theta$ radianer, så koordinaterne i $x$-$y$-koordinatsystemet er\n",
"\n",
"$$\n",
"\\begin{pmatrix} \n",
"x \\\\[0.3em] \n",
"y \n",
"\\end{pmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"\\cos\\theta & -\\sin\\theta \\\\\n",
"\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}\n",
"\\begin{pmatrix}\n",
"x' \\\\[0.3em] y'\n",
"\\end{pmatrix}.\n",
"$$\n",
"\n",
"Drejningen den modsatte vej er givet ved\n",
"\n",
"$$\n",
"\\begin{pmatrix} x'\\\\[0.2em] y' \\end{pmatrix}\n",
"=\n",
"\\begin{bmatrix}\n",
"\\cos\\theta & \\sin\\theta\\\\\n",
"-\\sin\\theta & \\cos\\theta\n",
"\\end{bmatrix}\n",
"\\begin{pmatrix} x\\\\[0.2em] y \\end{pmatrix}.\n",
"$$\n",
"\n",
">Forklar hvorfor! \n",
"\n",
"Vi kalder de to indgående matricer for koordinatskiftematricer.\n",
"\n",
"---\n",
"\n",
"**Opgave**\n",
"\n",
"Vælg nu en drejningsvinkel på $\\tfrac{\\pi}{4}$ radianer.\n",
"\n",
"1. Betragt en vektor $\\boldsymbol{v}$ med koordinater\n",
"\n",
"$$\n",
"\\begin{pmatrix} x \\\\ y \\end{pmatrix}\n",
"=\n",
"\\begin{pmatrix} 1 \\\\ 2 \\end{pmatrix}.\n",
"$$\n",
"\n",
">Find $x'$-$y'$-koordinaterne."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9d0266d7",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "3c00d9fc",
"metadata": {},
"source": [
"2. Betragt en vektor $\\boldsymbol{w}'$ med koordinater\n",
"\n",
"$$\n",
"\\begin{pmatrix} x' \\\\ y' \\end{pmatrix}\n",
"=\n",
"\\begin{pmatrix} \\sqrt{2} \\\\ \\sqrt{2} \\end{pmatrix}.\n",
"$$\n",
"\n",
">Find $x$-$y$-koordinaterne."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "07902333",
"metadata": {},
"outputs": [],
"source": [
"#"
]
},
{
"cell_type": "markdown",
"id": "146a8b48",
"metadata": {},
"source": [
"3. 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:\n",
"\n",
"`ax.quiver(0, 0, *np.array([1,1/2]), angles=\"xy\", scale_units=\"xy\", scale=1, color=\"red\", width=0.006)`\n",
"\n",
">Foretag ændringer i plottet, så vi får følgende: \n",
"> * I ($x,y$)-koordinatsystem vises vektorerne $\\boldsymbol{v}$ og $\\boldsymbol{w}$.\n",
"> * I ($x',y'$)-koordinatsystem vises vektorerne $\\boldsymbol{v}'$ og $\\boldsymbol{w}'$.\n",
"> * $\\boldsymbol{v}$ og $\\boldsymbol{v}'$ er plottet med samme farve, mens $\\boldsymbol{w}$ og $\\boldsymbol{w}'$ har en anden fælles farve."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4a37d1c4",
"metadata": {},
"outputs": [],
"source": [
"# Rotationsvinkel\n",
"theta = np.pi / 4\n",
"\n",
"# Akse definitioner\n",
"x_prime = 2*np.array([np.cos(theta), np.sin(theta)])\n",
"y_prime = 2*np.array([-np.sin(theta), np.cos(theta)])\n",
"\n",
"fig, axs = plt.subplots( 1, 2, figsize = (10,10)) # laver to plots side om side (1x2)\n",
"\n",
"# fælles plot udseende\n",
"for ax in axs:\n",
" ax.grid()\n",
" ax.set_aspect('equal')\n",
" ax.set_xlim(-1.75, 2.25)\n",
" ax.set_ylim(-1, 2.5)\n",
" ax.axhline(0, color=\"black\", linewidth=1)\n",
" ax.axvline(0, color=\"black\", linewidth=1)\n",
"\n",
"# venstre subplot (x-y koordinatsystem) ----------------------------\n",
"ax = axs[0]\n",
"\n",
"# sætter akse-labels og titel\n",
"ax.set_xlabel('x')\n",
"ax.set_ylabel('y')\n",
"ax.set_title('($x$, $y$) koordinatsystem')\n",
"\n",
"# plotter x'-y'-askerne\n",
"ax.quiver(0, 0, *x_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=0.004)\n",
"ax.text(x_prime[0]+0.05, x_prime[1], \"$x'$\", fontsize=12)\n",
"ax.quiver(0, 0, *y_prime, angles=\"xy\", scale_units=\"xy\", scale=1, color=\"black\", width=0.004)\n",
"ax.text(y_prime[0]-0.1, y_prime[1], \"$y'$\", fontsize=12)\n",
"\n",
"# EGEN KODE: plotter vektorerne v og w (x-y koordinater)\n",
"ax.quiver(0, 0, *np.array([1,1/2]), angles=\"xy\", scale_units=\"xy\", scale=1, color=\"red\", width=0.006) # eksempel (fjern denne)\n",
"\n",
"# højre subplot (x'-y' koordinatsystem) ----------------------------\n",
"ax = axs[1]\n",
"\n",
"# sætter akse-labels og titel\n",
"ax.set_xlabel(\"$x'$\")\n",
"ax.set_ylabel(\"$y'$\")\n",
"ax.set_title(\"($x'$, $y'$) koordinatsystem\")\n",
"\n",
"# EGEN KODE: plotter vektorerne v' og w' (x'-y' koordinater)\n",
"ax.quiver(0, 0, *np.array([1,1/2]), angles=\"xy\", scale_units=\"xy\", scale=1, color=\"blue\", width=0.006) # eksempel (fjern denne)\n",
"\n",
"plt.show()\n"
]
}
],
"metadata": {
"jupytext": {
"formats": "ipynb,md:myst",
"text_representation": {
"extension": ".md",
"format_name": "myst",
"format_version": 0.13,
"jupytext_version": "1.16.0"
}
},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"source_map": [
13,
20,
23,
168,
172,
238,
240,
307,
347,
374,
376,
380,
382,
386,
412,
416,
419,
433,
435,
451,
457,
476,
478,
483,
492,
497,
499,
620,
622,
656,
660,
876,
878,
898,
900,
916,
962,
972,
1017,
1096,
1098,
1111,
1113,
1125
]
},
"nbformat": 4,
"nbformat_minor": 5
}