Python Language Numeri complessi e il modulo cmath


Esempio

Il modulo cmath è simile al modulo math , ma definisce le funzioni in modo appropriato per il piano complesso.

Prima di tutto, i numeri complessi sono un tipo numerico che fa parte del linguaggio Python stesso anziché essere fornito da una classe di libreria. Pertanto non è necessario import cmath per le normali espressioni aritmetiche.

Nota che usiamo j (o J ) e non i .

z = 1 + 3j

Dobbiamo usare 1j poiché j sarebbe il nome di una variabile piuttosto che un valore letterale numerico.

1j * 1j
Out: (-1+0j)

1j ** 1j
# Out: (0.20787957635076193+0j)     # "i to the i"  ==  math.e ** -(math.pi/2)

Abbiamo la parte real e la parte imag (immaginaria), così come il complesso conjugate :

# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)

z.conjugate()
# Out: (1-3j)    # z.conjugate() == z.real - z.imag * 1j

Le funzioni integrate abs e complex sono anche parte del linguaggio stesso e non richiedono alcuna importazione:

abs(1 + 1j)
# Out: 1.4142135623730951     # square root of 2

complex(1)
# Out: (1+0j)

complex(imag=1)
# Out: (1j)

complex(1, 1)
# Out: (1+1j)

La funzione complex può prendere una stringa, ma non può avere spazi:

complex('1+1j')
# Out: (1+1j)

complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string

Ma per la maggior parte delle funzioni abbiamo bisogno del modulo, ad esempio sqrt :

import cmath

cmath.sqrt(-1)
# Out: 1j

Naturalmente il comportamento di sqrt è diverso per numeri complessi e numeri reali. Nella math non complessa la radice quadrata di un numero negativo solleva un'eccezione:

import math

math.sqrt(-1)
# Exception: ValueError: math domain error

Le funzioni sono fornite per convertire da e verso le coordinate polari:

cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # == (sqrt(1 + 1), atan2(1, 1))

abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483)    # same as previous calculation

cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)

Il campo matematico dell'analisi complessa va oltre lo scopo di questo esempio, ma molte funzioni nel piano complesso hanno un "taglio di ramo", solitamente lungo l'asse reale o l'asse immaginario. La maggior parte delle piattaforme moderne supporta lo "zero firmato" come specificato in IEEE 754, che fornisce la continuità di tali funzioni su entrambi i lati del taglio del ramo. Il seguente esempio è tratto dalla documentazione di Python:

cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793

cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793

Il modulo cmath fornisce anche molte funzioni con controparti dirette dal modulo math .

Oltre a sqrt , esistono versioni complesse di exp , log , log10 , le funzioni trigonometriche e le loro inverse ( sin , cos , tan , asin , acos , atan ) e le funzioni iperboliche e le loro inverse ( sinh , cosh , tanh , asinh , acosh , atanh ). Si noti tuttavia che non esiste una controparte complessa di math.atan2 , la forma a due argomenti di arcotangente.

cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)

cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j)   # e to the i pi == -1, within rounding error

Le costanti pi ed e sono fornite. Nota che questi sono float e non complex .

type(cmath.pi)
# Out: <class 'float'>

Il modulo cmath fornisce anche versioni complesse di isinf , e (per Python 3.2+) isfinite . Vedi " Infinito e NaN ". Un numero complesso è considerato infinito se la sua parte reale o la sua parte immaginaria è infinita.

cmath.isinf(complex(float('inf'), 0.0))
# Out: True

Allo stesso modo, il modulo cmath fornisce una versione complessa di isnan . Vedi " Infinito e NaN ". Un numero complesso è considerato "non un numero" se la sua parte reale o la sua parte immaginaria è "non un numero".

cmath.isnan(0.0, float('nan'))
# Out: True 

Nota: non esiste una controparte di cmath delle costanti math.inf e math.nan (da Python 3.5 e versioni successive)

Python 3.x 3.5
cmath.isinf(complex(0.0, math.inf))
# Out: True

cmath.isnan(complex(math.nan, 0.0))
# Out: True

cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'

In Python 3.5 e superiore, v'è un isclose metodo sia cmath e math moduli.

Python 3.x 3.5
z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

cmath.isclose(z, 1+1j)
# True