std::complex Sınıfı

Giriş
Kullanmak için şu satır dahil edilir.

#include <complex.h>

std::complex Sınıfı
Giriş
Bu sınıf real ve imaginary kısımlardan oluşan bir yapı gibi düşünülebilir.

typedef struct {
  double real;
  double imaginary;};

Gerçek sayılardan kompleks sayılara geçince sıralama (order) kayboluyor. Açıklaması şöyle.

The most important property you loose when moving from real to complex numbers is definitely the notion of an order,

Complex sayının ismini tarihi bir kullanımı var. Ayrıca komplex sayının karesi -1'dir. Açıklaması şöyle.

They're called "numbers" for historical reasons, since the motivation in the development of the complex numbers was solving polynomial equations. They were viewed as natural extensions of the real numbers. It's somehow quite natural and satisfying to say "every polynomial equation can be solved by some (complex) number". Is it more natural to regard i as being a number which, when squared, is equal to −1, or is it more natural to regard i as being some non-number thingamajig which when squared is equal to −1? Clearly the former.

"Higher" number systems, like quaternions, aren't really called numbers very often, for the simple fact that they are not as intimately connected with number theory and analysis in the same way that complex numbers are.

Kompleks sayıları toplamak ve çarpmak mümkün. Açıklaması şöyle.

The two fundamental operations for numbers are "addition" and "multiplication" which obey very nice "laws" of arithmetic. Taking powers is also important. You can do all of those things with complex numbers.

Constructor
Örnek

Şöyle tanımlarız.

vector<complex<double> > v;

Constructor - real + imaginary

Örnek

Şöyle yaparız

std::vector<std::complex<float>> points{ {4,5}, {30,6}, {20,25} };

Constructor - literal

Örnek

Şöyle yaparız

constexpr std::array<std::complex<double>,3> points2{
        {  24.0 + 7.0i, 22.0 + 9.0i, 8.0 + 20.0i }
};

operator + metodu
Formülü şöyledir

Real0 + Real1 , Imaginary0 + Imaginary1 

operator * metodu
(r0 , i0) * (r1 , i1) şöyledir.

public static Complex mul(Complex c0, Complex c1) {
  double r0=c.getRe(), r1=c1.getRe();
  double i0=c.getIm(), i1=c1.getIm();
  return new Complex(r0*r1-i0*i1, r0*i1+r1*i0);
}

_Complex Sınıfı - C Yapısı
Şöyle tanımlarız. 5i gcc extension olur 5 kök -1 demektir.

_Complex x = 4 + 5i;

Kendi Sınıfım
Tanımlama

Şöyle yaparız.

class Complex {
public:
  double r; //real part
  double i; //imaginary part
  ...
};

add metodu

real1 + real2 , imaginary1 + imaginary2 şeklindedir. Şöyle yaparız.

Complex &Complex::add (const Complex &op) { 
  r += op.r; 
  i += op.i;
  return *this;
}

Free Style Metodlar
Neden Free Style Metodlar Var

Açıklaması şöyle

The C++ standard library does not exclusively follow the OO design paradigm.

Free functions, when combined with parameter overloading, play much nicer when you are writing templated code that should work with both class types and primitive types.

For example, suppose I have a list of values (either complex, as std::complex<float>, or real, as float) and I want to compare them on magnitude. Then I can write a comparison function like

Bu kod şöyle olsun

template <class T>
bool magnitude_less(const T& lhs, const T& rhs)
{
  using std::abs;
  return abs(lhs) < abs(rhs);
}

abs metodu std::complex tipinin üye alanı olsaydı bu kod derlenmezdi. Bu yöntemin kaynağı Scott Meyers. Açıklaması şöyle

There is a school of though that prefers "non-member non-friend" functions, and justifies it in terms of improving code cohesion. I believe the original source for the idea is Effective C++ by Scott Meyers.

std::conj metodu

Metodun imzası şöyle. Sayının i kısmını eksi yapar. a + bi sayısı a - bi olur.

template< class T >
complex<T> conj( const complex<T>& z );       (1)     
template< class DoubleOrIngeter >
std::complex<double> conj( DoubleOrInteger z );       (3)     (since C++11)

std::real metodu
std::complex sınıfının real kısmını döner. Şöyle yaparız.

std::real(x);