Комплексно сопряженное число python

Комплексные числа Python

Комплексное число — это любое число в форме a + bj , где a и b — действительные числа, а j*j = -1.

В Python есть несколько способов создать такое комплексное число.

>>> a = 4 + 3j >>> print(a) (4+3j) >>> print(type(a))

>>> a = complex(4, 3) >>> print(type(a)) >>> print(a) (4+3j)

Реальные и мнимые части в комплексном числе

Каждое комплексное число ( a + bj ) имеет действительную часть ( a ) и мнимую часть ( b ).

Чтобы получить действительную часть, используйте number.real , а для получения мнимой части используйте number.imag .

>>> a (4+3j) >>> a.real 4.0 >>> a.imag 3.0

Сопряжение комплексного числа

Сопряжение комплексного числа a + bj определяется как a — bj . Мы также можем использовать number.conjugate() для получения конъюгата.

Арифметические операции

Подобно действительным числам, комплексные числа также можно складывать, вычитать, умножать и делить. Давайте посмотрим, как мы могли бы это сделать в Python.

a = 1 + 2j b = 2 + 4j print('Addition =', a + b) print('Subtraction =', a - b) print('Multiplication =', a * b) print('Division =', a / b)

Addition = (3+6j) Subtraction = (-1-2j) Multiplication = (-6+8j) Division = (2+0j)

ПРИМЕЧАНИЕ. В отличие от действительных чисел, мы не можем сравнивать два комплексных числа. Мы можем сравнивать только их действительную и мнимую части по отдельности, поскольку это действительные числа. Приведенный ниже фрагмент доказывает это.

>>> a (4+3j) >>> b (4+6j) >>> a < b Traceback (most recent call last): File "", line 1, in TypeError: '
Фаза (аргумент)
Мы можем представить комплексное число как вектор, состоящий из двух компонентов на плоскости, состоящей из real и imaginary осей. Следовательно, две составляющие вектора — это действительная и мнимая части.


Угол между вектором и действительной осью определяется как argument или phase комплексного числа.
Формально это определяется как:
фаза (число) = arctan (мнимая_часть / действительная_часть)
где функция arctan является обратной математической функцией tan.
В Python мы можем получить фазу комплексного числа, используя модуль cmath для комплексных чисел. Мы также можем использовать функцию math.arctan и получить фазу из ее математического определения.
import cmath import math num = 4 + 3j # Using cmath module p = cmath.phase(num) print('cmath Module:', p) # Using math module p = math.atan(num.imag/num.real) print('Math Module:', p)
 
cmath Module: 0.6435011087932844 Math Module: 0.6435011087932844
 
Обратите внимание, что эта функция возвращает фазовый угол в radians , поэтому, если нам нужно преобразовать в degrees , мы можем использовать другую библиотеку, например numpy .
 
import cmath import numpy as np num = 4 + 3j # Using cmath module p = cmath.phase(num) print('cmath Module in Radians:', p) print('Phase in Degrees:', np.degrees(p))
 
cmath Module in Radians: 0.6435011087932844 Phase in Degrees: 36.86989764584402
 
Прямоугольные и полярные координаты
 
Комплексное число может быть записано в формате прямоугольных или полярных координат с помощью cmath.rect() и cmath.polar() .
 
>>> import cmath >>> a = 3 + 4j >>> polar_coordinates = cmath.polar(a) >>> print(polar_coordinates) (5.0, 0.9272952180016122) >>> modulus = abs(a) >>> phase = cmath.phase(a) >>> rect_coordinates = cmath.rect(modulus, phase) >>> print(rect_coordinates) (3.0000000000000004+3.9999999999999996j)
 
Константы в модуле cmath
 
В модуле cmath есть специальные константы. Некоторые из них перечислены ниже.
 
print('π =', cmath.pi) print('e =', cmath.e) print('tau =', cmath.tau) print('Positive infinity =', cmath.inf) print('Positive Complex infinity =', cmath.infj) print('NaN =', cmath.nan) print('NaN Complex =', cmath.nanj)
 
π = 3.141592653589793 e = 2.718281828459045 tau = 6.283185307179586 Positive infinity = inf Positive Complex infinity = infj NaN = nan NaN Complex = nanj
 
Тригонометрические функции
 
Тригонометрические функции для комплексного числа также доступны в модуле cmath .
 
import cmath a = 3 + 4j print('Sine:', cmath.sin(a)) print('Cosine:', cmath.cos(a)) print('Tangent:', cmath.tan(a)) print('ArcSin:', cmath.asin(a)) print('ArcCosine:', cmath.acos(a)) print('ArcTan:', cmath.atan(a))
 
Sine: (3.853738037919377-27.016813258003936j) Cosine: (-27.034945603074224-3.8511533348117775j) Tangent: (-0.0001873462046294784+0.999355987381473j) ArcSin: (0.6339838656391766+2.305509031243477j) ArcCosine: (0.9368124611557198-2.305509031243477j) ArcTan: (1.4483069952314644+0.15899719167999918j)
 
Гиперболические функции
 
Подобно тригонометрическим функциям, гиперболические функции для комплексного числа также доступны в модуле cmath .
 
import cmath a = 3 + 4j print('Hyperbolic Sine:', cmath.sinh(a)) print('Hyperbolic Cosine:', cmath.cosh(a)) print('Hyperbolic Tangent:', cmath.tanh(a)) print('Inverse Hyperbolic Sine:', cmath.asinh(a)) print('Inverse Hyperbolic Cosine:', cmath.acosh(a)) print('Inverse Hyperbolic Tangent:', cmath.atanh(a))
 
Hyperbolic Sine: (-6.5481200409110025-7.61923172032141j) Hyperbolic Cosine: (-6.580663040551157-7.581552742746545j) Hyperbolic Tangent: (1.000709536067233+0.00490825806749606j) Inverse Hyperbolic Sine: (2.2999140408792695+0.9176168533514787j) Inverse Hyperbolic Cosine: (2.305509031243477+0.9368124611557198j) Inverse Hyperbolic Tangent: (0.11750090731143388+1.4099210495965755j)
 
Экспоненциальные и логарифмические функции
 
import cmath a = 3 + 4j print('e^c =', cmath.exp(a)) print('log2(c) =', cmath.log(a, 2)) print('log10(c) =', cmath.log10(a)) print('sqrt(c) =', cmath.sqrt(a))
 
e^c = (-13.128783081462158-15.200784463067954j) log2(c) = (2.321928094887362+1.3378042124509761j) log10(c) = (0.6989700043360187+0.4027191962733731j) sqrt(c) = (2+1j)
 
Другие
 
Есть несколько разных функций, чтобы проверить, является ли комплексное число конечным, бесконечным или nan . Также есть функция проверки близости двух комплексных чисел.
 
>>> print(cmath.isfinite(2 + 2j)) True >>> print(cmath.isfinite(cmath.inf + 2j)) False >>> print(cmath.isinf(2 + 2j)) False >>> print(cmath.isinf(cmath.inf + 2j)) True >>> print(cmath.isinf(cmath.nan + 2j)) False >>> print(cmath.isnan(2 + 2j)) False >>> print(cmath.isnan(cmath.inf + 2j)) False >>> print(cmath.isnan(cmath.nan + 2j)) True >>> print(cmath.isclose(2+2j, 2.01+1.9j, rel_tol=0.05)) True >>> print(cmath.isclose(2+2j, 2.01+1.9j, abs_tol=0.005)) False
 
Источник
 
Python, комплексные типы для работы с комплексными числами (абсолютные значения, склонение, полярные преобразования и т.д.)
 
 
 
 
В Python есть стандартный тип для работы с комплексными числами — тип COMPLEX. Если вы хотите выполнять простые вычисления, вам не нужно импортировать какие-либо модули, но если вы импортируете стандартную библиотеку cmath, вы также сможете использовать математические функции (экспоненциальные, логарифмические, тригонометрические и т.д.), соответствующие комплексным числам.
 
Следующее содержание объясняется здесь с помощью примера кода.
 
 
Генерировать комплексные переменные
 
Получение действительных и мнимых частей : real , imag атрибут
 
Получение сопряженных комплексных чисел : conjugate() метод
 
Получить абсолютное значение (величину) : abs() функция (например, математика, программирование, программирование)
 
Получить склонение (фазу) : math , cmath модуль
 
Преобразование полярных координат (представление в полярной форме) : math , cmath модуль
 
Вычисление комплексных чисел (квадратура, силы, квадратные корни)
 
 
Генерировать комплексные переменные
 
Обозначим мнимую единицу через j и напишем следующее, заметим, что это не i.
 
c = 3 + 4j print(c) print(type(c)) # (3+4j) # 
 
Если мнимая часть равна 1, ее опущение приводит к ошибке NameError. Если переменная с именем j определена первой, она считается этой переменной.
 
1j 
Это должно быть четко сформулировано таким образом.
 
# c = 3 + j # NameError: name 'j' is not defined c = 3 + 1j print(c) # (3+1j) 
 
Если действительная часть равна 0, ее можно опустить.
 
Если вы хотите определить значение с мнимой частью 0 как сложный комплексный тип, запишите 0 явно. Как описано ниже, между комплексным типом и целочисленным типом или типом с плавающей точкой можно выполнять операции.
 
Вещественная и мнимая части могут быть заданы в виде плавающей запятой. Также допустима экспоненциальная нотация.
 
c = 1.2e3 + 3j print(c) # (1200+3j) 
 
Он также может быть порожден конструктором типа «complex», как в «complex(real part, imaginary part)».
 
c = complex(3, 4) print(c) print(type(c)) # (3+4j) # 
 
Получение действительных и мнимых частей комплексных чисел: real, imagатрибут
 
Действительную и мнимую части сложного комплексного типа можно получить с помощью атрибутов real и imag соответственно. Оба типа являются типами с плавающей точкой.
 
c = 3 + 4j print(c.real) print(type(c.real)) # 3.0 # print(c.imag) print(type(c.imag)) # 4.0 # 
 
Он доступен только для чтения и не может быть изменен.
 
# c.real = 5.5 # AttributeError: readonly attribute 
 
Получение сопряженных комплексных чисел: conjugate()
 
Чтобы получить сопряженные комплексные числа, используйте метод conjugate().
 
c = 3 + 4j print(c.conjugate()) # (3-4j) 
 
Получение абсолютного значения (величины) комплексного числа: abs()
 
Чтобы получить абсолютное значение (величину) комплексного числа, используйте встроенную функцию abs().
 
c = 3 + 4j print(abs(c)) # 5.0 c = 1 + 1j print(abs(c)) # 1.4142135623730951 
 
Получение склонения (фазы) комплексного числа: math, cmathмодуль
 
Чтобы получить склонение (фазу) комплексного числа, используйте модуль math или cmath.
 
Модуль cmath — это модуль математических функций для комплексных чисел.
 
Его можно вычислить с помощью функции обратного тангенса math.atan2(), как определено, или использовать cmath.phase(), которая возвращает склонение (фазу).
 
import cmath import math c = 1 + 1j print(math.atan2(c.imag, c.real)) # 0.7853981633974483 print(cmath.phase(c)) # 0.7853981633974483 print(cmath.phase(c) == math.atan2(c.imag, c.real)) # True 
 
В обоих случаях единицей измерения угла, который можно получить, являются радианы. Для преобразования в градусы используйте math.degrees().
 
print(math.degrees(cmath.phase(c))) # 45.0 
 
Преобразование полярных координат комплексных чисел (полярное формальное представление): math, cmathмодуль
 
Как упоминалось выше, можно получить абсолютное значение (величину) и склонение (фазу) комплексного числа, но с помощью cmath.polar() их можно получить вместе в виде кортежа (абсолютное значение, склонение).
 
c = 1 + 1j print(cmath.polar(c)) print(type(cmath.polar(c))) # (1.4142135623730951, 0.7853981633974483) # print(cmath.polar(c)[0] == abs(c)) # True print(cmath.polar(c)[1] == cmath.phase(c)) # True 
 
Преобразование из полярных координат в декартовы осуществляется с помощью cmath.rect(). cmath.rect(абсолютное значение, отклонение) и аналогичные аргументы можно использовать для получения значений эквивалентного комплексного комплексного типа.
 
print(cmath.rect(1, 1)) # (0.5403023058681398+0.8414709848078965j) print(cmath.rect(1, 0)) # (1+0j) print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1])) # (1.0000000000000002+1j) 
 
Действительная и мнимая части эквивалентны результатам, вычисленным косинусом math.cos() и синусом math.sin() по абсолютным значениям и углам склонения.
 
r = 2 ph = math.pi print(cmath.rect(r, ph).real == r * math.cos(ph)) # True print(cmath.rect(r, ph).imag == r * math.sin(ph)) # True 
 
Вычисление комплексных чисел (квадратура, силы, квадратные корни)
 
Четыре арифметические операции и вычисления мощности могут быть выполнены с помощью обычных арифметических операторов.
 
c1 = 3 + 4j c2 = 2 - 1j print(c1 + c2) # (5+3j) print(c1 - c2) # (1+5j) print(c1 * c2) # (10+5j) print(c1 / c2) # (0.4+2.2j) print(c1 ** 3) # (-117+44j) 
 
Квадратный корень можно вычислить с помощью **0.5, но это вносит ошибку. Для вычисления точного значения можно использовать cmath.sqrt().
 
print((-3 + 4j) ** 0.5) # (1.0000000000000002+2j) print((-1) ** 0.5) # (6.123233995736766e-17+1j) print(cmath.sqrt(-3 + 4j)) # (1+2j) print(cmath.sqrt(-1)) # 1j 
 
Он также может выполнять арифметические операции с комплексными типами, типами int и float.
 
print(c1 + 3) # (6+4j) print(c1 * 0.5) # (1.5+2j) 
 
Источник
 
Читайте также:  Удалить элемент из сета python