cmath — Matematiska funktioner för komplexa tal

---

Den här modulen ger tillgång till matematiska funktioner för komplexa tal. Funktionerna i denna modul accepterar heltal, flyttal eller komplexa tal som argument. De accepterar också alla Python-objekt som har antingen en __complex__()- eller en __float__()-metod: dessa metoder används för att konvertera objektet till ett komplext tal respektive ett flyttal, och funktionen tillämpas sedan på resultatet av konverteringen.

Anteckning

För funktioner som involverar förgreningar har vi problemet att bestämma hur vi ska definiera dessa funktioner på själva förgreningen. I enlighet med Kahans dokument ”Branch cuts for complex elementary functions” samt bilaga G i C99 och senare C-standarder använder vi tecknet för noll för att skilja den ena sidan av förgreningen från den andra: för en förgrening längs (en del av) den reella axeln tittar vi på tecknet för den imaginära delen, medan vi för en förgrening längs den imaginära axeln tittar på tecknet för den reella delen.

Till exempel har funktionen cmath.sqrt() ett grenavsnitt längs den negativa realaxeln. Ett argument med -2-0j behandlas som om det ligger under grenavsnittet och ger därför ett resultat på den negativa imaginära axeln:

>>> cmath.sqrt(-2-0j)
-1.4142135623730951j

Men ett argument av -2+0j behandlas som om det ligger ovanför grenen cut:

>>> cmath.sqrt(-2+0j)
1.4142135623730951j

Omvandlingar till och från polära koordinater
phase(z)	Returnera fasen för z
polar(z)	Returnera representationen av z i polära koordinater
rect(r, phi)	Returnerar det komplexa talet z med polära koordinater r och phi
Kraft- och logaritmfunktioner
exp(z)	Returnera e upphöjd till kraften z
log(z[, base])	Returnerar logaritmen av z till den angivna basen (e som standard)
log10(z)	Returnerar bas-10 logaritmen av z
sqrt(z)	Returnerar kvadratroten av z
Trigonometriska funktioner
acos(z)	Returnera arc cosinus av z
asin(z)	Returnerar bågsinus av z
atan(z)	Returnera bågtangenten för z
cos(z)	Returnera cosinus av z
sin(z)	Returnera sinus av z
tan(z)	Returnera tangenten till z
Hyperboliska funktioner
acosh(z)	Returnerar den inversa hyperboliska cosinus av z
asinh(z)	Returnerar den inversa hyperboliska sinus av z
atanh(z)	Returnera den inversa hyperboliska tangenten för z
cosh(z)	Returnerar hyperbolisk cosinus av z
sinh(z)	Returnerar hyperbolisk sinus av z
tanh(z)	Returnera den hyperboliska tangenten för z
Klassificeringsfunktioner
isfinite(z)	Kontrollera om alla komponenter i z är ändliga
isinf(z)	Kontrollera om någon komponent i z är oändlig
isnan(z)	Kontrollera om någon komponent i z är en NaN
isclose(a, b, *, rel_tol, abs_tol)	Kontrollera om värdena a och b ligger nära varandra
Konstanter
pi	π = 3.141592…
e	e = 2.718281…
tau	τ = 2π = 6,283185…
inf	Positiv oändlighet
infj	Ren imaginär oändlighet
nan	”Inte ett tal” (NaN)
nanj	Rent imaginärt NaN

Omvandling till och från polära koordinater

Ett komplext Python-tal z lagras internt med hjälp av rektangulära eller kartesiska koordinater. Det bestäms helt av dess reella del z.real och dess imaginära del z.imag.

Polära koordinater ger ett alternativt sätt att representera ett komplext tal. I polära koordinater definieras ett komplext tal z av modulus r och fasvinkeln phi. Modulen r är avståndet från z till origo, medan fasen phi är den motsols vinkeln, mätt i radianer, från den positiva x-axeln till det linjesegment som förbinder origo med z.

Följande funktioner kan användas för att konvertera från de ursprungliga rektangulära koordinaterna till polära koordinater och vice versa.

cmath.phase(z)

Returnerar fasen för z (även känt som argumentet för z), som en float. phase(z) är ekvivalent med math.atan2(z.imag, z.real). Resultatet ligger i intervallet [-π, π], och grenavsnittet för denna operation ligger längs den negativa realaxeln. Tecknet på resultatet är detsamma som tecknet på z.imag, även när z.imag är noll:

>>> phase(-1+0j)
3.141592653589793
>>> phase(-1-0j)
-3.141592653589793

Anteckning

Modulus (absolutvärdet) för ett komplext tal z kan beräknas med hjälp av den inbyggda funktionen abs(). Det finns ingen separat cmath-modulfunktion för denna operation.

cmath.polar(z)

Returnerar representationen av z i polära koordinater. Returnerar ett par (r, phi) där r är modulus för z och phi är fas för z. polar(z) är ekvivalent med (abs(z), phase(z)).

cmath.rect(r, phi)

Returnerar det komplexa talet z med polära koordinater r och phi. Motsvarar komplex(r * math.cos(phi), r * math.sin(phi)).

Potens- och logaritmfunktioner

cmath.exp(z)

Returnerar e upphöjt till potensen z, där e är basen för naturliga logaritmer.

cmath.log(z[, base])

Returnerar logaritmen av z till den angivna basen. Om bas inte anges, returneras den naturliga logaritmen för z. Det finns ett grenavsnitt, från 0 längs den negativa realaxeln till -∞.

cmath.log10(z)

Returnerar bas-10 logaritmen av z. Detta har samma grenutskärning som log().

cmath.sqrt(z)

Returnerar kvadratroten av z. Detta har samma grenutsnitt som log().

Trigonometriska funktioner

cmath.acos(z)

Returnerar arc cosinus av z. Det finns två grenskärningar: Den ena sträcker sig höger från 1 längs den reella axeln till ∞. Den andra sträcker sig vänster från -1 längs den reella axeln till -∞.

cmath.asin(z)

Returnerar bågsinus för z. Detta har samma grenavsnitt som acos().

cmath.atan(z)

Returnerar bågtangenten för z. Det finns två grenskärningar: Den ena sträcker sig från 1j längs den imaginära axeln till ∞j. Den andra sträcker sig från -1j längs den imaginära axeln till -∞j.

cmath.cos(z)

Returnerar cosinus av z.

cmath.sin(z)

Returnerar sinus av z.

cmath.tan(z)

Returnera tangenten till z.

Hyperboliska funktioner

cmath.acosh(z)

Returnerar den inversa hyperboliska cosinus för z. Det finns ett grenavsnitt som sträcker sig åt vänster från 1 längs den reella axeln till -∞.

cmath.asinh(z)

Returnerar den inversa hyperboliska sinus för z. Det finns två grenskärningar: Den ena sträcker sig från 1j längs imaginäraxeln till ∞j. Den andra sträcker sig från -1j längs den imaginära axeln till -∞j.

cmath.atanh(z)

Returnerar den inversa hyperboliska tangenten för z. Det finns två grenskärningar: Den ena sträcker sig från 1 längs den reella axeln till ∞. Den andra sträcker sig från -1 längs den reella axeln till -∞.

cmath.cosh(z)

Returnerar hyperbolisk cosinus av z.

cmath.sinh(z)

Returnerar den hyperboliska sinusformen av z.

cmath.tanh(z)

Returnerar den hyperboliska tangenten för z.

Klassificeringsfunktioner

cmath.isfinite(z)

Returnerar True om både real- och imaginärdelarna av z är ändliga, och False annars.

Tillagd i version 3.2.

cmath.isinf(z)

Returnerar True om antingen den reella eller den imaginära delen av z är en oändlighet, och False annars.

cmath.isnan(z)

Returnerar True om antingen den reella eller den imaginära delen av z är en NaN, och False annars.

cmath.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Returnerar True om värdena a och b ligger nära varandra och False i annat fall.

Huruvida två värden anses ligga nära varandra eller inte avgörs enligt givna absoluta och relativa toleranser. Om inga fel inträffar blir resultatet: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

rel_tol är den relativa toleransen - det är den maximalt tillåtna skillnaden mellan a och b, i förhållande till det större absoluta värdet av a eller b. Om du t.ex. vill ange en tolerans på 5 % anger du rel_tol=0,05. Standardtoleransen är 1e-09, vilket garanterar att de två värdena är lika inom cirka 9 decimaler. rel_tol måste vara icke-negativt och mindre än 1,0.

abs_tol är den absoluta toleransen; standardvärdet är 0,0 och det måste vara icke-negativt. Vid jämförelse av x med 0,0 beräknas isclose(x, 0) som abs(x) <= rel_tol * abs(x), vilket är falskt för alla x och rel_tol som är mindre än 1,0. Lägg därför till ett lämpligt positivt abs_tol-argument i anropet.

IEEE 754 specialvärdena NaN, inf och -inf kommer att hanteras enligt IEEE:s regler. Specifikt anses inte NaN ligga nära något annat värde, inklusive NaN. inf och -inf betraktas endast som nära sig själva.

Tillagd i version 3.5.

Se även

PEP 485 – En funktion för att testa ungefärlig likhet

Konstanter

cmath.pi

Den matematiska konstanten π, som en flyttal.

cmath.e

Den matematiska konstanten e, som ett flyttal.

cmath.tau

Den matematiska konstanten τ, som flyttal.

Tillagd i version 3.6.

cmath.inf

Flyttalspositiv oändlighet. Motsvarar float('inf').

Tillagd i version 3.6.

cmath.infj

Komplext tal med noll i real del och positiv oändlighet i imaginär del. Motsvarar komplex(0.0, float('inf')).

Tillagd i version 3.6.

cmath.nan

Ett flytpunktsvärde som inte är ett tal (NaN). Motsvarar float('nan').

Tillagd i version 3.6.

cmath.nanj

Komplext tal med noll i realdelen och NaN i imaginärdelen. Motsvarar komplex(0.0, float('nan')).

Tillagd i version 3.6.

Observera att urvalet av funktioner är liknande, men inte identiskt, med det i modul math. Anledningen till att det finns två moduler är att vissa användare inte är intresserade av komplexa tal, och kanske inte ens vet vad de är. De vill hellre att math.sqrt(-1) ska ge upphov till ett undantag än att returnera ett komplext tal. Notera också att de funktioner som definieras i cmath alltid returnerar ett komplext tal, även om svaret kan uttryckas som ett reellt tal (i vilket fall det komplexa talet har en imaginär del på noll).

En anteckning om grenskärningar: De är kurvor längs vilka den givna funktionen inte är kontinuerlig. De är en nödvändig egenskap hos många komplexa funktioner. Det antas att om du behöver beräkna med komplexa funktioner, kommer du att förstå om grenskärningar. Konsultera nästan vilken (inte alltför elementär) bok som helst om komplexa variabler för upplysning. För information om det rätta valet av grenskärningar för numeriska ändamål bör en bra referens vara följande:

Se även

Kahan, W: Branch cuts for complex elementary functions; or, Much ado about nothing’s sign bit. I Iserles, A., och Powell, M. (red.), The state of the art in numerical analysis. Clarendon Press (1987) s. 165–211.