Komplexa tal

Komplexa tal med DSL

Då inleder vi med komplexa tal! Det här är något som antagligen känns ganska hemvant för de flesta av er men vi tar och repeterar lite ändå och passar på att visa hur man kan implementera ämnet med DSL.

Imaginära tal. Var kommer dom ifrån tänker ni? Jo, det är så att om man försökte dra roten ur ett negativt tal så blev det jobbigt, fram till att någon introducerade imaginära tal. Som är jobbiga på sitt eget sätt istället. Så därför bestämdes det att $\i^2$ ska vara -1.

Som tur är så är det hela ganska konsekvent utformat så att $\sqrt{-2}$ också blir $\sqrt{2}i$, och $\sqrt{-3}$ blir $\sqrt{3} i$. Så om man drar roten ur vilket negativt tal som helst så får man samma svar som i det positiva fallet fast med ett i på köpet.

Vi kommer dock inte använda oss av beteckningen i i våra texter, eftersom att man inom fysik, elektronik och flera andra ämnen redan använder bokstaven i för att beteckna en ström. Därfor brukar man ofta använda j inom signallära istället, för att undvika missförstånd, och det kommer vi också göra. Komplexa tal kan ses som ett par utav reella värden, där första värdet i talet är reellt och det andra värdet är den imaginära delen. Det kan dock vara så att en eller båda av dessa delar är noll. T.ex. $7+0*j$ blir ju bara 7.

Att skriva

  Complex 13 37

i vårt DSL är samma sak som att skriva $13 + 37j$, där 13 är reellt och 37 är imaginärt. Det är alltså inget ‘j’ i vårt DSL som indikerar att det är imaginärt utan man måste bara skriva dem i rätt ordning. Det ser som tur liknande ut i matten så det är ganska lätt att komma ihåg! Nu betraktar vi det komplexa talet $13+37j$. Vi döper detta till leet så att vi slipper skriva ut alltihop i framtiden.

  ghci> let leet = Complex 13 37

Om du nu känner att du vill veta vad det reella talet i paret är, då kan man skriva en funktion realPart som bara ger dig den reella delen.

  realPart :: Complex -> Double
  realPart (Complex re im) = re

Nu kan vi enkelt få ut realdelen ifrån leet:

  ghci> realPart leet
  13

Se så enkelt det blev! Så för att få ut den imaginära delen av talet så gör vi en funktion imPart.

imPart :: Complex -> Double
imPart (Complex re im) = im

  printComplex :: Complex -> String
  printComplex z
    | re == 0 = show im ++ "j"
    | im == 0 = undefined
    | otherwise = undefined
       where im = imPart z
              re = realPart z

printComplex :: Complex -> String
printComplex z
  | re == 0 = show im ++ "j"
  | im == 0 = show re
  | otherwise = show re ++ " + " ++ show im ++ "j"
    where im = imPart z
          re = realPart z

Exempel:

  ghci> printComplex (Complex 5 12)
  "5 + 12j"

  ghci> printComplex leet
  "13 + 37j"

Hur skulle man då göra för att faktiskt räkna på detta? Då måste man definiera hur matematiska tecken ska tolkas när man arbetar med komplexa tal.

Addition för komplexa tal är ganska lätt om ni kommer ihåg det. Om man är reell bryr man sig bara om andra reella tal, och vice versa för imaginära tal.

instance Num Complex where
    z + w =          Complex (...)

instance Num Complex where
    z + w           = Complex (realPart z + realPart w) (imPart z + imPart w)

Multiplikation blir lite krångligare. Om vi multiplicerar två komplexa tal, vi kallar dem z och w, ser det ut såhär:

  z * w = Complex (realZ*realW - imZ*imW) (realZ*imW + realW*imZ)
	   where realZ = realPart z
	         realW = realPart w
	         imZ   = imPart z
	         imW   = imPart w

Vilket då blir samma sak som: $$z \; w = (Re(Z) ⋅ Re(W) - Im(Z) ⋅ Im(W)) + (Re(Z) ⋅ Im(W) + Re(W) ⋅ Im(Z))j$$

Det kan även vara bra att ha en funktion som negerar ett komplext tal. T.ex. $13+37j$ ska då alltså bli $-13-37j$

negate z        = Complex (...)

   negate z        = Complex (negate $ realPart z, negate $ imPart z)

Absolutbeloppet på ett komplext tal kan man räkna ut på samma sätt som man räknar ut hypotenusan i en rätvinklig triangel.

 abs z = Complex hyp 0
           where hyp = ...
                 re  = realPart z
                 im  = imPart z

    abs z           = Complex (hyp, 0)
        where hyp   = sqrt (re*re + im*im)
              re    = realPart z
              im    = imPart z

Eulers formel

Eulers formel, eller Enigmatic Euler’s Formula som den också kallas, är en formel för att skriva om komplexa tal från en exponentiell funktion till trigonometriska funktioner och tvärtom.

Är det någon som verkligen vet hur trigonometriska funktioner funkar? Förmodligen..., men det skulle väl inte skada om det fanns ett sätt att skriva om trigonometriska funktioner till komplexa tal och tvärtom. Här kommer Eulers formel in! $$e^{jt} = cos(t) + jsin(t)$$

Med lite magiska omskrivningar kan man bryta ut cosinus respektive sinus ur formeln vilket ger följande funktioner. $$cos(t) = (e^{jt} + e^{-jt})/2$$ $$sin(t) = (e^{jt} - e^{-jt})/(2j)$$ Varför skulle flera komponenter vara bättre då? Det tar vi upp i avsnitt 3 om Fourierserier! Men nu vet ni hur man gör!

Sammanfattning

Gratulerar! Du har nu lärt dig följande:

• Vad komplexa tal är.

• Hur man gör några vanliga beräkningar med komplexa tal.

• Hur man implementerar komplexa tal med funktionell programmering i en DSL.

• Hur man implementerar vanliga beräkningar med komplexa tal med funktionell programmering i en DSL.

• Vad Eulers formel är.

• Hur man kan skriva om trigonometriska och komplexa uttryck med Eulers formel.

• Hur man implementerar Eulers formel med funktionell programmering i en DSL.