LV5 - Z2

/*Definirajte imenik nazvan prema vlastitom imenu koji sadrži klasu koja
predstavlja kompleksni broj (ime: Complex). Klasa treba sadržavati
podrazumijevani i parametarski konstruktor, pristupne metode (postavljanje i
dohvaćanje) te preopterećene relacijske operatore (==, !=, <, >, >=, <=, nap.
dovoljno je napisati dva i ostale izvesti preko njih). Kompleksni brojevi se
korištenjem ove klase uspoređuju po modulu. Definirajte novi imenik nazvan po
vlastitom prezimenu koji sadrži klasu koja predstavlja kompleksni broj (ime:
Complex). Klasa treba sadržavati sve kao i prethodna klasa, ali se kompleksni
brojevi uspoređuju najprije po realnom, a zatim po imaginarnom dijelu. U
glavnom dijelu programa stvoriti dva polja kompleksnih brojeva (za svaku klasu
po jedno polje), popuniti ih nasumično generiranim objektima te ih sortirati i
ispisati (oba polja trebaju sadržavati iste kompleksne brojeve). Sortiranje obaviti
funkcijom, koja može biti ili predložak ili preopterećena.*/
#include<iostream>
#include<cmath>
#include<ctime>
using namespace std;

namespace Filip {
    class Complex {
        friend bool operator== (const Complex &c1, const Complex &c2);
        friend bool operator!= (const Complex &c1, const Complex &c2);
        friend bool operator< (const Complex &c1, const Complex &c2);
        friend bool operator> (const Complex &c1, const Complex &c2);
        friend bool operator<= (const Complex &c1, const Complex &c2);
        friend bool operator>= (const Complex &c1, const Complex &c2);
    private:
        float re, im;
    public:
        Complex() : re(0), im(0) {};
        Complex(float _re, float _im) : re(_re), im(_im) {};

        float getRe();
        void setRe(float _re);
        float getIm();
        void setIm(float _im);
    };
}

float Filip::Complex::getRe() {
    return re;
}
void Filip::Complex::setRe(float _re) {
    re = _re;
}
float Filip::Complex::getIm() {
    return im;
}
void Filip::Complex::setIm(float _im) {
    im = _im;
}
bool Filip::operator== (const Complex &c1, const Complex &c2) {
    if ((sqrt(c1.re*c1.re + c1.im*c1.im)) == (sqrt(c2.re*c2.re + c2.im*c2.im)))
        return true;
    return false;
}
bool Filip::operator!= (const Complex &c1, const Complex &c2) {
    return !(c1 == c2);
}
bool Filip::operator< (const Complex &c1, const Complex &c2) {
    if ((sqrt(c1.re*c1.re + c1.im*c1.im)) < (sqrt(c2.re*c2.re + c2.im*c2.im)))
        return true;
    return false;
}
bool Filip::operator> (const Complex &c1, const Complex &c2) {
    return !(c1 < c2);
}
bool Filip::operator<= (const Complex &c1, const Complex &c2) {
    if ((sqrt(c1.re*c1.re + c1.im*c1.im)) <= (sqrt(c2.re*c2.re + c2.im*c2.im)))
        return true;
    return false;
}
bool Filip::operator>= (const Complex &c1, const Complex &c2) {
    if ((sqrt(c1.re*c1.re + c1.im*c1.im)) >= (sqrt(c2.re*c2.re + c2.im*c2.im)))
        return true;
    return false;
}

namespace Cesnek {
    class Complex {
        friend bool operator== (const Complex &c1, const Complex &c2);
        friend bool operator!= (const Complex &c1, const Complex &c2);
        friend bool operator< (const Complex &c1, const Complex &c2);
        friend bool operator> (const Complex &c1, const Complex &c2);
        friend bool operator<= (const Complex &c1, const Complex &c2);
        friend bool operator>= (const Complex &c1, const Complex &c2);
    private:
        float re, im;
    public:
        Complex() : re(0), im(0) {};
        Complex(float _re, float _im) : re(_re), im(_im) {};

        float getRe();
        void setRe(float _re);
        float getIm();
        void setIm(float _im);
    };
}

float Cesnek::Complex::getRe() {
    return re;
}
void Cesnek::Complex::setRe(float _re) {
    re = _re;
}
float Cesnek::Complex::getIm() {
    return im;
}
void Cesnek::Complex::setIm(float _im) {
    im = _im;
}
bool Cesnek::operator== (const Complex &c1, const Complex &c2) {
    if ((c1.re == c2.re) && (c1.im == c2.im))
        return true;
    return false;
}
bool Cesnek::operator!= (const Complex &c1, const Complex &c2) {
    return !(c1 == c2);
}
bool Cesnek::operator< (const Complex &c1, const Complex &c2) {
    if ((c1.re < c2.re) && (c1.im < c2.im))
        return true;
    return false;
}
bool Cesnek::operator> (const Complex &c1, const Complex &c2) {
    return !(c1 < c2);
}
bool Cesnek::operator<= (const Complex &c1, const Complex &c2) {
    if ((c1.re <= c2.re) && (c1.im <= c2.im))
        return true;
    return false;
}
bool Cesnek::operator>= (const Complex &c1, const Complex &c2) {
    if ((c1.re >= c2.re) && (c1.im >= c2.im))
        return true;
    return false;
}

template<class Tip>
void sort(Tip array[], int n) {
    Tip temp;
    for (int i = 0; i < (n - 1); i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (array[j] > array[j + 1])
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}
int main()
{
    float rand_re, rand_im;
    int n;
    cout << "Broj elemenata: ";
    cin >> n;

    Filip::Complex *c1 = new Filip::Complex[n];
    Cesnek::Complex *c2 = new Cesnek::Complex[n];

    srand((unsigned)time(NULL));

    for (int i = 0; i < n; i++) {
        rand_re = ((float)rand() / (float)(RAND_MAX)) * 2.0;
        rand_im = ((float)rand() / (float)(RAND_MAX)) * 3.0;
        c1[i].setRe(rand_re);
        c1[i].setIm(rand_im);
        c2[i].setRe(rand_re);
        c2[i].setIm(rand_im);
    }

    sort(c1, n);
    sort(c2, n);

    cout << "C1 sortirano (po modulu)" << endl;
    for (int i = 0; i < n; i++) {
        cout << c1[i].getRe() << "+" << c1[i].getIm() << "i" << endl;
    }
    cout << endl << "C2 sortirano (po re i im vrijednostima)" << endl;
    for (int i = 0; i < n; i++) {
        cout << c2[i].getRe() << "+" << c2[i].getIm() << "i" << endl;
    }

    delete[] c1;
    delete[] c2;

    system("pause");
    return 0;
}