Komplexatal.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ecd726f8-bc4f-4ce5-8064-e67a757121b2",
   "metadata": {},
   "source": [
    "# Komplexa tal\n",
    "\n",
    "Komplexa tal och deras hantering i python.\n",
    "\n",
    "\n",
    "## Att ange den imaginära enheten\n",
    "\n",
    "I matematiken används ofta bokstaven i för att symbolisera $\\sqrt{-1}$ men i python används bokstaven j. I matematiken skriver vi $2+3i$ men i python skriver vi $2+3j$.\n",
    "\n",
    "Vi låter python själv identifiera datatypen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b8a6ede-7aee-4674-b614-86082e081a2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "z = 2 + 3j\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b2f1d84-f4b6-4574-a850-3e21b7bf93b2",
   "metadata": {},
   "source": [
    "Man kan inte skriva $2+3*j$ utan måste skriva $2+3*1j$ eller $2+3j$. Man kan inte skriva enbart *j utan måste skriva *1j."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bd730fc6-869a-4ee3-9974-bdeb6c8a0a1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+3j)\n",
      "(2+3j) 1j\n"
     ]
    }
   ],
   "source": [
    "z = 2 + 3j\n",
    "print(z)\n",
    "#z1 = 2 + 3*j  # Fel\n",
    "z2 = 2 + 3*1j  # Rätt\n",
    "#z3 = j  # Fel\n",
    "z4 = 1j  # Rätt\n",
    "print(z2, z4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea058395-f4fd-41df-8469-7eb581e5d7ef",
   "metadata": {},
   "source": [
    "Ett komplext tal kan också skapas på följande sätt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c000f723-0896-4a6c-89e6-2365c059e48d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+3j) \n",
      " 3j\n"
     ]
    }
   ],
   "source": [
    "z1 = complex(2, 3)\n",
    "z2 = complex(0,3)\n",
    "print(z1,\"\\n\",z2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9637dd5a-9980-40a6-94f6-582a99251965",
   "metadata": {},
   "source": [
    "## Realdel och imaginärdel\n",
    "\n",
    "\n",
    "De fyra räknesätten fungerar som med float, inga nya symboler.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0a8e8b28-720a-4fda-b32a-3370e7ea0693",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-1.9+8j)\n",
      "(6.1-2j)\n",
      "(-23.4-1.5j)\n",
      "(0.16097560975609757-0.5487804878048781j)\n",
      "3.661966684720111\n",
      "(-4.0324954682820735e-05+2.1605933515767933e-05j)\n"
     ]
    }
   ],
   "source": [
    "z1 = 2.1 + 3j\n",
    "z2 = -4 + 5j\n",
    "\n",
    "print(z1 + z2)\n",
    "print(z1 - z2)\n",
    "print(z1 * z2)\n",
    "print(z1 / z2)\n",
    "print(abs(z1))\n",
    "print(z1**z2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1887362d-072f-4190-95e5-d4347bab7742",
   "metadata": {},
   "source": [
    "\n",
    "De komplexa talen är vad man kallar för en klass. På denna klass finns en mängd metoder. En metod är i princip en def (se 2.4), fast den anropas lite annorlunda. Att få realdel och imaginärdel av ett tal $z$ är exempel på metoder.\n",
    "\n",
    "I matematiken skriver vi $Re(z)$ och $Im(z)$. I python skriver vi `z.real` och `z.imag`. Metoder anges med \"objekt.metod\". I detta fall är z objektet och metoden som används på z är real och imag."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f08ab044-fd39-476b-9c37-a2cc84590a23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0 4.0\n",
      "(2-4j)\n"
     ]
    }
   ],
   "source": [
    "z = 2 + 4j\n",
    "print(z.real, z.imag)\n",
    "print(z.conjugate())  # Observera parentesen i detta fall"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72086e35-bdc6-458a-afd6-38c32a05e346",
   "metadata": {},
   "source": [
    "Metoderna är 'immutable' så de kan inte användas för att ändra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f957f53b-00ca-42b8-b606-5adfae33c836",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "readonly attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m z \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m4\u001b[39mj\n\u001b[0;32m----> 2\u001b[0m z\u001b[38;5;241m.\u001b[39mreal \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n",
      "\u001b[0;31mAttributeError\u001b[0m: readonly attribute"
     ]
    }
   ],
   "source": [
    "z = 2 + 4j\n",
    "z.real = 3  # Går ej ändra realdelen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38aa3740-f4f3-4afb-8dd6-bee5fda91670",
   "metadata": {},
   "source": [
    "Vid inmatning, som ju är en sträng, har vi behov av att omvandla strängen till ett komplext tal. Observera att det inte får finnas mellanslag vid inmatningen, testa själv. `2+3j` är ok men inte `2 + 3j`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ee45619e-9d99-47fe-8cd3-9434db1f06e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2+3j)\n"
     ]
    }
   ],
   "source": [
    "z = complex(input(\"Ange ett komplext tal\"))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be1668d2-882c-48b5-bc0d-ec839c85a144",
   "metadata": {},
   "source": [
    "Komplexa tal finns i built in modulen (den som alltid laddas när python startas). Där finns .real, .imag och .conjugate() men inte mer (och de fyra räknesätten för komplexa tal naturligtvis). För att beräkna vinklar osv. så används modulen cmath (complex math) som laddas på vanligt sätt. Modulen math räcker i regel inte; math kan tex. inte ta roten ur -1, vilket cmath kan.\n",
    "\n",
    "\n",
    "## Rötter\n",
    "\n",
    "Även cmath har sina begränsningar. Om vi försöker lösa $z^4+1=0$ som har fyra rötter ger oss cmath bara en. Här krävs modulen numpy (numerical python) för att reda ut det och ge oss 4 rötter. Vi ska beräkna $(-1)^{1/4}$ och förväntar oss 4 svar. För z3 (nedan i programmet) har vi använt omskrivningen\n",
    "\n",
    "$$\n",
    "\\left(-1\\right)^{1/4}=e^{\\ln(-1)\\cdot1/4}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fe63748c-96ec-4e82-8152-d5978ac3538c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z=  (0.7071067811865476+0.7071067811865475j)\n",
      "(z1=  1j )\n",
      "z2=  (0.7071067811865476+0.7071067811865475j)\n",
      "z3=  (0.7071067811865476+0.7071067811865475j)\n"
     ]
    }
   ],
   "source": [
    "import cmath  # Vi testar numpy i nästa cell\n",
    "\n",
    "z = (-1)**(1/4)  # Även utan cmath får vi 1 lösning\n",
    "\n",
    "z1=cmath.sqrt(-1)  # Med cmath i 2 steg\n",
    "z2=cmath.sqrt(z1)\n",
    "\n",
    "z3=cmath.exp(cmath.log(-1)*1/4)  # (-1)^1/4\n",
    "\n",
    "print(\"z= \", z)\n",
    "print(\"(z1= \", z1,\")\")\n",
    "print(\"z2= \", z2)\n",
    "print(\"z3= \", z3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c483a9df-38b2-4c39-8204-bff207b11693",
   "metadata": {},
   "source": [
    "Medan numpy kommer att ge oss 4 svar. Vi måste ange de 5 koefficienterna i polynomet $a_0+a_1z+a_2z^2+a_3z^3+a_4z^4$ som en lista med lägsta gradtalet först (så samma som index). `[1,0,0,0,1]` ger oss $a_0=1$ och $a_4=1$, dvs $1+1 \\cdot z^4$. För att skapa en ekvation sätter numpy automatiskt polynomet till lika med 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "10c85167-57a2-4221-8fca-b3e8dc150736",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.70710678-0.70710678j -0.70710678+0.70710678j  0.70710678-0.70710678j\n",
      "  0.70710678+0.70710678j]\n"
     ]
    }
   ],
   "source": [
    "import numpy.polynomial.polynomial as poly\n",
    "\n",
    "print(poly.polyroots([1,0,0,0,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37dc2ff7-0099-4d80-a9ef-df961cc886fa",
   "metadata": {},
   "source": [
    "## Rektangulära och Polära koordinater\n",
    "\n",
    "Omvandling mellan Rektangulära och polära koordinater i cmath. Kommandot ger oss två tal, radien (avståndet) och vinkeln"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "145266d9-2579-4485-bafe-3939025407d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "avståndet är  3.605551275463989\n",
      "vinkeln är  33.70715561737648 eller i radianer  0.5880026035475675\n",
      "3.605551275463989\n",
      "33.70715561737648\n"
     ]
    }
   ],
   "source": [
    "import cmath\n",
    "r, fi = cmath.polar(3 + 2j)  # Anrop av funktionen ger oss 2 tal i retur\n",
    "print(\"avståndet är \", r)\n",
    "print(\"vinkeln är \", fi/3.14*180, \"eller i radianer \", fi)\n",
    "\n",
    "print(abs(3+2j))\n",
    "print(cmath.phase(3+2j)/3.14*180)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd632fd-592f-4f3f-b8dc-05d91682b59a",
   "metadata": {},
   "source": [
    "Och i andra riktningen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6b6fe148-26b0-449a-8f9f-46d3210f7dd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2.995386258684133+1.9969129077869852j)\n"
     ]
    }
   ],
   "source": [
    "import cmath\n",
    "print(cmath.rect(3.6, 0.588))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31cdd1f5-10a4-4970-aede-b3836400f558",
   "metadata": {},
   "source": [
    "## Uppgifter\n",
    "\n",
    "\n",
    "**Uppgift 1**\n",
    "\n",
    "Ange rötterna till $z^3=-1$ och $z^3=-i$\n",
    "\n",
    "\n",
    "[Lösningsförslag](./uppg/KomplexatalUppgift1.ipynb)\n",
    "\n",
    "\n",
    "**Uppgift 2**\n",
    "\n",
    "Studera Eulers formel genom att sätta in några värden. Eulers formel är $e^{ix}=\\cos(x)+i\\sin(x)$. Sätt in några tal för $x$ i vänster led och beräkna, sätt också in dem för $x$ i höger led och beräkna. Jämför. Använd import cmath och exponentialfunktionen `cmath.exp()` samt `cmath.cos(x)` och `cmath.sin(x)`. \n",
    "\n",
    "[Lösningsförslag](./uppg/KomplexatalUppgift2.ipynb)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 5
}