Vector.hpp

Go to the documentation of this file.

// This file is part of GranOO, a workbench for DEM simulation.
//
// Author(s)    : - Damien Andre       IRCER/UNILIM, Limoges France
//                  <damien.andre@unilim.fr>
//                - Jean-luc Charles   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jean-luc.charles@ensam.eu>
//                - Jeremie Girardot   Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <jeremie.girardot@ensam.eu>
//                - Cedric Hubert      LAMIH/UPHF, Valenciennes France
//                  <cedric.hubert@uphf.fr>
//                - Ivan Iordanoff     Arts et Metiers ParisTech, CNRS, I2M, Bordeaux France
//                  <ivan.iordanoff@ensam.eu>
//
// Copyright (C) 2008-2019 D. Andre, JL. Charles, J. Girardot, C. Hubert, I. Iordanoff
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 
#ifndef _GranOO_libGeom_Vector_hpp_
#define _GranOO_libGeom_Vector_hpp_
 
#include <vector>
#include <cmath>
#include <iostream>
#include <string>
#include <cmath>
#include "GranOO3/3rdParty/Eigen/Dense"
 
#include "GranOO3/Core/TinyXml.hpp"
#include "GranOO3/Core/Macro.hpp"
#include "GranOO3/Geom/Constant.hpp"
#include "GranOO3/Geom/Axis.hpp"
 
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
 
namespace GranOO3
{
  namespace Geom
  {
    class Vector;
    class Point;
    class Tensor;
 
    // Extern operators
    std::ostream& operator<< (std::ostream& os, const Vector& v);
    std::istream& operator>> (std::istream& in,       Vector& v);
    Vector operator+ (const Vector& v1, const Vector& v2);
    Vector operator- (const Vector& v1, const Vector& v2);
    Vector operator- (const Vector& v);
    Vector operator* (const Vector& v, const double& a);
    Vector operator* (const double& a, const Vector& v);
    Vector operator/ (const Vector& v, const double& a);
    double operator* (const Vector& v1, const Vector& v2);
    Vector operator^ (const Vector& v1, const Vector& v2);
    bool operator!= (const Vector& v1, const Vector& v2);
    bool operator== (const Vector& v1, const Vector& v2);
    Vector double_cross(const Vector& v1, const Vector& v2);
    double get_angle_between_unit_vector (const Vector &a, const Vector &b);
 
    class Vector
    {
    public:
      // Usefull for internal use only, NOT DOCUMENTED !
      static Vector& glob(const std::string& id);
      static std::string class_ID() {return "Vector";}
      static Vector* new_object(const TiXmlElement* el);
      static const Vector& null() {return null::vector;}
      static const int N = 3;
      
 
    public:
      // Constructors and destructor
      Vector ();
      Vector (const Vector& v);
      Vector (const Vector& v, const Frame& from, const Frame& to);
      explicit Vector (const Point& p);
      explicit Vector (const Point& p1, const Point& p2);
      explicit Vector (double x, double y, double z);
      explicit Vector (const double* pt);
      
      
 
      // Miscellaneous Usefull methods
      void clear();
      bool is_null() const;
      bool is_nan() const;
      bool is_unit() const;
      Point& to_point();
      const Point & to_point() const;
 
      // Component
      double & x();
      const double & x() const;
      double & y();
      const double & y() const;
      double & z();
      const double & z() const;
 
 
      // Component (for python wrapper)
      void set_x(const double&);
      void set_y(const double&);
      void set_z(const double&);
 
      // Component (for python wrapper)
      double get_x() const;
      double get_y() const;
      double get_z() const;
 
 
      template <typename Axis> double& val();
      template <typename Axis> const double& val() const;
 
      const double & operator() (unsigned int i) const;
      double& operator() (unsigned int i);
 
      // Internal operators
      Vector & operator= (const Vector& v);
      void operator+= (const Vector& v);
      void operator-= (const Vector& v);
      void operator*= (double k);
      void operator/= (double k);
 
      // Normalizing
      double squared_norm() const;
      double norm() const;
      double Norm1() const;
      double normalize();
      Vector unit() const;
 
      // Projection
      void project_on_axis (const Vector& axis);
      void project_on_plane (const Vector& normal);
      Vector orthogonal_vector() const;
 
      // Misc
      std::string info() const;
      void add_glob(const std::string& id);
 
    private:
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int);
 
    public:
      Eigen::Matrix<double, 3, 1> coord;
    };
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
 
    template<class Archive>
    void Vector::serialize(Archive& ar, const unsigned int) {
      ar & x();
      ar & y();
      ar & z();
    }
 
    inline
    Vector::Vector ()
      : coord(){
    }
 
    inline
    Vector::Vector (const Vector & v)
      : coord(v.coord) {
    }
 
    inline
    Vector::Vector (double x, double y, double z)
      : coord(x, y, z) {
    }
 
    inline
    Vector::Vector (const double* pt)
      : coord(pt[0], pt[1], pt[2]){
    }
 
    // Conversions ...
    inline Point&
    Vector::to_point() {
      return *reinterpret_cast<Point*> (this);
    }
 
    inline const Point&
    Vector::to_point() const {
      return *reinterpret_cast<const Point*> (this);
    }
 
    inline double&
    Vector::x() {
      return coord(0);
    }
 
    inline const double&
    Vector::x() const {
      return coord(0);
    }
 
    inline double&
    Vector::y() {
      return coord(1);
    }
 
    inline const double&
    Vector::y() const {
      return coord(1);
    }
 
    inline double&
    Vector::z() {
      return coord(2);
    }
 
    inline const double&
    Vector::z() const {
      return coord(2);
    }
 
    inline void
    Vector::set_x(const double& val) {
      x() = val;
    }
 
    inline void
    Vector::set_y(const double& val) {
      y() = val;
    }
 
    inline void
    Vector::set_z(const double& val) {
      z() = val;
    }
 
    inline double
    Vector::get_x() const {
      return x();
    }
 
    inline double
    Vector::get_y() const {
      return y();
    }
 
    inline double
    Vector::get_z() const {
      return z();
    }
 
    template <typename Axis> inline
    double& Vector::val() {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template <typename Axis> inline
    const double& Vector::val() const {
      SafeModeAssert(0, "Non specilized method is forbidden");
      return x();
    }
 
    template<> inline
    double& Vector::val<X>() {
      return x();
    }
 
    template<> inline
    const double& Vector::val<X>() const {
      return x();
    }
 
    template<> inline
    double& Vector::val<Y>() {
      return y();
    }
 
    template<> inline
    const double& Vector::val<Y>() const {
      return y();
    }
 
    template<> inline
    double& Vector::val<Z>() {
      return z();
    }
 
    template<> inline
    const double& Vector::val<Z>() const {
      return z();
    }
 
    inline const double&
    Vector::operator() (unsigned int i) const {
      SafeModeAssert(i < 3, "The component must be in [0, 2] range");
      return coord(i);
    }
 
    inline double&
    Vector::operator() (unsigned int i) {
      SafeModeAssert(i < 3, "The component must be in [0, 2] range");
      return coord(i);
    }
 
    // External Operators ...
 
    inline bool
    operator== (const Vector &a, const Vector &b) {
      return (a - b).squared_norm() < constant::epsilon;
    }
 
    inline bool
    operator!= (const Vector &a, const Vector &b) {
      return !(a == b);
    }
 
    inline std::ostream&
    operator<< (std::ostream &out, const Vector &v) {
      return out << v.x() << "\t" << v.y() << "\t"  << v.z() <<"\t";
    }
 
    inline std::istream&
    operator>> (std::istream &in, Vector &v) {
      return in >> v.x() >> v.y() >> v.z();
    }
 
    inline Vector
    operator* (const double & k, const Vector &v) {
      return v*k;
    }
 
    inline double
    operator* (const Vector &a, const Vector &b) {
      return a.x()*b.x() + a.y()*b.y() + a.z()*b.z();
    }
 
    inline double
    get_angle_between_unit_vector (const Vector &a, const Vector &b) {
      return acos(a*b);
    }
 
    inline Vector
    double_cross(const Vector& v1, const Vector& v2) {
      return ((v1^v2)^v1);
    }
 
    // Class Operators ...
    inline Vector&
    Vector::operator=(const Vector& v) {
      x() = v.x();
      y() = v.y();
      z() = v.z();
      return *this;
    }
 
    inline void
    Vector::operator+=(const Vector& a) {
      x() += a.x();
      y() += a.y();
      z() += a.z();
    }
 
    inline void
    Vector::operator-=(const Vector& a) {
      x() -= a.x();
      y() -= a.y();
      z() -= a.z();
    }
 
    inline void
    Vector::operator*=(double k) {
      x() *= k;
      y() *= k;
      z() *= k;
    }
 
    inline void
    Vector::operator/= (double k) {
      x() /= k;
      y() /= k;
      z() /= k;
    }
 
    inline double
    Vector::squared_norm() const {
      return x()*x() + y()*y() + z()*z();
    }
 
    inline double
    Vector::Norm1() const {
      return fabs(x()) + fabs(y()) + fabs(z());
    }
 
    // Other Methods
    inline void
    Vector::clear() {
      x() = 0.;
      y() = 0.;
      z() = 0.;
    }
 
    inline bool
    Vector::is_null() const {
      return (norm() < constant::epsilon);
    }
 
    inline bool
    Vector::is_nan() const {
      if (x()!=x())
        return true;
      if (y()!=y())
        return true;
      if (z()!=z())
        return true;
      return false;
    }
 
    inline bool
    Vector::is_unit() const {
      const double n = norm();
      return (n > 1 - constant::epsilon && n < 1 + constant::epsilon); 
    }
 
    inline Vector
    Vector::unit() const {
      Vector v1 (*this);
      v1.normalize();
      return v1;
    }
 
    // External Operators ...
    inline Vector
    operator+ (const Vector &a, const Vector &b) {
      return Vector (a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
    }
 
    inline Vector
    operator- (const Vector &a, const Vector &b) {
      return Vector (a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
    }
 
    inline Vector
    operator- (const Vector &a) {
      return Vector (-a.x(), -a.y(), -a.z());
    }
 
    inline Vector
    operator* (const Vector &a, const double &d) {
      return Vector (d*a.x(), d*a.y(), d*a.z());
    }
 
    inline Vector
    operator/ (const Vector &a, const double &k) {
      SafeModeAssert(k != 0., "can't divide a vector by a null value");
      return Vector (a.x() / k, a.y() / k, a.z() / k);
    }
 
    inline double
    Vector::norm() const {
      return sqrt(x()*x() + y()*y() + z()*z());
    }
 
    inline Vector
    operator^ (const Vector &a, const Vector &b) {
      return Vector (a.y()*b.z() - a.z()*b.y(),
                     a.z()*b.x() - a.x()*b.z(),
                     a.x()*b.y() - a.y()*b.x());
    }
 
    inline double
    Vector::normalize() {
      const double n = norm();
      if (n == 0.) {
        x() = 0.;
        y() = 0.;
        z() = 0.;
        return 0.;
      } else {
        *this /= n;
        return n;
      }
    }
 
#endif
 
  }
}
 
 
#endif