/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/vec3d

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_vec3d
#define inlib_vec3d

#include "a3"

#include <cmath> //::sqrt

namespace inlib {

class vec3d : public inlib::a3::vec<double> {
public:
  vec3d(): inlib::a3::vec<double>() {}
  vec3d(const double a_vec[3]): inlib::a3::vec<double>(a_vec) {}
  vec3d(double a0,double a1,double a2)
  : inlib::a3::vec<double>(a0,a1,a2){}
  virtual ~vec3d() {}
public:
  vec3d(const vec3d& a_from): inlib::a3::vec<double>(a_from){}
  vec3d& operator=(const vec3d& a_from){
    inlib::a3::vec<double>::operator=(a_from);
    return *this;
  }

  vec3d(const inlib::a3::vec<double>& a_from)
  : inlib::a3::vec<double>(a_from){}

public: //operators
  double& operator[](unsigned int a_index) {
    //WARNING : no check on a_index.
    return m_vector[a_index];
  }
  const double& operator[](unsigned int a_index) const {
    //WARNING : no check on a_index.
    return m_vector[a_index];
  }
  vec3d operator*(double a_v) const {
    return vec3d(m_vector[0]*a_v,
                 m_vector[1]*a_v,
                 m_vector[2]*a_v);
  }    
  vec3d operator+(const vec3d& a_v) const {
    return vec3d(m_vector[0]+a_v[0],
                 m_vector[1]+a_v[1],
                 m_vector[2]+a_v[2]);
  }    
  vec3d operator-(const vec3d& a_v) const {
    return vec3d(m_vector[0]-a_v[0],
                 m_vector[1]-a_v[1],
                 m_vector[2]-a_v[2]);
  }    
  vec3d& operator+=(const vec3d& a_v) {   
    m_vector[0] += a_v[0];
    m_vector[1] += a_v[1];
    m_vector[2] += a_v[2];
    return *this;
  }    
  vec3d& operator*=(double a_v) {   
    m_vector[0] *= a_v;
    m_vector[1] *= a_v;
    m_vector[2] *= a_v;
    return *this;
  }    
  vec3d operator-() const {
    return vec3d(-m_vector[0],-m_vector[1],-m_vector[2]);
  }
  bool operator==(const vec3d& a_v) const {return equal(a_v);}
  bool operator!=(const vec3d& a_v) const {return !operator==(a_v);}
public:
  double x() const {return m_vector[0];}
  double y() const {return m_vector[1];}
  double z() const {return m_vector[2];}
  double length() const {
    return ::sqrt(m_vector[0] * m_vector[0] + 
                  m_vector[1] * m_vector[1] + 
                  m_vector[2] * m_vector[2]); 
  }
  double normalize() {
    double norme = length();
    if(norme==0) return 0;
    divide(norme);
    return norme;
  }
  vec3d cross(const vec3d& aV) const {
    return vec3d(m_vector[1] * aV.m_vector[2] - m_vector[2] * aV.m_vector[1],
                 m_vector[2] * aV.m_vector[0] - m_vector[0] * aV.m_vector[2],
                 m_vector[0] * aV.m_vector[1] - m_vector[1] * aV.m_vector[0]);
  }    
  /*double dot(const vec3d& aV) const {
    return (m_vector[0] * aV.m_vector[0] + 
            m_vector[1] * aV.m_vector[1] + 
            m_vector[2] * aV.m_vector[2]);
  }*/   
public:
  //NOTE : don't handle a static object because of mem balance.
  //static const vec3d& x_axis() {
  //  static const vec3d s_v(1,0,0);
  //  return s_v;
  //}
  //static const vec3d& y_axis() {
  //  static const vec3d s_v(0,1,0);
  //  return s_v;
  //}
  //static const vec3d& z_axis() {
  //  static const vec3d s_v(0,0,1);
  //  return s_v;
  //}
private:
  static void check_instantiation() {
    vec3d dummy(0,0,0);
    dummy.set_value(1,1,1);
  }
};

inline vec3d operator*(double a_f,const vec3d& a_v) {
  vec3d res(a_v);
  res *= a_f;
  return res;
}

}

#endif