/*
 * =====================================================================================
 *
 *       Filename:  6.00.UeberladenVonOperatoren.cc
 *
 *    Description:  Implementierung Vek3
 *
 *        Version:  1.0
 *        Created:  15.05.2014 12:23:50
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Stefan Suhren (SSuhren), suhren.stefan@fh-swf.de
 *   Organization:  FH Südwestfalen, Iserlohn
 *
 * =====================================================================================
 */

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

using namespace std;

// =====================================================================================
//        Class:  Vek3
//  Description:  
// =====================================================================================
class Vek3
{
	public:
		// ====================  LIFECYCLE     ======================================= 
		Vek3 (double xx=0.0, double yy=0.0, double zz=0.0);    // constructor 

		// ====================  ACCESSORS     ======================================= 
		double laenge();				// Vektorlänge zurückgeben
		double get_x(){ return x;}		// x-Wert zurückgeben
		double get_y(){ return y;}		// y-Wert zurückgeben
		double get_z(){ return z;}		// z-Wert zurückgeben
		
		// die folgenden Operationen erzeugen jeweils einen Ergebnisvektor;
		// der eigene Vektor bleibt unverändert
		Vek3 add ( Vek3 &v2 );	// Vektoraddition
		Vek3 sub ( Vek3 &v2 );	// Vektorsubtraktion
		Vek3 mul ( double s );	// Vektor * Skalar

		Vek3 kreuzprodukt ( Vek3 &v2 );
		double skalarprodukt ( Vek3 &v2 );	// Skalarprodukt
		void out ( const char *name );			// einfache Ausgabefunktion

		// ====================  MUTATORS      ======================================= 
		Vek3& null ();							// Komponenten zu Null setzen
		Vek3& e_x  ();							// Einnheitsvektor in x-Richtung
		Vek3& e_y  ();							// Einnheitsvektor in y-Richtung
		Vek3& e_z  ();							// Einnheitsvektor in z-Richtung
		Vek3& set  ( double xx=0.0,
					 double yy=0.0,
					 double zz=0.0 );
		void set_x ( double xx ) { x = xx; }	// x-Wert zuweisen
		void set_y ( double yy ) { y = yy; }	// y-Wert zuweisen
		void set_z ( double zz ) { z = zz; }	// z-Wert zuweisen
		Vek3& norm ();							// Vektor normieren

		// die folgenden Operationen verändern den eigenen Vektor und
		// geben eine Referenz auf sich selbst zurück
		Vek3& plusgleich  ( Vek3 &v2 );			// Vektoraddition
		Vek3& minusgleich ( Vek3 &v2 );			// Vektorsubtraktion
		Vek3& mulgleich   ( double s );			// Vektor x Skalar

		// ====================  OPERATORS     ======================================= 
		Vek3  operator +  ();					// Positives Vorzeichen
		Vek3  operator -  ();					// Negatives Vorzeichen
		Vek3  operator += ( Vek3 &v2 );	// Vektoraddition mit Zuweisung
		Vek3  operator -= ( Vek3 &v2 );	// Vektorsubtraktion mit Zuweisung
		Vek3& operator *= ( double s );			// Streckung mit Zuweisung
		Vek3& operator /= ( double s );			// Streckung mit Zuweisung
		Vek3  operator + ( Vek3 v2 );	// Vektoraddition
		Vek3  operator - ( Vek3 v2 );	// Vektorsubtraktion
		Vek3  operator / ( double s);			// Streckung

		friend Vek3   operator * ( Vek3 v2, double s );		// Vektor*Skalar
		friend Vek3   operator * ( double s, Vek3 v2 );		// Skalar*Vektor
		friend double operator * ( Vek3 v1, Vek3 v2 );// Skalarprodukt
		friend Vek3   operator % ( Vek3 v1, Vek3 v2 );// Kreuzprodukt

		friend ostream& operator << ( ostream &os, Vek3 obj );// Ausgabe

	private:
		// ====================  DATA MEMBERS  ======================================= 
		double x;
		double y;
		double z;

}; // -----  end of class Vek3  ----- 

Vek3 lingl3          ( Vek3 s1, Vek3 s2, Vek3 s3, Vek3 rs );
Vek3 kreismittelpunkt( Vek3 p1, Vek3 p2, Vek3 p3 );
double kreisbogenlaenge( Vek3 p1, Vek3 p2, Vek3 p3 );

// ===  FUNCTION  ======================================================================
//         Name:  main
//  Description:  
// =====================================================================================
int main ( int argc, char *argv[] ){
	
	// Aufgabe 1
	Vek3 test1;
	Vek3 test2(1,2,3);
	Vek3 test3(4,5,6);

	cout << "test1: " << test1.laenge() << ", (" << test1.get_x() << ", " << test1.get_y() << ", " << test1.get_z() << ")\n";
	cout << "test2: " << test2.laenge() << ", (" << test2.get_x() << ", " << test2.get_y() << ", " << test2.get_z() << ")\n";
	cout << "test3: " << test3.laenge() << ", (" << test3.get_x() << ", " << test3.get_y() << ", " << test3.get_z() << ")\n";

	test1 = test2.add(test3);

	test2.add(test3).out("v2+v3");
	test2.sub(test3).out("v2-v3");
	test2.mul(3).out("v2*3");
	test2.kreuzprodukt(test3).out("v2xv3");
	cout << "v2*v3=" << test2.skalarprodukt(test3) << "\n";

	test3.null().out("v3.null");
	test3.out("v3.null");
	test3.e_x().out("v3.e_x");
	test3.out("v3.e_x");
	test3.e_y().out("v3.e_y");
	test3.out("v3.e_y");
	test3.e_z().out("v3.e_z");
	test3.out("v3.e_z");
	test3.set(4,5,6).out("v3.4,5,6");
	test3.out("v3.4,5,6");

	test3.set_x(6);
	test3.set_y(5);
	test3.set_z(4);
	test3.out("v3.6,5,4");

	test3.norm().out("v3.norm");
	test3.out("v3.norm");

	test2.plusgleich(test3).out("v2+=v3");
	test2.out("v2+=v3");
	test2.minusgleich(test3).out("v2-=v3");
	test2.out("v2-=v3");
	test2.mulgleich(3).out("v2*=3");
	test2.out("v2*=3");

	cout << "\n\n";

	// Aufgabe 2
	cout << "+v3\n" << +test3;
	cout << "-v3\n" << -test3;

	test2 += test3;
	cout << "v2+=v3\n" << test2;
	test2 -= test3;
	cout << "v2-=v3\n" << test2;
	test2 *= 3;
	cout << "v2*=3\n" << test2;
	test2 /= 3;
	cout << "v2/=3\n" << test2;

	cout << "v2+v3\n" << test2 + test3;
	cout << "v2-v3\n" << test2 - test3;
	cout << "v2/3\n" << test2 / 3;

	cout << "v2*3\n" << test2 * 3;
	cout << "3*v2\n" << 3 * test2;
	cout << "v2*v3=" << test2 * test3 << "\n";
	cout << "v2xv3\n" << test2 % test3;

	cout << "\n\n\n";

	// Aufgabe 5
	
	Vek3 p1(1,1,0);
	Vek3 p2(0,2,0);
	Vek3 p3(-1,1,0);

	cout << "m1\n" << kreismittelpunkt(p1,p2,p3);
	cout << "b1 = " << kreisbogenlaenge(p1,p2,p3) << "\n";

	cout << "\n\n";

	Vek3 p4(2,-1,-1);
	Vek3 p5(-2,-2,-1);
	Vek3 p6(0,1,4);

	cout << "m2\n" << kreismittelpunkt(p4,p5,p6);
	cout << "b2 = " << kreisbogenlaenge(p4,p5,p6) << "\n";

	cout << "\n\n";

	Vek3 p7(2,2,1);
	Vek3 p8(1,1,1);
	Vek3 p9(-1,-1,1);

	cout << "m2\n" << kreismittelpunkt(p7,p8,p9);
	cout << "b2 = " << kreisbogenlaenge(p7,p8,p9) << "\n";

	return EXIT_SUCCESS;
}				// ----------  end of function main  ---------- 

// ===  FUNCTION  ======================================================================
//         Name:  lingl3
//  Description:  
// =====================================================================================
Vek3 lingl3          ( Vek3 s1, Vek3 s2, Vek3 s3, Vek3 rs ){
	double d0 = ( s1 % s2 ) * s3;

	assert( d0 > 0.000000001 || d0 < -0.000000001 );

	double d1 = ( rs % s2 ) * s3;
	double d2 = ( s1 % rs ) * s3;
	double d3 = ( s1 % s2 ) * rs;

	double x1 = d1 / d0;
	double x2 = d2 / d0;
	double x3 = d3 / d0;

	return Vek3(x1, x2, x3);
}

// ===  FUNCTION  ======================================================================
//         Name:  kreismittelpunkt
//  Description:  
// =====================================================================================
Vek3 kreismittelpunkt( Vek3 p1, Vek3 p2, Vek3 p3 ){
	Vek3 d1 = p2 - p1;
	Vek3 d2 = p3 - p2;
	Vek3 n  = d1 % d2;
	Vek3 m1 = d1 % n;
	Vek3 m2 = d2 % n;

	Vek3 x = lingl3( m1, -m2, n, 0.5*(p3-p1));

	double x1 = x.get_x();
		
	Vek3 m = p1 + 0.5*d1 + x1 * m1;

	cout << "Abstand l1 = " << (p1 - m).laenge() << "\n";
	cout << "Abstand l2 = " << (p2 - m).laenge() << "\n";
	cout << "Abstand l3 = " << (p3 - m).laenge() << "\n";

	return m;
}

// ===  FUNCTION  ======================================================================
//         Name:  kreisbogenlaenge
//  Description:  
// =====================================================================================
double kreisbogenlaenge( Vek3 p1, Vek3 p2, Vek3 p3 ){
	Vek3 v1 = (p1 - p2).norm();
	Vek3 v2 = (p3 - p2).norm();

	double alpHlb = M_PI - acos(v1*v2);

	double r  = ((p3 - p1).laenge()) / (2*sin(alpHlb));

	double b = 2 * alpHlb * r;

	return b;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::Vek3
//  Description:  
// =====================================================================================
Vek3::Vek3 (double xx, double yy, double zz){
	x = xx;
	y = yy;
	z = zz;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::laenge
//  Description:  
// =====================================================================================
double Vek3::laenge(){
	return sqrt( x*x + y*y + z*z );
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::add
//  Description:  
// =====================================================================================
Vek3 Vek3::add ( Vek3 &v2 ){
	return Vek3( x + v2.x, y + v2.y, z + v2.z );
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::sub
//  Description:  
// =====================================================================================
Vek3 Vek3::sub ( Vek3 &v2 ){
	return Vek3( x - v2.x, y - v2.y, z - v2.z );
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::mul
//  Description:  
// =====================================================================================
Vek3 Vek3::mul ( double s ){
	return Vek3( s * x, s * y, s * z );
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::kreuzprodukt
//  Description:  
// =====================================================================================
Vek3 Vek3::kreuzprodukt ( Vek3 &v2 ){
	return Vek3( y*v2.z - z*v2.y, z*v2.x - x*v2.z, x*v2.y - y*v2.x );

}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::skalarprodukt
//  Description:  
// =====================================================================================
double Vek3::skalarprodukt ( Vek3 &v2 ){
	return x*v2.x + y*v2.y + z*v2.z;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::out
//  Description:  
// =====================================================================================
void Vek3::out ( const char *name ){
	cout << name << "\n";
	cout << "/ " << setw(3) << x << " \\\n";
	cout << "| " << setw(3) << y << " |\n";
	cout << "\\ " << setw(3) << z << " /\n";
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::null
//  Description:  
// =====================================================================================
Vek3& Vek3::null (){
	x = 0;
	y = 0;
	z = 0;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::e_x
//  Description:  
// =====================================================================================
Vek3& Vek3::e_x  (){
	x = 1;
	y = 0;
	z = 0;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::e_y
//  Description:  
// =====================================================================================
Vek3& Vek3::e_y  (){
	x = 0;
	y = 1;
	z = 0;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::e_z
//  Description:  
// =====================================================================================
Vek3& Vek3::e_z  (){
	x = 0;
	y = 0;
	z = 1;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::set
//  Description:  
// =====================================================================================
Vek3& Vek3::set  ( double xx, double yy, double zz ){
	x = xx;
	y = yy;
	z = zz;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::norm
//  Description:  
// =====================================================================================
Vek3& Vek3::norm (){
	double betrag = laenge();
	
	x = x / betrag;
	y = y / betrag;
	z = z / betrag;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::plusgleich
//  Description:  
// =====================================================================================
Vek3& Vek3::plusgleich  ( Vek3 &v2 ){
	x += v2.x;
   	y += v2.y;
	z += v2.z;
	
	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::minusgleich
//  Description:  
// =====================================================================================
Vek3& Vek3::minusgleich ( Vek3 &v2 ){
	x -= v2.x;
   	y -= v2.y;
	z -= v2.z;
	
	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::mulgleich
//  Description:  
// =====================================================================================
Vek3& Vek3::mulgleich   ( double s ){
	x *= s;
   	y *= s;
	z *= s;
	
	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator+
//  Description:  
// =====================================================================================
Vek3  Vek3::operator +  (){
	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator-
//  Description:  
// =====================================================================================
Vek3  Vek3::operator -  (){
	return Vek3(-x,-y,-z);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator+=
//  Description:  
// =====================================================================================
Vek3  Vek3::operator += ( Vek3 &v2 ){
	return plusgleich(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator-=
//  Description:  
// =====================================================================================
Vek3  Vek3::operator -= ( Vek3 &v2 ){
	return minusgleich(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator*=
//  Description:  
// =====================================================================================
Vek3& Vek3::operator *= ( double s ){
	return mulgleich(s);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator/=
//  Description:  
// =====================================================================================
Vek3& Vek3::operator /= ( double s ){
	x /= s;
	y /= s;
	z /= s;

	return *this;
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator+
//  Description:  
// =====================================================================================
Vek3  Vek3::operator + ( Vek3 v2 ){
	return add(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator-
//  Description:  
// =====================================================================================
Vek3  Vek3::operator - ( Vek3 v2 ){
	return sub(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator/
//  Description:  
// =====================================================================================
Vek3  Vek3::operator / ( double s){
	return Vek3(x/s,y/s,z/s);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator*
//  Description:  
// =====================================================================================
Vek3   operator * ( Vek3 v2, double s ){
	return v2.mul(s);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator*
//  Description:  
// =====================================================================================
Vek3   operator * ( double s, Vek3 v2 ){
	return v2.mul(s);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator*
//  Description:  
// =====================================================================================
double operator * ( Vek3 v1, Vek3 v2 ){
	return v1.skalarprodukt(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator%
//  Description:  
// =====================================================================================
Vek3   operator % ( Vek3 v1, Vek3 v2 ){
	return v1.kreuzprodukt(v2);
}

// ===  FUNCTION  ======================================================================
//         Name:  Vek3::operator<<
//  Description:  
// =====================================================================================
ostream& operator << ( ostream &os, Vek3 obj ){
	os << "/ " << setw(3) << obj.x << " \\\n";
	os << "| " << setw(3) << obj.y << " |\n";
	os << "\\ " << setw(3) << obj.z << " /\n";
	return os;
}