VectorT.hh

/* ========================================================================= *
 *                                                                           *
 *                               OpenMesh                                    *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openmesh.org                               *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenMesh.                                            *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
 * ========================================================================= */





//=============================================================================
//
//  CLASS VectorT
//
//=============================================================================

// Don't parse this header file with doxygen since
// for some reason (obviously due to a bug in doxygen,
// bugreport: https://bugzilla.gnome.org/show_bug.cgi?id=629182)
// macro expansion and preprocessor defines
// don't work properly.

#if ((defined(_MSC_VER) && (_MSC_VER >= 1900)) || __cplusplus > 199711L || defined(__GXX_EXPERIMENTAL_CXX0X__)) && !defined(OPENMESH_VECTOR_LEGACY)
#include "Vector11T.hh"
#else
#ifndef DOXYGEN

#ifndef OPENMESH_VECTOR_HH
#define OPENMESH_VECTOR_HH


//== INCLUDES =================================================================

#include <OpenMesh/Core/System/config.h>
#include <ostream>
#include <cmath>
#include <cassert>
#include <cstring>

#if defined(__GNUC__) && defined(__SSE__)
#include <xmmintrin.h>
#endif

//== NAMESPACES ===============================================================


namespace OpenMesh {


//== CLASS DEFINITION =========================================================


template<typename Scalar, int N> class VectorDataT {
    public:
        Scalar values_[N];
};


#if defined(__GNUC__) && defined(__SSE__)

template<> class VectorDataT<float, 4> {
    public:
        union {
            __m128 m128;
            float values_[4];
        };
};

#endif




//== CLASS DEFINITION =========================================================


#define DIM               N
#define TEMPLATE_HEADER   template <typename Scalar, int N>
#define CLASSNAME         VectorT
#define DERIVED           VectorDataT<Scalar,N>
#define unroll(expr)      for (int i=0; i<N; ++i) expr(i)

#include "VectorT_inc.hh"

#undef  DIM
#undef  TEMPLATE_HEADER
#undef  CLASSNAME
#undef  DERIVED
#undef  unroll




//== PARTIAL TEMPLATE SPECIALIZATIONS =========================================
#if OM_PARTIAL_SPECIALIZATION


#define TEMPLATE_HEADER        template <typename Scalar>
#define CLASSNAME              VectorT<Scalar,DIM> 
#define DERIVED                VectorDataT<Scalar,DIM>


#define DIM                    2
#define unroll(expr)           expr(0) expr(1)
#define unroll_comb(expr, op)  expr(0) op expr(1)
#define unroll_csv(expr)       expr(0), expr(1)
#include "VectorT_inc.hh"
#undef  DIM
#undef  unroll
#undef  unroll_comb
#undef  unroll_csv


#define DIM                    3
#define unroll(expr)           expr(0) expr(1) expr(2)
#define unroll_comb(expr, op)  expr(0) op expr(1) op expr(2)
#define unroll_csv(expr)       expr(0), expr(1), expr(2)
#include "VectorT_inc.hh"
#undef  DIM
#undef  unroll
#undef  unroll_comb
#undef  unroll_csv


#define DIM                    4
#define unroll(expr)           expr(0) expr(1) expr(2) expr(3)
#define unroll_comb(expr, op)  expr(0) op expr(1) op expr(2) op expr(3)
#define unroll_csv(expr)       expr(0), expr(1), expr(2), expr(3)
#include "VectorT_inc.hh"
#undef  DIM
#undef  unroll
#undef  unroll_comb
#undef  unroll_csv
    
#define DIM                    5
#define unroll(expr)           expr(0) expr(1) expr(2) expr(3) expr(4)
#define unroll_comb(expr, op)  expr(0) op expr(1) op expr(2) op expr(3) op expr(4)
#define unroll_csv(expr)       expr(0), expr(1), expr(2), expr(3), expr(4)
#include "VectorT_inc.hh"
#undef  DIM
#undef  unroll
#undef  unroll_comb
#undef  unroll_csv

#define DIM                    6
#define unroll(expr)           expr(0) expr(1) expr(2) expr(3) expr(4) expr(5)
#define unroll_comb(expr, op)  expr(0) op expr(1) op expr(2) op expr(3) op expr(4) op expr(5)
#define unroll_csv(expr)       expr(0), expr(1), expr(2), expr(3), expr(4), expr(5)
#include "VectorT_inc.hh"
#undef  DIM
#undef  unroll
#undef  unroll_comb
#undef  unroll_csv
    

#undef  TEMPLATE_HEADER
#undef  CLASSNAME
#undef  DERIVED




//== FULL TEMPLATE SPECIALIZATIONS ============================================
#else

template<>
inline VectorT<float,3>
VectorT<float,3>::operator%(const VectorT<float,3>& _rhs) const 
{
   return 
     VectorT<float,3>(values_[1]*_rhs.values_[2]-values_[2]*_rhs.values_[1],
                      values_[2]*_rhs.values_[0]-values_[0]*_rhs.values_[2],
                      values_[0]*_rhs.values_[1]-values_[1]*_rhs.values_[0]);
}
  

template<>
inline VectorT<double,3>
VectorT<double,3>::operator%(const VectorT<double,3>& _rhs) const
{
 return 
   VectorT<double,3>(values_[1]*_rhs.values_[2]-values_[2]*_rhs.values_[1],
                     values_[2]*_rhs.values_[0]-values_[0]*_rhs.values_[2],
                     values_[0]*_rhs.values_[1]-values_[1]*_rhs.values_[0]);
}

#endif



//== GLOBAL FUNCTIONS =========================================================


template<typename Scalar1, typename Scalar2,int N>
inline VectorT<Scalar1,N> operator*(Scalar2 _s, const VectorT<Scalar1,N>& _v) {
  return _v*_s;
}


template<typename Scalar, int N>
inline Scalar 
dot(const VectorT<Scalar,N>& _v1, const VectorT<Scalar,N>& _v2) {
  return (_v1 | _v2); 
}


template<typename Scalar, int N>
inline VectorT<Scalar,N> 
cross(const VectorT<Scalar,N>& _v1, const VectorT<Scalar,N>& _v2) {
  return (_v1 % _v2);
}


template<typename Scalar, int DIM>
Scalar norm(const VectorT<Scalar, DIM>& _v) {
    return _v.norm();
}


template<typename Scalar, int DIM>
Scalar sqrnorm(const VectorT<Scalar, DIM>& _v) {
    return _v.sqrnorm();
}


template<typename Scalar, int DIM, typename OtherScalar>
VectorT<Scalar, DIM>& vectorize(VectorT<Scalar, DIM>& _v, OtherScalar const& _val) {
    return _v.vectorize(_val);
}


template<typename Scalar, int DIM>
VectorT<Scalar, DIM>& normalize(VectorT<Scalar, DIM>& _v) {
    return _v.normalize();
}


template<typename Scalar, int DIM>
VectorT<Scalar, DIM>& maximize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
    return _v1.maximize(_v2);
}


template<typename Scalar, int DIM>
VectorT<Scalar, DIM>& minimize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
    return _v1.minimize(_v2);
}


//== TYPEDEFS =================================================================

typedef VectorT<signed char,1> Vec1c;
typedef VectorT<unsigned char,1> Vec1uc;
typedef VectorT<signed short int,1> Vec1s;
typedef VectorT<unsigned short int,1> Vec1us;
typedef VectorT<signed int,1> Vec1i;
typedef VectorT<unsigned int,1> Vec1ui;
typedef VectorT<float,1> Vec1f;
typedef VectorT<double,1> Vec1d;

typedef VectorT<signed char,2> Vec2c;
typedef VectorT<unsigned char,2> Vec2uc;
typedef VectorT<signed short int,2> Vec2s;
typedef VectorT<unsigned short int,2> Vec2us;
typedef VectorT<signed int,2> Vec2i;
typedef VectorT<unsigned int,2> Vec2ui;
typedef VectorT<float,2> Vec2f;
typedef VectorT<double,2> Vec2d;

typedef VectorT<signed char,3> Vec3c;
typedef VectorT<unsigned char,3> Vec3uc;
typedef VectorT<signed short int,3> Vec3s;
typedef VectorT<unsigned short int,3> Vec3us;
typedef VectorT<signed int,3> Vec3i;
typedef VectorT<unsigned int,3> Vec3ui;
typedef VectorT<float,3> Vec3f;
typedef VectorT<double,3> Vec3d;
typedef VectorT<bool,3> Vec3b;

typedef VectorT<signed char,4> Vec4c;
typedef VectorT<unsigned char,4> Vec4uc;
typedef VectorT<signed short int,4> Vec4s;
typedef VectorT<unsigned short int,4> Vec4us;
typedef VectorT<signed int,4> Vec4i;
typedef VectorT<unsigned int,4> Vec4ui;
typedef VectorT<float,4> Vec4f;
typedef VectorT<double,4> Vec4d;

typedef VectorT<signed char, 5> Vec5c;
typedef VectorT<unsigned char, 5> Vec5uc;
typedef VectorT<signed short int, 5> Vec5s;
typedef VectorT<unsigned short int, 5> Vec5us;
typedef VectorT<signed int, 5> Vec5i;
typedef VectorT<unsigned int, 5> Vec5ui;
typedef VectorT<float, 5> Vec5f;
typedef VectorT<double, 5> Vec5d;

typedef VectorT<signed char,6> Vec6c;
typedef VectorT<unsigned char,6> Vec6uc;
typedef VectorT<signed short int,6> Vec6s;
typedef VectorT<unsigned short int,6> Vec6us;
typedef VectorT<signed int,6> Vec6i;
typedef VectorT<unsigned int,6> Vec6ui;
typedef VectorT<float,6> Vec6f;
typedef VectorT<double,6> Vec6d;


//=============================================================================
} // namespace OpenMesh
//=============================================================================


#endif // OPENMESH_VECTOR_HH defined
//=============================================================================
#endif // DOXYGEN
#endif // C++11