VVectorFun.h

// -*- C++ -*-
#ifndef __VVECTORFUN_H__
#define __VVECTORFUN_H__

#include "VVector.h"
#include <math.h>
#include <functional>
#include "vuVector.h"

namespace math {
using math::VVector;
//----------------------------------------------------------------------------
//operators

template<typename T, int N>
T dot(const VVector<T,N>& a, const VVector<T,N>& b) {
    T res(0);
    for(typename VVector<T,N>::value_cptr ai=a.begin(), bi=b.begin(); 
        ai!=a.end(); ai++, bi++)
        res+=(*ai)*(*bi);
    return res;
}

template<typename T>
VVector<T,3> cross(const VVector<T,3>& a, const VVector<T,3>& b) 
{
    VVector<T,3> p;
    p[0] = a.val[1]*b.val[2] - a.val[2]*b.val[1];
    p[1] = a.val[2]*b.val[0] - a.val[0]*b.val[2];
    p[2] = a.val[0]*b.val[1] - a.val[1]*b.val[0];
    return p;
}

// //! cross product
// template<typename T>
// VVector<T,4> cross(const VVector<T,4>& a, const VVector<T,4>& b) 
// {
//     VVector<T,4> v;
//     v[0] = r[1]*s[2]*t[3] + r[2]*s[3]*t[1] + r[3]*s[1]*t[2] 
//          - r[1]*s[3]*t[2] - r[2]*s[1]*t[3] - r[3]*s[2]*t[1];
//     v[1] = r[0]*s[3]*t[2] + r[2]*s[0]*t[3] + r[3]*s[2]*t[0] 
//          - r[0]*s[2]*t[3] - r[2]*s[3]*t[0] - r[3]*s[0]*t[2];
//     v[2] = r[0]*s[1]*t[3] + r[1]*s[3]*t[0] + r[3]*s[0]*t[1] 
//          - r[0]*s[3]*t[1] - r[1]*s[0]*t[3] - r[3]*s[1]*t[0];
//     v[3] = r[0]*s[2]*t[1] + r[1]*s[0]*t[2] + r[2]*s[1]*t[0] 
//          - r[0]*s[1]*t[2] - r[1]*s[2]*t[0] - r[2]*s[0]*t[1];
//     return v;
// }

template<typename T, int N>
T norm2(const VVector<T,N>& a) {
    T res(0);
    for(typename VVector<T,N>::value_cptr ai=a.begin(); ai!=a.end(); ai++)
        res+=(*ai)*(*ai);
    return res;
}

template<typename T, int N>
double norm(const VVector<T,N>& a) {
    return sqrt(double(norm2(a)));
}

template<typename T, int N>
T normalize(VVector<T,N>& a) {
    T length = norm(a);
    if ( length ) a *= T(1)/length;
    return length;
}

template<typename T, int N> T product(const VVector<T,N>& v) {
    T res = v[0];
    for(const T* e=v.begin()+1; e!=v.end(); e++) res *= *e;
    return res;
}

template<typename T, int N> T sum(const VVector<T,N>& v) {
    T res = v[0];
    for(const T* e=v.begin()+1; e!=v.end(); e++) res += *e;
    return res;
}

template<typename T, int N> T max(const VVector<T,N>& v) {
    T res = v[0];
    for(const T* e=v.begin()+1; e!=v.end(); e++)
        if(res<*e) res = *e;
    return res;
}

template<typename T, int N> T min(const VVector<T,N>& v) {
    T res = v[0];
    for(const T* e=v.begin()+1; e!=v.end(); e++)
        if(res>*e) res = *e;
    return res;
}
template<typename T, int N>
VVector<T,N>& maxVector(const VVector<T,N>& a, const VVector<T,N>& b, 
                        VVector<T,N>& target) 
{
    T* ti=target.begin();
    for(const T *ai=a.begin(), *bi=b.begin(); 
        ai!=a.end(); ai++, bi++, ti++)
        *ti = std::max(*ai,*bi);
    return target;
}
template<typename T, int N>
VVector<T,N> maxVector(const VVector<T,N>& a, const VVector<T,N>& b) 
{
    VVector<T,N> target; return maxVector(a,b,target);
}
template<typename T, int N>
VVector<T,N>& minVector(const VVector<T,N>& a, const VVector<T,N>& b, 
                        VVector<T,N>& target) 
{
    T* ti=target.begin();
    for(const T *ai=a.begin(), *bi=b.begin(); 
        ai!=a.end(); ai++, bi++, ti++)
        *ti = std::min(*ai,*bi);
    return target;
}
template<typename T, int N>
VVector<T,N> minVector(const VVector<T,N>& a, const VVector<T,N>& b) 
{
    VVector<T,N> target; return minVector(a,b,target);
}
template<int N>
VVector<float,N>& floor(const VVector<float,N>& a, VVector<float,N>& target) 
{
    std::transform(a.begin(), a.end(), target.begin(), std::ptr_fun(::floorf));
}
template<int N>
VVector<double,N>& floor(const VVector<double,N>& a, VVector<double,N>& target) 
{
    std::transform(a.begin(), a.end(), target.begin(), std::ptr_fun(::floor));
}
template<typename T, int N>
VVector<T,N> floor(const VVector<T,N>& a) 
{
    VVector<T,N> target; return floor(a,target);
}

template<typename T, int N, typename T2, int N2>
VVector<T,N>& convert(const VVector<T2,N2>& source, VVector<T,N>& target)
{ 
    STATIC_CHECK(N2<=N,Size_of_source_vector_has_to_be_less_or_equal);
    std::copy(source.begin(), source.end(), target.begin()); return target; 
}
//keep these just as long as vuVector is not based on VVector
template<typename T, int N>
VVector<T,N>& convert(const vuVector& source, VVector<T,N>& target)
{ 
    //STATIC_CHECK(4<=N,Size_of_source_vector_has_to_be_less_or_equal_4);
    std::transform(source.getData(), source.getData()+std::min(N,4),
                   target.begin(), Convert<float,T>()); return target; 
}
template<typename T, int N>
vuVector& convert(const VVector<T,N>& source, vuVector& target)
{ 
    STATIC_CHECK(N<=4,Size_of_source_vector_has_to_be_bigger_or_equal_4);
    std::copy(source.begin(), source.end(),
              target.getData()); return target; 
}

template<typename T>
VVector<T,2> makeVec(const T& a, const T& b) {
    //STATIC_CHECK(N==2, Constructor_only_available_if_N_is_2 );
    VVector<T,2> v;
    v.data[0] = a; v.data[1] = b;
    return v;
}
template<typename T>
VVector<T,3> makeVec(const T& a, const T& b, const T& c) {
    //STATIC_CHECK(N==3, Constructor_only_available_if_N_is_3 );
    VVector<T,3> v;
    v.data[0] = a; v.data[1] = b; v.data[2] = c;
    return v;
}
template<typename T>    
VVector<T,4> makeVec(const T& a, const T& b, const T& c, const T& d) {
    //STATIC_CHECK(N==4, Constructor_only_available_if_N_is_4 );
    VVector<T,4> v;
    v.data[0] = a; v.data[1] = b; v.data[2] = c; v.data[3] = d;
    return v;
}


} // end of namespace math

#endif

---