8 Mart 2019 Cuma

std::complex Sınıfı

Kullanmak için şu satır dahil edilir.
#include <complex.h>
std::complex Sınıfı
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.
Şöyle tanımlarız.
vector<complex<double> > v;
Constructor - real + imaginary
Şöyle yaparız
std::vector<std::complex<float>> points{ {4,5}, {30,6}, {20,25} };
Constructor - literal
Şö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
Şöyle yaparız.
class Complex {
  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.

Hiç yorum yok:

Yorum Gönder