Java комплексные числа: комплексное число | C++ для приматов

Содержание

комплексное число | C++ для приматов

#include <iostream>

#include <string>

using namespace std;

 

struct complex_number {  //создадим структуру комплексных чисел

    int real;

    int imagine;

};

 

complex_number convert(string term) {

    complex_number x;

    x.real = 1;  //чтобы не вводить отдельные переменные для знака присвоим начальное значение не 0, а 1

    x.imagine = 1;

    if (term[0] == ‘-‘) {  //если нулевой символ минус, то меняем значение действительной части на -1;

        x.real *= -1;

        term.erase(term.begin(), term.begin() + 1);  //удаляем минус на нулевой позиции, если он есть, чтобы было легче найти второй знак

    }

    int index = term.find(‘+’);  //находим индекс знака, если это плюс

    if (index == -1) {

        index = term.find(‘-‘);  //находим индекс знака, если это минус

        x.imagine = -1;  //меняем значение мнимой части на -1, если второй знак минус

    }

    x.real *= atoi(&term.substr(0, index)[0]);  //находим действительную часть

    x.imagine *= atoi(&term.substr(index + 1, term.size() — 2)[0]);  //находим мнимую часть

    return x;  //возвращаем полученное комплексное число

}

 

int main() {

    string term1, term2;

    char sign;

    complex_number convert_term1, convert_term2;

    while (cin >> term1 >> sign >> term2) {

        convert_term1 = convert(term1);  //переводим первую строку в первое слагаемое

        convert_term2 = convert(term2);  //переводим вторую строку во второе слагаемое

        if (sign == ‘+’) { //выполняем действие соответствующее считанному знаку

            convert_term1.real += convert_term2.real;

            convert_term1.imagine += convert_term2.imagine;

        }

        else {

            convert_term1.real -= convert_term2.real;

            convert_term1.imagine -= convert_term2.imagine;

        }  //если мнимая часть отрицательная, то минус между мнимой и действительной частями выведется сам, а если она положительная, то мы должны вывести плюс вручную

        cout << convert_term1.real << (convert_term1.imagine >= 0 ? «+» : «») << convert_term1.imagine << «i» << endl;

    }

}

Комплексные числа в Scala — CoderLessons.com

обзор

Недавно я выступил с вступительной речью о Scala на мероприятии внутреннего гика в SAP . В этом выступлении я использовал пример класса комплексных чисел для иллюстрации важных концепций и функций языка. Во многих отношениях это классический пример, который можно найти во многих других вводных материалах о Scala, например, в этом руководстве по Scala для Java-программистов . Тем не менее, я подумал, что это прекрасный пример, достойный очередной попытки. Во время беседы я начал с очень простой однострочной и постепенно добавил к ней больше возможностей, в то же время представляя возможности языка, которые сделали их возможными. В итоге я получил более или менее полную и полезную реализацию комплексных чисел всего за несколько строк кода, которая, тем не менее, позволяла

было бы невозможно с другими языками (Java), такими как операторная арифметика, плавное преобразование между сложными и действительными числами и «свободное» равенство и сравнение. В этом посте я хотел бы воспроизвести эту часть моего выступления. Если вы интересуетесь Scala, но еще не освоили язык, это может быть хорошим знакомством с краткостью и мощью этого замечательного языка программирования.

Отправная точка

Наша отправная точка довольно проста:

1

class Complex(val re

: Double, val im: Double)

Единственная строка выше — это полное определение класса. У него есть два поля Double , которые являются открытыми (так как это по умолчанию в Scala) и неизменяемыми (из-за ключевого слова val ). Вышеприведенная строка также неявно определяет конструктор с двумя аргументами по умолчанию, так что экземпляры Complex уже могут быть созданы и инициализированы. Давайте сделаем это в интерпретаторе Scala:

1

2

scala> val x = new Complex(1, 2)

x:

Complex = Complex@3997ca20

Если вы сравните это определение класса с кодом, который был бы необходим для достижения того же в Java, становится очевидным, что Scala гораздо более лаконичен и элегантен, позволяя вам четко выразить свое намерение в наименьшем количестве возможных строк кода.

Переопределяющие методы

Строковое представление по умолчанию для Complex выше довольно недружелюбно. Было бы намного лучше, если бы он содержал членов класса в формате, подходящем для комплексного числа. Чтобы достичь этого, мы, конечно, переопределим метод toString который наш класс наследует от Any , корня иерархии классов Scala.

1

2

3

4

class Complex(val re: Double, val im: Double) {

  override def toString =

    re + (if (im < 0) "-" + -im else "+" + im) + "*i"

}

Обратите внимание, что ключевое слово override является обязательным в Scala. Он должен использоваться при переопределении чего-либо, иначе вы получите ошибку компилятора. Это один из многих способов, которыми Scala помогает вам как программисту избежать глупых ошибок, в данном случае случайных переопределений. Теперь, если вы создадите экземпляр Complex

в интерпретаторе, вы получите:

1

2

scala> val x = new Complex(1, 2)

x: Complex = 1.0+2.0*i

Добавление методов и операторов

Поскольку комплексные числа являются числами, одну вещь, которую мы хотели бы иметь с ними, — это арифметические операции, такие как сложение. Один из способов добиться этого — определить новый метод add :

1

2

3

4

class Complex(val

re: Double, val im: Double) {

  def add(c: Complex) = new Complex(re + c.re, im + c.im)

  ...

}

С помощью приведенного выше определения мы можем добавить комплексные числа, вызвав наш новый метод, используя знакомую запись:

1

2

3

4

5

6

7

8

scala> val x = new Complex(1, 2)

x: Complex

= 1.0+2.0*i

 

scala> val y = new Complex(3, 4)

y: Complex = 3.0+4.0*i

 

scala> x.add(y)

res0: Complex = 4.0+6.0*i

В Scala мы также можем вызывать наш метод, как и любой другой метод, используя операторную нотацию , с тем же результатом:

1

2

scala> x add y

res1: Complex = 4.0+6.0*i

А так как у нас есть операторная нотация, мы могли бы также вызвать наш метод + , а не add . Да, это возможно в Scala.

1

2

3

4

class Complex(val re: Double, val im: Double) {

  def +(c: Complex) = new Complex(re + c.re, im + c.im)

  ...

}

Теперь добавление x и y может быть выражено просто как:

1

2

scala> x + y

res2: Complex = 4.0+6.0*i

Если вы знакомы с такими языками, как C ++, это может выглядеть как перегрузка операторов . Но на самом деле неверно говорить, что в Scala есть перегрузка операторов. Вместо этого у Scala вообще нет операторов. Каждая оператороподобная конструкция, включая арифметические операции над простыми типами, на самом деле является вызовом метода. Это, конечно, гораздо более согласованно и проще в использовании, чем традиционная перегрузка операторов, которая рассматривает операторов как особый случай. В финальной версии нашего класса Complex мы добавим методы оператора -, * и / для других арифметических операций.

Перегрузка конструкторов и методов

Комплексные числа с нулевой мнимой частью на самом деле являются действительными числами, поэтому действительные числа можно рассматривать просто как особый тип комплексных чисел. Следовательно, должна быть возможность плавно преобразовывать эти два вида чисел и смешивать их в арифметических выражениях. Чтобы достичь этого в нашем примере класса, мы будем перегружать существующий конструктор и метод + чтобы они принимали Double вместо Complex :

1

2

3

4

5

6

class Complex(val re: Double, val im: Double) {

  

def this(re: Double) = this(re, 0)

  ...

  def +(d: Double) = new Complex(re + d, im)

  ...

}

Теперь мы можем создавать Complex экземпляры, указав только их действительные части и добавив к ним действительные числа:

1

2

3

4

5

scala> val y = new Complex(2)

y: Complex = 2.0+0.0*i

 

scala> y + 2

res3: Complex = 4.0+0.0*i

Перегрузка конструкторов и методов в Scala аналогична тому, что можно найти в Java и других языках. Перегрузка конструктора, однако, несколько более ограничительна. Чтобы обеспечить согласованность и избежать общих ошибок, каждый перегруженный конструктор должен вызывать конструктор по умолчанию в своем первом операторе, и только конструктору по умолчанию разрешается вызывать конструктор суперкласса.

Неявные преобразования

Если вместо y + 2 выше мы выполним 2 + y мы получим ошибку, поскольку ни у одного из простых типов Scala нет метода + принятия Complex в качестве аргумента. Чтобы улучшить ситуацию, мы можем определить неявное преобразование из Double в Complex :

1

implicit def fromDouble(d: Double) = new Complex(d)

С этим преобразованием становится возможным добавление экземпляра Complex в double:

1

2

scala> 2 + y

res3: Complex = 4.0+0.0*i

Неявные преобразования — это мощный механизм, позволяющий несовместимым типам взаимодействовать друг с другом. Это почти делает другие подобные функции, такие как перегрузка метода, устаревшими. Фактически, с вышеупомянутым преобразованием нам больше не нужно перегружать метод + . Действительно, есть веские причины предпочитать неявные преобразования перегрузке методов, как объясняется в разделе «Почему перегрузка методов отстает в Scala» . В финальной версии нашего класса Complex мы добавим неявные преобразования и из других простых типов.

Модификаторы доступа

Как истинно объектно-ориентированный язык, Scala предлагает мощные функции контроля доступа, которые могут помочь вам обеспечить правильную инкапсуляцию. Среди них есть знакомые модификаторы private и protected доступа, которые вы можете использовать в полях и методах для ограничения их видимости. В нашем классе Complex мы могли бы использовать закрытое поле для хранения абсолютного значения или модуля комплексного числа:

1

2

3

4

class Complex(val re: Double, val im: Double) {

  private val modulus = sqrt(pow(re, 2) + pow(im, 2))

  ...

}

Попытка получить доступ к modulus извне, конечно, приведет к ошибке.

Унарные операторы

Чтобы позволить клиентам получить модуль экземпляра Complex , мы добавим новый метод, который его возвращает. Поскольку модуль является очень распространенной операцией, было бы неплохо иметь возможность снова вызывать его как оператор. Однако на этот раз это должен быть унарный оператор. К счастью, Scala помогает нам определить и этот тип операторов:

1

2

3

4

5

6

class Complex(val re: Double, val im: Double) {

  private val modulus = sqrt(pow(re, 2) + pow(im, 2))

  ...

  def unary_! = modulus

  ...

}

Методы, начинающиеся с unary_ могут быть вызваны как унарные операторы:

1

2

3

4

5

scala> val y = new Complex(3, 4)

y: Complex = 3.0+4.0*i

 

scala> !y

res2: Double = 5.0

В финальной версии нашего класса Complex мы добавим унарные операторы для знаков + и - и для комплексного сопряжения.

Сопутствующие объекты

Помимо традиционных классов, Scala также позволяет определять объекты с помощью ключевого слова object , которое в сущности одновременно определяет одноэлементный класс и его единственный экземпляр. Если объект имеет то же имя, что и класс, определенный в том же исходном файле, он становится сопутствующим объектом этого класса. Сопутствующие объекты имеют особое отношение к классам, которые они сопровождают, в частности, они могут получить доступ к закрытым методам и полям этого класса.

У Scala нет static ключевого слова, поскольку создатели языка считают, что это противоречит истинной объектной ориентации. Поэтому сопутствующие объекты в Scala — это место для размещения элементов, которые вы бы определили как статические в других языках, например, константах, фабричных методах и неявных преобразованиях. Давайте определим следующий объект-компаньон для нашего класса Complex :

1

2

3

4

5

6

object Complex {

  val i = new Complex(0, 1)

  def apply(re: Double, im: Double) = new Complex(re, im)

  def apply(re: Double) = new Complex(re)

  implicit def fromDouble(d: Double) = new Complex(d)

}

Наш сопутствующий объект имеет следующие члены:

  • i постоянная для мнимой единицы
  • Два apply метода — это фабричные методы, которые позволяют создавать экземпляры Complex , вызывая Complex(...) вместо менее удобного new Complex(...) .
  • Неявное преобразование из fromDouble является введенным выше.

Имея объект-компаньон, мы можем теперь написать такие выражения, как:

1

2

scala> 2 + i + Complex(1, 2)

res3: Complex = 3.0+3.0*i

Черты

Строго говоря, комплексные числа не сопоставимы друг с другом. Тем не менее, для практических целей было бы полезно ввести естественное упорядочение на основе их модуля. Конечно, мы хотели бы иметь возможность сравнивать комплексные числа с теми же операторами <, <=,> и> =, которые используются для сравнения других числовых типов.

Один из способов добиться этого — определить все эти 4 метода. Тем не менее, это приведет к некоторому шаблону, так как методы <=,> и> = будут, конечно, вызывать метод <. В Scala этого можно избежать, используя мощную функцию, известную как черты .

Черты похожи на интерфейсы в Java, так как они используются для определения типов объектов путем указания сигнатуры поддерживаемых методов. В отличие от Java, Scala позволяет частично реализовать черты, поэтому для некоторых методов можно определить реализации по умолчанию, аналогично методам по умолчанию в Java 8 . В Scala класс может расширяться или смешивать несколько признаков благодаря составу класса mixin .

В нашем примере мы Ordered черту Ordered в наш класс Complex . Эта черта обеспечивает реализации всех 4 операторов сравнения, которые все вызывают абстрактный метод compare . Поэтому, чтобы получить все операции сравнения «бесплатно», все, что нам нужно сделать, — это предоставить конкретную реализацию этого метода.

1

2

3

4

5

6

class Complex(val re: Double, val im: Double)

  extends Ordered[Complex] {

  ...

  def compare(that: Complex) = !this compare !that

  ...

}

Теперь мы можем сравнивать комплексные числа по желанию:

1

2

3

4

5

scala> Complex(1, 2) > Complex(3, 4)

res4: Boolean = false

 

scala> Complex(1, 2) < Complex(3, 4)

res5: Boolean = true

Классы дел и сопоставление с образцом

Интересно, что сравнение Complex экземпляров на равенство не работает должным образом:

1

2

scala> Complex(1, 2) == Complex(1, 2)

res6: Boolean = false

Это связано с тем, что метод == вызывает метод equals , который по умолчанию реализует равенство ссылок. Один из способов исправить это — переопределить метод equals для нашего класса. Конечно, переопределение equals означает также переопределение hashCode . Хотя это было бы довольно тривиально, это добавило бы нежелательный образец.

В Scala мы можем пропустить все это, если определим наш класс как класс case , добавив ключевое слово case . Это автоматически добавляет несколько полезных возможностей, среди которых следующие:

  • адекватные реализации equals и hashCode
  • сопутствующий объект с методом apply factory
  • параметры класса неявно определены как val

1

2

3

case class Complex(re: Double, im: Double)

  ...

}

Теперь сравнение на равенство работает, как и ожидалось:

1

2

scala> i == Complex(0, 1)

res6: Boolean = true

Но наиболее важной возможностью case-классов является то, что они могут использоваться в сопоставлении с образцом , еще одной уникальной и мощной функцией Scala. Чтобы проиллюстрировать это, давайте рассмотрим следующую реализацию toString :

1

2

3

4

5

6

7

8

9

override def toString() =

    this match {

      case Complex.i => "i"

      case Complex(re, 0) => re.toString

      case Complex(0, im) => im.toString + "*i"

      case _ => asString

    }

  private def asString =

    re + (if (im < 0) "-" + -im else "+" + im) + "*i"

Приведенный выше код сопоставляет this с несколькими шаблонами, представляющими константу i , действительное число, чисто мнимое число и все остальное. Хотя это может быть написано и без сопоставления с образцом, этот способ короче и проще для понимания. Сопоставление с образцом становится действительно неоценимым, если вам нужно обрабатывать сложные деревья объектов, поскольку оно предоставляет гораздо более элегантную и лаконичную альтернативу шаблону проектирования Visitor, обычно используемому в таких случаях.

Заворачивать

Окончательная версия нашего класса Complex выглядит следующим образом:

01

02

03

04

05

06

07

08

09

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

import scala.math._

 

case class Complex(re: Double, im: Double) extends Ordered[Complex] {

  private val modulus = sqrt(pow(re, 2) + pow(im, 2))

 

  

  def this(re: Double) = this(re, 0)

 

  

  def unary_+ = this

  def unary_- = new Complex(-re, -im)

  def unary_~ = new Complex(re, -im)

  def unary_! = modulus

 

  

  def compare(that: Complex) = !this compare !that

 

  

  def +(c: Complex) = new Complex(re + c.re, im + c.im)

  def -(c: Complex) = this + -c

  def *(c: Complex) =

    new Complex(re * c.re - im * c.im, im * c.re + re * c.im)

  def /(c: Complex) = {

    require(c.re != 0 || c.im != 0)

    val d = pow(c.re, 2) + pow(c.im, 2)

    new Complex((re * c.re + im * c.im) / d, (im * c.re - re * c.im) / d)

  }

 

  

  override def toString() =

    this match {

      case Complex.i => "i"

      case Complex(re, 0) => re.toString

      case Complex(0, im) => im.toString + "*i"

      case _ => asString

    }

  private def asString =

    re + (if (im < 0) "-" + -im else "+" + im) + "*i" 

}

 

object Complex {

  

  val i = new Complex(0, 1)

 

  

  def apply(re: Double) = new Complex(re)

 

  

  implicit def fromDouble(d: Double) = new Complex(d)

  implicit def fromFloat(f: Float) = new Complex(f)

  implicit def fromLong(l: Long) = new Complex(l)

  implicit def fromInt(i: Int) = new Complex(i)

  implicit def fromShort(s: Short) = new Complex(s)

}

 

import Complex._

С этой удивительно короткой и элегантной реализацией мы можем сделать все, что описано выше, и еще немного:

  • создавать экземпляры с помощью Complex(...)
  • получить модуль с !x и сопряженный с ~x
  • выполнять арифметические операции с обычными операторами +, -, * и /
  • свободно смешивать сложные, действительные и целые числа в арифметических выражениях
  • сравнить на равенство с == и! =
  • сравнить на основе модулей с <, <=,> и> =
  • получить наиболее естественное представление строки

Если вы склонны к некоторым экспериментам, я бы посоветовал вам вставить приведенный выше код в интерпретатор Scala (используя :paste сначала :paste ) и поэкспериментировать с этими возможностями, чтобы почувствовать себя лучше.

Вывод

Многие считают Скала довольно сложным языком. Возможно, именно поэтому он так подходит для комплексных чисел … Если не считать блин, где некоторые люди видят сложность, я вижу непревзойденную элегантность и мощь. Я надеюсь, что этот пост хорошо это проиллюстрировал. Я сам все еще изучаю Scala и далеко не эксперт. Знаете ли вы о лучших способах реализации вышеуказанных возможностей? Я хотел бы услышать об этом.

Ссылка: Комплексные числа в Scala от нашего партнера JCG Стояна Рачева в блоге Стояна Рачева .

Операции над комплексными числами / Хабр

Здравствуй, %username%!
Я получил довольно много отзывов о первой части и постарался все их учесть.
В первой части я писал о сложении, вычитании, умножении и делении комплексных чисел.
Если не знаешь это — скорей беги читать первую часть 🙂
Статья оформлена в виде шпарлагки, истории здесь крайне мало, в основном формулы.
Приятного чтения!

Итак, перейдем к более интересным и чуть более сложным операциям.
Я расскажу про показательную форму комлексного числа,
возведение в степень, квадратный корень, модуль, а также про синус и
косинус комплексного аргумента.
Думаю, начать стоит с модуля комплексного числа.
Комплексное число можно представить на оси координат.
По x будут расположены вещественные числа, а по y мнимые.
Это называется комплексная плоскость. Любое комплексное число, например


очевидно можно представить как радиус-вектор:

Формула расчета модуля будет выглядить так:


Получается, что модуль комплексного числа z будет равен 10.
В прошлой части я рассказал про две формы записи комплексного числа:
алгебраическую и геометрическую. Есть еще показательная форма записи:


Здесь r — это модуль комплексного числа,
а φ — это arctg(y/x), если x>0
Если x0 то


Если x


Есть замечательная формула Муавра, которая позволяет возвести комплексное число в
целую степень. Она была открыта французким математиком Абрахом де Муавром в 1707 году.
Выглядит она вот так:


В результате можем возвести число z в степень a:


Если Ваше комплексное число записано в показательном виде, то
можно использовать формулу:


Теперь, зная как находится модуль комплексного числа и формулу Муавра, можем найти
n корень из комплексного числа:


Здесь k это числа от 0 до n-1
Из этого можно сделать вывод, что существует ровно n различных корней n-ой
степени из комплексного числа.
Перейдем к синусу и косинусу.
Расчитать их нам поможет знаменитая формула Эйлера:


Кстати, еще существует тождество Эйлера, которое является частным
случаем формулы Эйлера при x=π:


Получаем формулы для вычисления синуса и косинуса:


Под конец статьи нельзя не упомянуть практическое применение комплексных
чисел, чтобы не возникало вопроса

сдались эти комплексные числа?
Ответ: в некоторых областях науки без них никак.
В физике в квантовой механике есть такое понятие как волновая функция, которая сама по себе комплекснозначна.
В электротехнике комплексные числа нашли себя в качестве удобной замены дифурам, которые неизбежно возникают при решении задач с линейными цепями переменного тока.
В теореме Жуковского (подъемная сила крыла) тоже используются комплексные числа.
А еще в биологии, медицине, экономике и еще много где.
Надеюсь, теперь вы умеете оперировать комплексными числами и сможете
применять их на практике.
Если что-то в статье непонятно — пишите в комментариях, отвечу.

Класс для работы с комплексными числами

Реализовать средствами языка CPP класс для работы с комплексными числами. Включить выполнение основных математических операций: сложение, вычитание, умножение, деление. Привести пример работы с классом.

Реализация класса для работы с комплексными числами включает:

  • конструктор по-умолчанию
  • конструктор копирования
  • конструктор, реализизуюций пользовательскую инициализацию
  • деструктор
  • четыре базовые математические операции (+,-,*,/)
  • перегрузку оператора присваивания
  • перегрузку операторов ввода-вывода (>>, <<) в виде friend-функций
  • функцию, возвращающую модуль (абсолютное значение) комплексного числа
    // Complex.cpp: определяет точку входа для консольного приложения.
    //
     
    #include <iostream.h>
    #include <conio.h>
    #include <math.h>
     
    class Complex // класс комплексных чисел
    {
       double re, im; // целая и мнимая части
     
    // создаем конструкторы   
    public:
     
       Complex() {};
     
       Complex (double r) // конструктор по умолчанию
       {
          re = r; 
    	  im = 0;
       }
     
       Complex (double r, double i) // конструктор по умолчанию
       {
          re = r; 
    	  im = i;
       } 
     
       Complex (Complex &c) // конструктор копирования
       {
          re = c.re; 
    	  im = c.im;
       }
     
       ~Complex() {}
     
       float abs() // Модуль комплексного числа
       {
          return sqrt(re * re - im * im);
       }     
     
       Complex & operator = (Complex &c) // перегрузка оператора присваивания
       {
          re = c.re;
    	  im = c.im;
     
    	  return (*this);
       }
     
       Complex Complex::operator + (Complex &c) // перегрузка оператора сложения
       {
    	  Complex temp;
     
    	  temp.re = re + c.re;
    	  temp.im = im + c.re;
     
    	  return temp;
       }
     
       Complex Complex::operator - (Complex &c) // перегрузка оператора вычитания
       {
    	  Complex temp;
     
    	  temp.re = re - c.re;
    	  temp.im = im - c.re;
     
    	  return temp;
       }
     
       Complex Complex::operator * (Complex &c) // перегрузка оператора умножения
       {
    	  Complex temp;
     
    	  temp.re = re*c.re;
    	  temp.im = re*c.im;
     
    	  return temp;
       }
     
       Complex Complex::operator / (Complex &c) // перегрузка оператора деления
       {
    	  Complex temp;
     
    	  double r = c.re * c.re + c.im * c.im;
    	  temp.re = (re * c.re + im * c.im) / r;
    	  temp.re = (im * c.re - re * c.im) / r;
     
    	  return temp;
       }   
     
       friend ostream &operator<<(ostream &, Complex &); // перегрузка оператора <<
       friend istream &operator>>(istream &, Complex &); // перегрузка оператора >>
     
    };
     
    ostream &operator<<(ostream &out, complex &c)
    {
       out << "(" << c.re << ") + I (" << c.im << "\n";
     
       return out;
    }
     
    istream &operator>>(istream &in, Complex &c)
    {
       in >> c.re >> c.im;
     
       return in;
    }
     
    int main()
    {
        Complex value1(5,2);
        Complex value2(3,-3);
     
        cout << value1 << " " << value2 << endl;
     
        cout << value1 + value2 << endl;
     
        cout << value1 - value2 << endl;
     
        cout << value1 * value2 << endl;
     
        cout << value1 / value2 << endl;    
     
        value1 = value2;
     
        cout << value1 << " = " << value2 << endl;
     
        return 0;
    }
  • Ключевые слова: 

    класс для работы с комплексными числами, комплексные числа
    ВложениеРазмер
    Complex.zip874 байта

    Комплексные числа Python — complex и операции с ними

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

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

    • Мы можем напрямую использовать синтаксис a + bj для создания комплексного числа.
    >>> a = 4 + 3j
    >>> print(a)
    (4+3j)
    >>> print(type(a))
    <class 'complex'>
    
    • Мы также можем использовать complex класс для создания комплексного числа
    >>> a = complex(4, 3)
    >>> print(type(a))
    <class 'complex'>
    >>> 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() для получения конъюгата.

    >>> a
    (4 + 3j)
    >>> a.conjugate()
    (4-3j)
    

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

    Подобно действительным числам, комплексные числа также можно складывать, вычитать, умножать и делить. Давайте посмотрим, как мы могли бы это сделать в 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 "<stdin>", line 1, in <module>
    TypeError: '<' not supported between instances of 'complex' and 'complex'
    

    Фаза (аргумент)

    Мы можем представить комплексное число как вектор, состоящий из двух компонентов на плоскости, состоящей из 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.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
    

    операции в показательном виде, примеры

    Комплексные числа — определение и основные понятия

    Обычные числа представляют собой множество действительных чисел, для обозначения которых используют букву R. Каждое число из множества можно отметить на числовой прямой.

     

    К действительным числам носят:

    • целые числа;
    • дроби;
    • иррациональные числа.

    Каждая точка на числовой прямой характеризуется некоторым действительным числом. Комплексное число является двумерным числом и записано в виде:

    z = a + bi

    Где а и b являются действительными числами, i представляет собой так называемую мнимую единицу.

    Уравнение можно мысленно поделить на несколько частей:

    • a — действительная часть (Re z) комплексного числа z;
    • b — мнимая часть (Im z) комплексного числа z.

    Следует отметить, что a + bi является единым числом, а не сложением. Места действительной и мнимой частей в уравнении можно менять:

    z = bi + a

    Мнимую единицу допускается переставлять:

    z = a + ib

    При таких операциях смысл выражения остается прежним. Однако стандартная запись комплексного числа имеет такой вид:

    z = a + bi

    Определение

    Комплексным числом называют выражение a + bi, в котором а и b являются действительными числами, i представляет собой мнимую единицу, символ, квадрат которого равен -1, то есть i2=-1. Число а представляет собой действительную часть, b — мнимую часть комплексного числа z = a + bi. Если b = 0, то вместо a + 0i записывают a. Действительные числа являются частным случаем комплексных чисел.

    Данное утверждение можно привести в виде геометрической интерпретации. Тогда комплексные числа изображают на комплексной плоскости.

     

    С помощью R обозначаю множество действительных чисел. В случае, когда требуется обозначить множество комплексных чисел, принято использовать букву С. Наличие буквы С на чертеже говорит о том, что на нем представлена комплексная плоскость. Данная плоскость включает две оси:

    Re z — является действительной осью;

    Im z — представляет собой мнимую ось.

    Правила оформления такого графика практически не отличаются от требований к чертежам для декартовой системы координат. По осям задают масштаб и отмечают:

    • ноль;
    • единицу для действительной оси;
    • мнимую единицу i для мнимо оси.

    С помощью комплексной плоскости можно построить заданные комплексные числа:

    \(z_{1}=0\)

    \(z_{2}=-3\)

    \(z_{3}=2\)

    \(z_{4}=i\)

    \(z_{5}=-\sqrt{3}i\)

    \(z_{6}=4i\)

    \(z_{7}=2+3i\)

    \(z_{8}=-4+i\)

    \(z_{9}=-3-3i\)

    \(z_{5}=-\sqrt{2}-i\)

     

    Можно рассмотреть следующие комплексные числа:

    \(z_{1}=0\)

    \(z_{2}=-3\)

    \(z_{3}=2\)

    Действительные числа являются частным случаем комплексных чисел. Действительная ось Re z обозначает в точности множество действительных чисел R, то есть на данной оси расположены все числа с обычными свойствами. Можно сформулировать справедливое утверждение: множество действительных чисел R представляет собой подмножество множества комплексных чисел С.

    Данные числа являются комплексными числами, мнимая часть которых нулевая:

    \(z_{1}=0\)

    \(z_{2}=-3\)

    \(z_{3}=2\)

    Мнимые числа с нулевой действительностью, которые расположены на мнимой оси Im z:

    \(z_{4}=i\)

    \(z_{5}=-\sqrt{3}i\)

    \(z_{6}=4i\)

    Есть ряд чисел с ненулевыми действительной и мнимой частью:

    \(z_{7}=2+3i\)

    \(z_{8}=-4+i\)

    \(z_{9}=-3-3i\)

    \(z_{5}=-\sqrt{2}-i\)

    Для их обозначения используют точки на комплексной плоскости. К таким точкам проводят радиус-векторы из начала координат. Радиус-векторы не принято чертить к числам, которые расположены на осях и сливаются с ними.

    Формы, как записываются

    Алгебраическая запись комплексного числа имеет такой вид:

    z = a + bi.{2}}\)

    Данная величина представляет собой модуль комплексного числа z = a + bi и имеет такое решение:

    \(\left|z \right|\)

    Вектор и положительное направление оси абсцисс образуют угол, отсчитанный против часовой стрелки. Данный угол называют аргументом комплексного числа z и обозначают, как Arg z. Аргумент имеет неоднозначное определение с точностью до прибавления величины, которая кратна 2π радиан. При повороте на такой угол вокруг начала координат вектор не изменяется.

    В том случае, когда вектор длиной r с положительным направлением оси абсцисс составляет угол ϕ, его координаты будут следующими:

    \(\left(r*\cos \varphi ;r*\sin \varphi \right)\)

    Таким образом, получают тригонометрическую форму записи комплексного числа:

    \(z=\left|z \right|*\left(\cos (Arg z)+i\sin (Arg z) \right)\)

    Из-за более простого вида вкладок комплексные числа, как правило, представляют в тригонометрической форме.

    Существует показательная форма для записи комплексных чисел.{2}}i\)

    Пример:

    \(\frac{3+4i}{1+2i}=\frac{11}{5}-\frac{2}{5}i\)

    Сложение комплексных чисел

    Ели требуется сложить пару комплексных чисел:

    \(z_{1}=1+3i\)

    \(z_{2}=4-5i\)

    Сначала нужно найти сумму их действительных и мнимых частей:

    \(z_{1}+ z_{2}=1+3i+4-5i=5-2i\)

    Таким образом, сумма какого-либо количества слагаемых определяется путем сложения действительных частей и сложением мнимых частей. В случае комплексных чисел справедливо правило первого класса, которое гласит, что от перестановки слагаемых их сумма остается прежней:

    \(z_{1}+ z_{2}= z_{2}+ z_{1}\)

    Вычитание комплексных чисел

    Разность комплексных чисел:

    \(z_{1}- z_{2}\)

    \(z_{2}- z_{1}\)

    При условии, что:

    \(z_{1}=-2+i\)

    \(z_{2}=\sqrt{3}+5i\)

    Действие аналогично сложению. Разница заключается в необходимости выделения скобками вычитаемого числа. Далее следует раскрыть скобки и изменить знак:

    \(z_{1}- z_{2}=-2+i-(\sqrt{3}+5i )=-2+i-\sqrt{3}-5i =-2-\sqrt{3}-4i \)

    Полученное в результате число обладает двумя частями.{2}}\)

    Для поиска аргумента комплексного числа требуется использовать определенную формулу для конкретного случая. Уравнение подбирается, исходя из положения числа z = a + bi в координатной четверти. Существует всего три таких варианта:

    • а > 0, число соответствует первой и четвертой координатной четверти, либо правой полуплоскости, формула для нахождения аргумента \(Arg z=arctg\frac{b}{a}\);
    • a < 0, b > 0, число соответствует второй координатной четверти, формула для расчета аргумента\(Arg z=\pi +arctg\frac{b}{a}\);
    • a < 0, b < 0, число соответствует третьей координатной четверти, найти аргумент можно по формуле \(Arg z=-\pi +arctg\frac{b}{a}\).

    Извлечение корня из комплексных чисел

    Комплексные числа в тригонометрической форме умножают таким образом:

    z_{1}*z_{2}=\left|z_{1} \right|*\left|z_{2} \right|*(\cos (Arg z_{1}+Arg z_{2})+i\sin (Arg z_{1}+Arg z_{2}))2

    При умножении пары комплексных чисел их модули перемножаются, а аргументы складываются.{i(\varphi _{1}+\varphi _{2})}\)

    Библиотека комплексных чисел Java / загрузка пакета

    ФИО

    Телефонный номер

    Название работы

    Промышленность

    Компания

    Размер компании Размер компании: 1 — 2526 — 99100 — 499500 — 9991,000 — 4,9995,000 — 9,99910,000 — 19,99920,000 или более

    Получайте уведомления об обновлениях для этого проекта.Получите информационный бюллетень SourceForge. Получайте информационные бюллетени и уведомления с новостями сайта, специальными предложениями и эксклюзивными скидками на ИТ-продукты и услуги.

    Да, также присылайте мне специальные предложения о продуктах и ​​услугах, касающихся:
    Программное обеспечение для бизнеса Программное обеспечение с открытым исходным кодом Информационные технологии Программирование Оборудование

    Вы можете связаться со мной через:
    Электронная почта (обязательно) Телефон смс

    Я согласен получать эти сообщения от SourceForge.сеть. Я понимаю, что могу отозвать свое согласие в любое время. Пожалуйста, обратитесь к нашим Условиям использования и Политике конфиденциальности или свяжитесь с нами для получения более подробной информации. Я согласен получать эти сообщения от SourceForge.net указанными выше способами. Я понимаю, что могу отозвать свое согласие в любое время. Пожалуйста, обратитесь к нашим Условиям использования и Политике конфиденциальности или свяжитесь с нами для получения более подробной информации.

    Для этой формы требуется JavaScript.

    Подписывайся

    Кажется, у вас отключен CSS.Пожалуйста, не заполняйте это поле.

    Кажется, у вас отключен CSS. Пожалуйста, не заполняйте это поле.

    java — выполнение арифметических действий с комплексными числами

    DaniWeb Войти Зарегистрироваться
    • Читать
    • Способствовать

    Поиск Поиск

    Навигация

    Поиск Поиск

    • Категории форума
    • ноутбук Аппаратное обеспечение
    • код Программирование
    • live_tv Цифровых средств массовой информации
    • local_cafe Общественный центр
    • Последние материалы
    • Новейшие темы
    • Последние темы
    • форум Последние сообщения
    • Лучшие теги
    • Лента тем
    • Социальные сети
    • Лучшие участники
    • DaniWeb Премиум
    • Архив новостей
    • Правила сообщества
    • Подключение API
    • Форум API Docs
    • DaniWeb Ads
    • Условия использования
    • Политика конфиденциальности
    • FAQ
    • О нас
    • Свяжитесь с нами

    © 2020 DaniWeb® LLC

    1. Дом
    2. Форум программирования
    3. Форум разработчиков программного обеспечения
    4. Обсуждение / Вопрос
    Эрикуолтер 0

    Что такое комплексные числа? | Живая наука

    Комплексные числа — это числа, состоящие из двух частей — действительного числа и мнимого числа.Комплексные числа являются строительными блоками более сложной математики, такой как алгебра. Их можно применить ко многим аспектам реальной жизни, особенно в электронике и электромагнетизме.

    Стандартный формат для комплексных чисел — a + bi , с действительным числом первым и последним мнимым числом. Поскольку любая часть может быть равна 0, технически любое действительное или мнимое число может считаться комплексным числом. Сложный не значит сложный; это означает, что два типа чисел объединяются, образуя комплекс, например жилой комплекс — группу зданий, соединенных вместе.

    Действительные числа — это осязаемые значения, которые могут быть нанесены на горизонтальную числовую линию, например дроби, целые числа или любое счетное число, которое вы можете придумать. Мнимые числа — это абстрактные понятия, которые используются, когда вам нужен квадратный корень из отрицательного числа.

    Сложение и умножение комплексных чисел

    Поскольку комплексное число является биномом — числовым выражением с двумя членами — арифметика обычно выполняется так же, как и любое биномиальное, путем комбинирования одинаковых терминов и упрощения.Например:

    (3 + 2i) + (4 — 4i)

    (3 + 4) = 7

    (2i — 4i) = -2i

    Результат: 7-2i .

    Для умножения вы используете метод FOIL для полиномиального умножения: умножьте первое, умножьте внешнее, умножьте внутреннее, умножьте последнее, а затем сложите. Например:

    (3 — 2i) (5 + 3i) =

    (3) (5) + (3) (3i) + (-2i) (5) + (-2i) (3i) =

    15 + 9i + -10i + -6i 2 =

    15 — i — 6 (-1) =

    21 — i

    Причина того, что i2 упрощается до (-1), заключается в том, что i является квадратный корень из -1.

    Деление комплексных чисел

    Однако деление становится более сложным и требует использования конъюгатов. Комплексные конъюгаты — это пары комплексных чисел с разными знаками, например (a + bi) и (a — bi) . Умножение комплексных конъюгатов приводит к сокращению среднего члена. Например:

    (a + bi) (a — bi) = a 2 — abi + abi — (bi) 2

    Это упрощается до 2 — b 2 (i 2 ) = a 2 — b 2 (-1)

    Конечный результат: a 2 + b 2

    При делении комплексных чисел определите сопряжение знаменателя и умножьте числитель и знаменатель на конъюгат.Например,

    (5 + 2i) ÷ (7 + 4i)

    Сопряжение 7 + 4i равно 7 — 4i. Итак, умножьте числитель и знаменатель на сопряжение:

    (5 + 2i) (7 — 4i) ÷ (7 + 4i) (7 — 4i) =

    (35 + 14i — 20i — 8i 2 ) ÷ (49 — 28i + 28i — 16i 2 ) =

    (35 — 6i + 8) ÷ (49 + 16) =

    (43 — 6i) ÷ 65

    Абсолютное значение комплексных чисел

    Абсолютное значение числа считается его расстояние от нуля на числовой прямой.Поскольку комплексные числа включают в себя мнимые числа, они не могут быть нанесены на линию действительных чисел. Однако они могут быть измерены от нуля на плоскости комплексных чисел, которая включает ось x (для действительного числа) и ось y (для мнимого числа).

    Использование комплексных чисел

    Комплексные числа могут использоваться для решения квадратичных вычислений нулей. Квадратичная формула решает ax2 + bx + c = 0 для значений x. Если формула дает отрицательное значение квадратного корня, для упрощения нуля можно использовать комплексные числа.

    Комплексные числа используются в электронике и электромагнетизме. Одно комплексное число объединяет две реальные величины, что упрощает работу с числами. Например, в электронике состояние элемента схемы определяется напряжением (V) и током (I). Элементы схемы также могут иметь емкость (c) и индуктивность (L), которые описывают тенденцию схемы противостоять изменениям V и I. Вместо того, чтобы описывать состояние элемента схемы с помощью V и I, его можно описать как z = V + II .Затем законы электричества могут быть выражены с помощью сложения и умножения сложных чисел.

    Как упоминалось ранее, это также применимо к электромагнетизму. Вместо того, чтобы описываться как напряженность электрического поля и напряженность магнитного поля, вы можете создать комплексное число, в котором электрические и магнитные составляющие являются действительными и мнимыми числами.

    Дополнительная литература:

    Калькулятор комплексных чисел

    Математика — это развлечение: комплексные числа

    Math Warehouse: комплексные числа

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

    Комплексное число — это пара двух действительных чисел (x, y).
    Мы можем думать о комплексных числах как о точках на координатной плоскости.
    Пусть z будет комплексным числом,
    то есть z = (x, y)
    x — это действительная часть z, а y — мнимая часть z.

    Комплексные числа обозначаются $ \ mathbb {C} $
    Множество действительных чисел является его подмножеством. Действительные числа, записанные как комплексные: $ (x, 0), \ \ x \ in \ mathbb {R} $.

    Каждое комплексное число (x, y) имеет соответствующую точку на координатной плоскости. Мы не можем записать точку A> B, из-за этого мы не можем напишите для двух комплексных чисел (x 1 , y 1 )> (x 2 , y 2 )
    Комплексные числа не имеют порядка.2} \ big) $

    Другой способ записать комплексное число z = (x, y): z = a + bi,
    a — действительная часть z,
    b — мнимая часть и
    i мнимая единица. я 2 = -1, я = √-1.

    Каждое комплексное число z = a + bi имеет комплексное сопряжение z = a — bi. {4n + 1} = i $ Кратное 4 + 1
    $ {4n + 1, \ n \ in \ mathbb {Z}} = {1; 5; 9.{4n + 2} = -1 $ Кратное 4 + 2
    $ {4n + 2, \ n \ in \ mathbb {Z}} = {2; 6; 10 …

    Комплексные числа — Викиверситет

    Содержание

    • 1 Комплексный номер
    • 2 Комплексно-сопряженное число
    • 3 математических операции
      • 3.1 Операция с двумя разными комплексными числами
      • 3.2 Операция над комплексными числами и их сопряженными
      • 3,3 В полярной форме
      • 3,4 Комплексная мощность
        • 3.4.1 Формула Эйлера
        • 3.4.2 Формула де Муавра
      • 3.5 Трансцендентные функции
    • 4 Резюме
    • 5 Ссылки
    • 6 См. Также

    Набор комплексных чисел обозначается C {\ displaystyle \ mathbb {C}}. Комплексное число z∈C {\ displaystyle z \ in \ mathbb {C}} может быть записано в декартовых координатах как

    z = a + ib {\ displaystyle z = a + ib}

    , где a, b∈R {\ displaystyle a, b \ in \ mathbb {R}}.a {\ displaystyle a} называется «действительной частью» z {\ displaystyle z}, а b {\ displaystyle b} называется «мнимой частью» z {\ displaystyle z}. Их также можно записать в тригонометрической полярной форме, как

    z знак равно r (cos⁡ (ϑ) + isin⁡ (ϑ)) {\ displaystyle z = r (\ cos (\ vartheta) + i \ sin (\ vartheta))}

    где r∈R {\ displaystyle r \ in \ mathbb {R}} — это «величина» z {\ displaystyle z}, а ϑ∈ [−π, π) {\ displaystyle \ vartheta \ in [- \ pi, \ pi)} называется «аргумент» z {\ displaystyle z}.{-i \ vartheta} = r (\ cos (\ vartheta) -i \ sin (\ vartheta)).}

    Операция с 2 различными комплексными числами [править | править источник]

    Дополнение (a + ib) + (c + id) = (a + c) + i (b + d) {\ displaystyle (a + ib) + (c + id) = (a + c) + i (b + г)}
    Вычитание (a + ib) — (c + id) = (a − c) + i (b − d) {\ displaystyle (a + ib) — (c + id) = (a-c) + i (b-d)}
    Умножение (a + ib) ⋅ (c + id) = (ac − bd) + i (ad + bc) {\ displaystyle (a + ib) \ cdot (c + id) = (ac-bd) + i (ad + bc)}
    Отдел (a + ib) (c + id) = (a + ib) (c + id) (c − id) (c − id) = (ac + bd) + i (bc − ad) c2 + d2 {\ displaystyle {\ frac {(a + ib)} {(c + id)}} = {\ frac {(a + ib)} {(c + id)}} {\ frac {(c-id)} {( c-id)}} = {\ frac {(ac + bd) + i (bc-ad)} {c ^ {2} + d ^ {2}}}}

    Операция над комплексными числами и их сопряженными [править | править источник]

    Дополнение (a + ib) + (a − ib) = 2a {\ displaystyle (a + ib) + (a-ib) = 2a}
    Вычитание (a + ib) — (a − ib) = 2ib {\ displaystyle (a + ib) — (a-ib) = 2ib}
    Умножение (a + ib) (a − ib) = a2 + iab − iab + b2 = a2 + b2 {\ displaystyle (a + ib) (a-ib) = a ^ {2} + iab-iab + b ^ { 2} = а ^ {2} + Ь ^ {2}}
    Отдел (a + ib) (a − ib) = (a + ib) (a − ib) (a + ib) (a + ib) = (a + ib) 2a2 + b2 {\ displaystyle {\ frac {(a + ib)} {(a-ib)}} = {\ frac {(a + ib)} {(a-ib)}} {\ frac {(a + ib)} {(a + ib)}} = {\ frac {(a + ib) ^ {2}} {a ^ {2} + b ^ {2}}}}

    В полярной форме [править | править источник]

    Операция над комплексным числом и его сопряженным

    z⋅z ∗ = | z | ∠eiϑ⋅ | z | ∠e − iϑ = | z | 2ei (ϑ − ϑ) = | z | 2e0 = | z | 2 {\ displaystyle z \ cdot z ^ {* } = | z | \ angle e ^ {i \ vartheta} \ cdot | z | \ angle e ^ {- i \ vartheta} = | z | ^ {2} e ^ {i (\ vartheta — \ vartheta)} = | z | ^ {2} e ^ {0} = | z | ^ {2}}
    zz ∗ = | z | eiϑ | z | e − iϑ = e2iϑ {\ displaystyle {\ frac {z} {z ^ {*}}} = {\ frac {| z | e ^ {i \ vartheta}} { | z | e ^ {- i \ vartheta}}} = e ^ {2i \ vartheta}}

    Операция с 2 различными комплексными числами

    z1⋅z2 = | z1 | eiϑ1⋅ | z1 | eiϑ2 = | z1z2 | ei (ϑ1 + ϑ2) {\ displaystyle z_ {1} \ cdot z_ {2} = | z_ {1} | e ^ {i \ vartheta _ {1}} \ cdot | z_ {1} | e ^ {i \ vartheta _ {2}} = | z_ {1} z_ {2} | e ^ {i (\ vartheta _ {1} + \ vartheta _ {2})}}
    z1z2 = | z1 | eiϑ1 | z2 | eiϑ2 = | z1z2 | ei (ϑ1

    Комплексные числа: Введение

    Комплекс Номера: Введение (стр. 1 из 3)

    Разделы: Введение, Операции с комплексами, Квадратичная формула


    До сих пор вы были сказал, что ты не можешь взять площадь корень негатива число.Это потому, что у вас не было чисел, которые были бы отрицательными после того, как вы возводил их в квадрат (так что вы не могли «вернуться назад», взяв квадрат корень). После возведения в квадрат все числа были положительными. Так ты не мог очень хорошо извлеките квадратный корень из отрицательного и ожидайте найти что-нибудь разумное.

    Теперь вы можете взять квадратный корень из отрицательного числа, но это предполагает использование нового числа сделать это. Это новое число было изобретено (обнаружено?) Примерно во времена Реформация.В то время никто не верил, что любой «реальный мир» будет найдено применение этому новому числу, кроме упрощения вычислений участвовал в решении определенных уравнений, поэтому новое число рассматривалось как выдуманное число, придуманное для удобства.

    (Но тогда, когда вы думаете об этом, разве все номеров не изобретения? Это не похоже на числа растут на деревьях! Они живут в наших головах. Мы сделали их все up! Зачем не придумывать новый, раз уж он работает нормально с тем, что у нас уже есть?)

    Во всяком случае, этот новый номер назывался « и «, означает «воображаемое», потому что «все знали» что и не были «настоящими».(Вот почему вы не могли извлечь квадратный корень отрицательного числа раньше: у вас были только «настоящие» числа; что есть числа без « i » в них.) Воображаемое определяется как:

    Тогда:

    Теперь вы можете подумать, что умеют:

    Но это не делает смысл! У вас уже есть , у вас есть двух чисел, равных 1; а именно –1 и +1.А и уже равняются –1. Поэтому неразумно, что i также будет равняться 1. Это указывает на важную деталь: имея дело с воображаемым, вы получить что-то (способность работать с отрицаниями внутри квадратных корней), но вы тоже что-то теряете (некоторая гибкость и удобные правила вы имели обыкновение иметь дело с квадратными корнями).В частности, ВЫ ДОЛЖНЫ ВСЕГДА ДЕЛАЙТЕ ЧАСТЬ i ПЕРВЫЙ!


    • Упростить sqrt (–9) . Авторские права © Элизабет Стапель 2000-2011 Все права защищены

    (Предупреждение: шаг, который проходит через третий знак «равно» — «», не «». i — это за пределами корня .)


    В своих вычислениях вы будет работать с i так же, как и с x , за исключением того факта, что x 2 — это всего лишь x 2 , но i 2 равно –1:

    • Умножить и Упростить (3 i ) (4 i ).
    • Умножить и Упростить ( i ) (2 i ) (- 3 i ).

      ( i ) (2 i ) (- 3 i ) = (2 · –3) ( i · ​​ i · ​​ i ) = (–6) ( i 2 · i )

    Обратите внимание на последнюю проблему. В нем вы можете видеть, что потому что i 2 = –1.Продолжая, получаем:

    Этот образец сил, знаки, единицы, и и это цикл:

    Другими словами, чтобы вычислить любая большая мощность и , вы можете преобразовать его в более низкую степень, взяв ближайшее кратное 4, которое не больше экспоненты, и вычтя это кратное из показатель степени.Например, распространенный вопрос с подвохом на тестах — это что-то по строкам «Упростить и 99 «, идея состоит в том, что вы попытаетесь умножить на девяносто девять раз, и у вас закончится время, а учителя получат Хорошенько посмеяться за свой счет в холле факультета. Вот как ярлык работ:

    То есть i 99 = i 3 , потому что вы можете просто отрезать i 96 .(Девяносто шесть кратно четырем, поэтому i 96 равно 1, которые вы можете игнорировать.) Другими словами, вы можете разделить показатель степени на 4 (используя длинное деление), отбросить ответ и использовать только остаток. Это даст вам часть экспоненты, которая вам нужна. Вот еще несколько примеров:

      i 64 002 = i 64 000 + 2 = i 4 · 16 000 + 2 = i 2 = –1

    Теперь вы видели, как воображаемые Работа; пора переходить к комплексным числам.»Сложные числа состоит из двух частей: «реальная» часть (любое «реальное» число с которой вы привыкли иметь дело) и «воображаемой» частью (являющейся любое число с « i » в этом).

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *

    Theme: Overlay by Kaira Extra Text
    Cape Town, South Africa