#ifndef __VECTOR3_H_INCLUDE
#define __VECTOR3_H_INCLUDE

#include <stdio.h>
#include <math.h>



//----  3次元ベクトルクラスの宣言

class TmpVec3
{
public:
  double x, y, z;
  TmpVec3( void );
  TmpVec3( const double& _x, const double& _y, const double& _z );
};

class Vector3
{
public:
  double x, y, z;
  Vector3( void );
  Vector3( const double& _x, const double& _y, const double& _z );
  Vector3( const TmpVec3& t );

  Vector3& operator = ( const Vector3& );
  Vector3& operator = ( const TmpVec3& );

  Vector3& operator+=( const Vector3& );
  Vector3& operator+=( const TmpVec3& );
  Vector3& operator-=( const Vector3& );
  Vector3& operator-=( const TmpVec3& );
};



//----  3次元ベクトルクラスのメンバ関数

//----  コンストラクタ1
inline TmpVec3::TmpVec3( void ){}
inline Vector3::Vector3( void ){}


//----  コンストラクタ2
inline TmpVec3::TmpVec3( const double& _x, const double& _y, const double& _z )
{
  x = _x;    y = _y;    z = _z;
}
inline Vector3::Vector3( const double& _x, const double& _y, const double& _z )
{
  x = _x;    y = _y;    z = _z;
}
inline Vector3::Vector3( const TmpVec3& t )
{
  x = t.x;    y = t.y;    z = t.z;
}


//----  代入の定義
inline Vector3&  Vector3::operator =  ( const Vector3& v )
{
  x = v.x;    y = v.y;    z = v.z;
  return *this;
}
inline Vector3&  Vector3::operator =  ( const TmpVec3& t )
{
  x = t.x;    y = t.y;    z = t.z;
  return *this;
}


//----  単項演算子の定義
inline TmpVec3  operator - ( const Vector3& v )
{
  return( TmpVec3( -v.x, -v.y, -v.z ) );
}
inline TmpVec3& operator - (       TmpVec3& t )
{
  t.x *= -1;    t.y *= -1;    t.z *= -1;
  return( t );
}
inline Vector3& operator + (       Vector3& v )
{
  return( v );
}
inline TmpVec3& operator + (       TmpVec3& t )
{
  return( t );
}


//----  3次元ベクトル＋＝3次元ベクトルの定義
inline Vector3& Vector3::operator+=( const Vector3& v )
{
  x += v.x;    y += v.y;    z += v.z;
  return( *this );  
}
inline Vector3& Vector3::operator+=( const TmpVec3& t )
{
  x += t.x;    y += t.y;    z += t.z;
  return( *this );  
}


//----  3次元ベクトル−＝3次元ベクトルの定義
inline Vector3& Vector3::operator-=( const Vector3& v )
{
  x -= v.x;    y -= v.y;    z -= v.z;
  return( *this );  
}
inline Vector3& Vector3::operator-=( const TmpVec3& t )
{
  x -= t.x;    y -= t.y;    z -= t.z;
  return( *this );  
}


//----  3次元ベクトル＋3次元ベクトルの定義
inline TmpVec3  operator+( const Vector3& v1, const Vector3& v2 )
{
  return( TmpVec3( v1.x+v2.x, v1.y+v2.y, v1.z+v2.z ) );
}
inline TmpVec3& operator+(       TmpVec3&  t, const Vector3&  v )
{
  t.x += v.x;    t.y += v.y;    t.z += v.z;
  return( t );
}
inline TmpVec3& operator+( const Vector3&  v,       TmpVec3&  t )
{
  t.x += v.x;    t.y += v.y;    t.z += v.z;
  return( t );
}
inline TmpVec3& operator+(       TmpVec3& t1, const TmpVec3& t2 )
{
  t1.x += t2.x;    t1.y += t2.y;    t1.z += t2.z;
  return( t1 );
}


//----  3次元ベクトル−3次元ベクトルの定義
inline TmpVec3  operator-( const Vector3& v1, const Vector3& v2 )
{
  return( TmpVec3( v1.x-v2.x, v1.y-v2.y, v1.z-v2.z ) );
}
inline TmpVec3& operator-(       TmpVec3&  t, const Vector3&  v )
{
  t.x -= v.x;    t.y -= v.y;    t.z -= v.z;
  return( t );
}
inline TmpVec3& operator-( const Vector3&  v,       TmpVec3&  t )
{
  t.x *=  -1;    t.y *=  -1;    t.z *=  -1;
  t.x += v.x;    t.y += v.y;    t.z += v.z;
  return( t );
}
inline TmpVec3& operator-(       TmpVec3& t1, const TmpVec3& t2 )
{
  t1.x += t2.x;    t1.y += t2.y;    t1.z += t2.z;
  return( t1 );
}

//----  実スカラー＊3次元ベクトルの定義
inline TmpVec3  operator*( const double& k, const Vector3& v )
{
  return( TmpVec3( k*v.x, k*v.y, k*v.z ) );
}
inline TmpVec3& operator*( const double& k,       TmpVec3& t )
{
  t.x *= k;    t.y *= k;    t.z *= k;
  return( t );
}

//----  3次元ベクトル＊実スカラーの定義
inline TmpVec3  operator*( const Vector3& v, const double& k )
{
  return( TmpVec3( v.x*k, v.y*k, v.z*k ) );
}
inline TmpVec3& operator*(       TmpVec3& t, const double& k )
{
  t.x *= k;    t.y *= k;    t.z *= k;
  return( t );
}


//----  3次元ベクトル／実スカラーの定義
inline TmpVec3  operator/( const Vector3& v, const double& k )
{
  const double inv_k = 1.0/k;
  return( TmpVec3( v.x*inv_k, v.y*inv_k, v.z*inv_k ) );
}
inline TmpVec3& operator/(       TmpVec3& t, const double& k )
{
  const double inv_k = 1.0/k;
  t.x *= inv_k;    t.y *= inv_k;    t.z *= inv_k;
  return( t );
}


//----  内積の定義
inline double operator*( const Vector3& v1, const Vector3& v2 )
{
  return( v1.x*v2.x + v1.y*v2.y + v1.z*v2.z );
}
inline double operator*(       TmpVec3&  t, const Vector3& v  )
{
  return( t.x*v.x + t.y*v.y + t.z*v.z );
}
inline double operator*( const Vector3&  v,       TmpVec3&  t )
{
  return( v.x*t.x + v.y*t.y + v.z*t.z );
}
inline double operator*(       TmpVec3& t1, const TmpVec3& t2 )
{
  return( t1.x*t2.x + t1.y*t2.y + t1.z*t2.z );
}


//----  外積の定義
inline TmpVec3  operator%( const Vector3& v1, const Vector3& v2 )
{
  return( TmpVec3( v1.y*v2.z - v1.z*v2.y,  v1.z*v2.x - v1.x*v2.z,  v1.x*v2.y - v1.y*v2.x ) );
}
inline TmpVec3& operator%(       TmpVec3&  t, const Vector3& v )
{
  const double t_x = t.x, t_y = t.y;
  t.x = t_y*v.z - t.z*v.y;
  t.y = t.z*v.x - t_x*v.z;
  t.z = t_x*v.y - t_y*v.x;
  return( t );
}
inline TmpVec3& operator%( const Vector3&  v,       TmpVec3&  t )
{
  const double t_x = t.x, t_y = t.y;
  t.x = v.y*t.z - v.z*t_y;
  t.y = v.z*t_x - v.x*t.z;
  t.z = v.x*t_y - v.y*t_x;
  return( t );
}
inline TmpVec3& operator%(       TmpVec3& t1, const TmpVec3& t2 )
{
  const double t1_x = t1.x, t1_y = t1.y;
  t1.x = t1_y*t2.z - t1.z*t2.y;
  t1.y = t1.z*t2.x - t1_x*t2.z;
  t1.z = t1_x*t2.y - t1_y*t2.x;
  return( t1 );
}

//----  絶対値の定義
inline double abs( const Vector3& v )
{
    return( sqrt( v.x*v.x + v.y*v.y + v.z*v.z ) );
}

//----  絶対値の2乗の定義
inline double norm( const Vector3& v )
{
    return( v.x*v.x + v.y*v.y + v.z*v.z );
}

//----  3次元ベクトルの成分の表示
inline void print( const Vector3& v )
{
    printf("(%f %f %f)\n", v.x, v.y, v.z );
}

#endif  // __VECTOR3_H_INCLUDE