#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iomanip>

using namespace std;

//=========================================================

// Deklaracja klasy Wektor3

class Wektor3
{
public:
	Wektor3( void );
	Wektor3( double x, double y, double z );
	Wektor3( const Wektor3 &w );

	double X( void ) { return _x; }
	double Y( void ) { return _y; }
	double Z( void ) { return _z; }

	Wektor3& Assign( double x, double y, double z );
	Wektor3& operator = ( const Wektor3 &w );

	double operator ! ( void );
	double Azym( void );
	double Elev( void );

	Wektor3& operator += ( const Wektor3 &w );
	Wektor3& operator *=( double k );

	friend Wektor3 operator + ( const Wektor3 &w1, const Wektor3 &w2 );
	friend Wektor3 operator * ( double k, const Wektor3 &w );
	friend Wektor3 operator * ( const Wektor3 &w, double k );

	friend operator == ( const Wektor3 &w1, const Wektor3 &w2 );
	friend operator != ( const Wektor3 &w1, const Wektor3 &w2 );

private:
	double  _x, _y, _z;
};

	istream& operator >> (istream &s, Wektor3 &w);
	ostream& operator << (ostream &s, Wektor3 &w);
//=========================================================

// Definicje konstruktorow, metod i funkcji zaprzyjaznionych

Wektor3::Wektor3( void )
{
	_x = _y = _z = 0.0;
}
//---------------------------------------------------------

Wektor3::Wektor3( double x, double y, double z )
{
	_x = x; _y = y; _z = z;
}
//---------------------------------------------------------

Wektor3::Wektor3( const Wektor3 &w )
//Do uzupelnienia
{
    _x = w._x;
    _y = w._y;
    _z = w._z;
}
//---------------------------------------------------------

Wektor3& Wektor3::Assign( double x, double y, double z )
{
	_x = x;
	_y = y;
	_z = z;

	return *this;
}
//---------------------------------------------------------

Wektor3& Wektor3::operator = ( const Wektor3 &w )
//Do uzupelnienia
{
    _x = w._x;
    _y = w._y;
    _z = w._z;
    return *this;
}
//---------------------------------------------------------

double Wektor3::operator ! ()
//Do uzupelnienia
{
    return sqrt((_x*_x)+(_y*_y)+(_z*_z));
}
//---------------------------------------------------------

double Wektor3::Azym( void )
{
//Do uzupelnienia
    double wynik = 0;
    wynik = _x/(sqrt((_x*_x)+(_y*_y)));
    if(_y >= 0)
    {
        return (acos(wynik)*(180/M_PI));
    }else
    {
        return -(acos(wynik)*(180/M_PI));
    }
}
//---------------------------------------------------------

double Wektor3::Elev( void )
//Do uzupelnienia
{
    return (asin((_z)/(((sqrt((_x*_x)+(_y*_y)+(_z*_z)))))))*(180/M_PI);
}
//---------------------------------------------------------

Wektor3& Wektor3::operator += ( const Wektor3 &w )
//Do uzupelnienia
{
    _x += w._x;
    _y += w._y;
    _z += w._z;

    return *this;
}
//---------------------------------------------------------

Wektor3& Wektor3::operator *=( double k )
//Do uzupelnienia
{
    _x *= k;
    _y *= k;
    _z *= k;
    return *this;
}

//---------------------------------------------------------

Wektor3 operator + ( const Wektor3 &w1, const Wektor3 &w2 )
//Do uzupelnienia
{
    Wektor3 suma(0,0,0);
    suma._x = w1._x + w2._x;
    suma._y = w1._y + w2._y;
    suma._z = w1._z + w2._z;

    return suma;
}
//---------------------------------------------------------

Wektor3 operator * ( double k, const Wektor3 &w )
//Do uzupelnienia
{
    Wektor3 iloczyn;

    iloczyn._x = k * w._x;
    iloczyn._y = k * w._y;
    iloczyn._z = k * w._z;

    return iloczyn;
}

Wektor3 operator * ( const Wektor3 &w, double k )
//Do uzupelnienia
{
    Wektor3 iloczyn;

    iloczyn._x = k * w._x;
    iloczyn._y = k * w._y;
    iloczyn._z = k * w._z;

    return iloczyn;
}
//---------------------------------------------------------

operator == ( const Wektor3 &w1, const Wektor3 &w2 )
//Do uzupelnienia
{
    if(w1._x == w2._x && w1._y == w2._y && w1._z == w2._z)
    {
        return true;
    }
    return false;
}
//---------------------------------------------------------

operator !=( const Wektor3 &w1, const Wektor3 &w2 )
//Do uzupelnienia
{
    if(w1._x != w2._x || w1._y != w2._y || w1._z != w2._z)
    {
        return true;
    }
    return false;
}

// --------------------------------------------------------

istream& operator >> (istream &s, Wektor3 &w)
{
	double x, y, z;
    s >> x >> y >> z;

    w.Assign(x,y,z);

    return s;
}
// --------------------------------------------------------
ostream& operator << (ostream &s, Wektor3 &w)
{
	double x, y, z;

	x = w.X();
	y = w.Y();
	z = w.Z();
    s << "(" << x << ", " << y << ", " << z << ")";
    return s;
}
//=========================================================

int main(int argc, char *argv[])
{
	Wektor3     w1( 1, 2, 3 );
	Wektor3     w3, w4, w5;
	double      ax, ay, az, k;

	cout << "Wektor w3 (x, y, z): ";

//	cin >> ax >> ay >> az;
//	w3.Assign( ax, ay, az );
	cin >> w3;

	cout << "Wektor w4 (x, y, z): ";

//	cin >> ax >> ay >> az;
//	w4.Assign( ax, ay, az );
	cin >> w4;

	cout << "Wspolczynnik k: ";
	cin >> k;

	Wektor3     w31( w3 );

	cout << fixed << setprecision( 3 ) << endl;

//	cout << "Wektor w1 = ( " << w1.X( ) << ", " << w1.Y( ) << ", " << w1.Z( ) << " )" << endl;
//	cout << "Wektor w3 = ( " << w3.X( ) << ", " << w3.Y( ) << ", " << w3.Z( ) << " )" << endl;
//	cout << "Kopia  w3 = ( " << w31.X( ) << ", " << w31.Y( ) << ", " << w31.Z( ) << " )" << endl;
//	cout << "Wektor w4 = ( " << w4.X( ) << ", " << w4.Y( ) << ", " << w4.Z( ) << " )" << endl << endl;
	cout << "Wektor w1 = " << w1 << endl;
	cout << "Wektor w3 = " << w3 << endl;
	cout << "Kopia  w3 = " << w31 << endl;
	cout << "Wektor w4 = " << w4 << endl << endl;

//	w5.Assign( w3 );
//	w5.Plus( w4 );
	w5 = w3;
	w5 += w4;

//	cout << "Wektor w3+w4 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl;
	cout << "Wektor w3+w4 = " << w5 << endl;

//	w5.Assign( Plus( w1, w3 ) );
	w5 = w1 + w3;

//	cout << "Wektor w1+w3 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl << endl;
	cout << "Wektor w1+w3 = " << w5 << endl << endl;

//	w5.Assign( w3 );
//	w5.Mult( k );
	w5 = w3;
	w5 *= k;

//	cout << "Wektor k*w3 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl ;
	cout << "Wektor k*w3 = " << w5 << endl ;

//	w5.Assign( Mult( k, w4 ) );
	w5 = k * w4;
//	cout << "Wektor k*w4 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl;
	cout << "Wektor k*w4 = " << w5 << endl;
	w5 = w3 * k;
//	cout << "Wektor w3*k = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl << endl;
	cout << "Wektor w3*k = " << w5 << endl << endl;

//	cout << "Modul w3 = " << w3.Mod( ) << endl;
	cout << "Modul w3 = " << !w3 << endl;

	cout << "Azymut w3 = " << w3.Azym( ) << endl;
	cout << "Elewacja w3 = " << w3.Elev( ) << endl << endl;

//	cout << "w3==w4 " << ( Eq( w3, w4 ) ? "tak" : "nie" ) << endl << endl;
//	cout << "w3!=w4 " << ( Neq( w3, w4 ) ? "tak" : "nie" ) << endl << endl;
	cout << "w3==w4 " << ( ( w3 == w4 ) ? "tak" : "nie" ) << endl << endl;
	cout << "w3!=w4 " << ( ( w3 != w4 ) ? "tak" : "nie" ) << endl << endl;

	return 0;
}