/* 

Struktúrák

- felhasználó által definiált összetett adattípusok

- az eddig használt típusok:
    - egyszerűek (primitív típusok): int, bool, char, float, double
    - tömbök, amik bizonyos (egyszerű) típusú elemekből állnak

- egy struktúrában lehet különböző típusú tagok (ezeket adattagoknak
vagy mezőknek szokás hívni), mindegyikre egy névvel hivatkozunk

Szintaxis:

    struct TipusNev
    {
        tipus1 nev1;
        tipus2 nev2;
        ...
    } globális változók nevei ;

    int main()
    {
        TipusNev x;
        x.nev1 = ...;
        cout << x.nev2;

        return 0;
    }

*/

/*
    Egy struktúraváltozó adattagjait a "." operátorral tudjuk elérni
    (név szerint).

    Pl.
*/
/*
#include <iostream>
#include <cstring>
using namespace std;

struct Alkalmazott
{
    char nev[100];
    int szuletesi_ev;
};

void kiir(Alkalmazott a) // másolódik
{
    cout << a.nev << ", aki "
         << a.szuletesi_ev
         << ". evben szuletett\n";
}

int main()
{
    Alkalmazott a1, a2;

    a1.szuletesi_ev = 1990;
    strcpy(a1.nev, "Nagy Kevin");

    a2.szuletesi_ev = 2000;
    strcpy(a2.nev, "Kis Vince");

    kiir(a1);
    kiir(a2);
    cout << endl;

    a2 = a1; // másolódik az egész
    a2.szuletesi_ev++;

    kiir(a1);
    kiir(a2);
    cout << endl;

    return 0;
}
*/

// 2. Pl. komplex számok

#include <iostream>
#include <cmath>
using namespace std;


struct Komplex
{
    double re;
    double im;
};


void kiir(Komplex z)
{
    cout << z.re << " + " << z.im << " i";
    // HF. szépíthető a kiírás (negatívokra)
}


Komplex osszead(Komplex z1, Komplex z2)
{
    Komplex s;

    s.re = z1.re + z2.re;
    s.im = z1.im + z2.im;

    return s;
}


Komplex kivonas(Komplex z1, Komplex z2)
{
    Komplex s;

    s.re = z1.re - z2.re;
    s.im = z1.im - z2.im;

    return s;
}


Komplex szorzas(Komplex z1, Komplex z2)
{
    Komplex s;

    /* (z1.re + z1.im * i) * (z2.re + z2.im * i)
        = z1.re * (z2.re + z2.im * i)  +  z1.im * i * (z2.re + z2.im * i)
        = z1.re * z2.re + z1.re * z2.im * i
          + z1.im * i * z2.re + z1.im * i * z2.im * i
        = (z1.re*z1.re - z1.im*z2.im)  +  (z1.re*z2.im + z1.im*z2.re) * i
    */

    s.re = z1.re*z2.re - z1.im*z2.im;
    s.im = z1.re*z2.im + z1.im*z2.re;

    return s;
}


Komplex konjugalt(Komplex k)
{
    Komplex eredmeny;
    eredmeny.re = k.re;
    eredmeny.im = -k.im;
    return eredmeny;
}


Komplex osztas(Komplex szam, Komplex nev)
{
    Komplex z =
        szorzas(szam, konjugalt(nev));

    double d = nev.re*nev.re + nev.im*nev.im;

    z.re = z.re / d;
    z.im = z.im / d;

    return z;
}


double modulusz(Komplex z)
{
    return sqrt(z.re * z.re + z.im * z.im);
}


int main()
{
    Komplex k1;
    k1.re = 5;
    k1.im = 3;

    kiir(k1);
    cout << endl;

    Komplex k2 = osszead(k1, k1);
    kiir(k2);
    cout << endl;

    // HF. kivonás, szorzás, konjugált, osztás

    cout << modulusz(k1) << endl;

    Komplex k3 = szorzas(k1, k1);
    kiir(k3);
    cout << endl;

    kiir(konjugalt(k3));
    cout << endl;

    cout << "--------------\n";
    Komplex k4 = szorzas(k1,k3);
    kiir(k1); cout << endl;
    kiir(k3); cout << endl;
    kiir(k4); cout << endl;
    kiir(osztas(k4,k1)); cout << endl;

    /* HF (+pont)
        még egy struktúrát definiálni a trig. alaknak, írni két átalakító
        függvényt az alg. és trig. alak között
    */

    return 0;
}