FVector.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

namespace Imagine {


    template <typename T,int dim> class FVector : public FArray<T,dim> {
        typedef FArray<T,dim> Base;
    public:
        FVector(){}
        explicit FVector(const T& v) : Base(v) {}
        template <typename T2> FVector(const T2 t[dim]) : Base(t) {}
        template <typename T2> FVector(const FArray<T2,dim>& a) : Base(a) {}
        FVector(T x, T y) : Base(x,y) {}
        FVector(T x, T y, T z) : Base(x,y,z) {}
        FVector& fill(const T& v) { Base::fill(v); return *this; }
        static FVector Zero() {
            FVector Z;
            memset(Z._data,0,dim*sizeof(T));
            return Z;
        }
        template <typename T2> 
        FVector& operator = (const FArray<T2,dim>& b) { Base::operator=(b); return *this; }
        const T& x() const { assert(dim>=1); return (*this)[0]; }
        T& x() { assert(dim>=1); return (*this)[0]; }
        const T& y() const { assert(dim>=2); return (*this)[1]; }
        T& y() { assert(dim>=2); return (*this)[1]; }
        const T& z() const { assert(dim>=3); return (*this)[2]; }
        T& z() { assert(dim>=3); return (*this)[2]; }
        FVector operator + (const FVector& v) const {
            FVector w;
            for (int i=0;i<dim;i++)
                w[i]=(*this)[i]+v[i];
            return w;
        }
        FVector operator - (const FVector& v) const {
            FVector w;
            for (int i=0;i<dim;i++)
                w[i]=(*this)[i]-v[i];
            return w;
        }
        FVector& operator += (const FVector& v) {
            for (int i=0;i<dim;i++)
                (*this)[i] += v[i];
            return *this;
        }
        FVector& operator -= (const FVector& v) {
            for (int i=0;i<dim;i++)
                (*this)[i] -= v[i];
            return *this;
        }
        FVector operator + (T s) const {
            FVector w;
            for (int i=0;i<dim;i++)
                w[i]=(*this)[i]+s;
            return w;
        }
        FVector operator - (T s) const {
            FVector w;
            for (int i=0;i<dim;i++)
                w[i]=(*this)[i]-s;
            return w;
        }
        FVector& operator += (T s) {
            for (int i=0;i<dim;i++)
                (*this)[i] += s;
            return *this;
        }
        FVector& operator -= (T s) {
            for (int i=0;i<dim;i++)
                (*this)[i] -= s;
            return *this;
        }
        FVector operator - () const {
            FVector w;
            for (int i=0;i<dim;i++)
                w[i]=-(*this)[i];
            return w;
        }
        T operator * (const FVector& v) const {
            T s=0;
            for (int i=0;i<dim;i++)
                s+=(*this)[i]*v[i];
            return s;
        }
        T operator ^ (const FVector<T,2>& v) const {
            assert(dim==2);
            return (*this)[0]*v[1]-(*this)[1]*v[0];
        }
        FVector<T,3> operator ^ (const FVector<T,3>& v) const {
            assert(dim==3);
            FVector<T,3> w;
            w[0]=(*this)[1]*v[2]-(*this)[2]*v[1];
            w[1]=(*this)[2]*v[0]-(*this)[0]*v[2];
            w[2]=(*this)[0]*v[1]-(*this)[1]*v[0];
            return w;
        }
        FVector operator*(T s) const {
            FVector v;
            for (int i=0;i<dim;i++)
                v[i]=(*this)[i]*s;
            return v;
        }
        FVector operator/(T s) const {
            FVector v;
            for (int i=0;i<dim;i++)
                v[i]=(*this)[i]/s;
            return v;
        }
        FVector& operator*=(T s) {
            for (int i=0;i<dim;i++)
                (*this)[i] *= s;
            return *this;
        }
        FVector& operator/=(T s) {
            for (int i=0;i<dim;i++)
                (*this)[i] /= s;
            return *this;
        }
        friend inline FVector operator*(T s,const FVector& v) {
            return v*s;
        }
        friend inline FVector operator+(T s,const FVector& v) {
            return v+s;
        }
        friend inline FVector operator-(T s,const FVector& v) {
            return (-v)+s;
        }
        friend inline T norm2(const FVector& v) {
            T n=0;
            for (int i=0;i<dim;i++)
                n+=v[i]*v[i];
            return n;
        }
        friend inline T norm(const FVector& v) {
            assert( !std::numeric_limits<T>::is_integer );
            return ::sqrt(norm2(v));
        }
        FVector& normalize() {
            T n=norm(*this);
            if (n!=0) return operator /= (n);
            return *this;
        }
        friend inline FVector normalized(const FVector& v) {
            T n=norm(v);
            assert(n!=0);
            return v/n;
        }
        friend inline T maxNorm(const FVector& v) {
            T mx = std::abs(v[0]);
            for (int i=0;i<dim;i++){
                T a = std::abs(v[i]);
                if (a>mx) mx = a;
            }
            return mx;
        }
        friend inline int intNorm1(const FVector & v)
        {
            assert( std::numeric_limits<T>::is_integer );
            int n = 0;
            for(int i=0; i < dim; ++i)
                n+= abs(v[i]);
            return n;
        }
        friend inline int intNorm2(const FVector& v) {
            assert( std::numeric_limits<T>::is_integer );
            int n=0;
            for (int i=0;i<dim;i++)
                n+=int(v[i])*int(v[i]);
            return n;
        }
        friend inline double doubleNorm1(const FVector& v) {
            double d=0;
            for (int i=0;i<dim;++i)
                d+=fabs(double(v[i]));
            return d;
        }
        friend inline double doubleNorm2(const FVector& v) {
            double n=0;
            for (int i=0;i<dim;i++)
                n+=double(v[i])*double(v[i]);
            return n;
        }
        friend inline double doubleNorm(const FVector& v) {
            return ::sqrt(doubleNorm2(v));
        }
        friend inline T sum(const FVector& v) {
            T n=0;
            for (int i=0;i<dim;i++)
                n+=v[i];
            return n;
        }
        friend inline FVector mult(const FVector &v, const FVector& w) {
            FVector r;
            for (int i=0;i<dim;i++)
                r[i]=v[i]*w[i];
            return r;
        }
        friend inline FVector div(const FVector &v, const FVector& w) { 
            FVector r;
            for (int i=0;i<dim;i++)
                r[i]=v[i]/w[i];
            return r;
        }
        friend inline FVector sqrt(const FVector& a) {
            assert( !std::numeric_limits<T>::is_integer );
            FVector v;
            for (int i=0;i<dim;i++)
                v[i]=::sqrt(a._data[i]);
            return v;
        }
        friend inline FVector log(const FVector& a) {
            assert( !std::numeric_limits<T>::is_integer );
            FVector v;
            for (int i=0;i<dim;i++)
                v[i]=::log(a._data[i]);
            return v;
        }
        friend inline FVector exp(const FVector& a) {
            assert( !std::numeric_limits<T>::is_integer );
            FVector v;
            for (int i=0;i<dim;i++)
                v[i]=::exp(a._data[i]);
            return v;
        }
        friend inline FVector pmin(const FVector& a, const FVector& b) {
            FVector m;
            for (int i=0;i<dim;++i)
                m[i]=std::min(a[i],b[i]);
            return m;
        }
        friend inline FVector pmax(const FVector& a, const FVector& b) {
            FVector m;
            for (int i=0;i<dim;++i)
                m[i]=std::max(a[i],b[i]);
            return m;
        }
        friend inline int intL1Dist(const FVector &a, const FVector& b) {
            assert( std::numeric_limits<T>::is_integer );
            int n=0;
            for (int i = 0; i<dim; ++i)
                n += abs(int(a[i])-int(b[i]));
            return n;
        }
        friend inline double L1Dist(const FVector &a, const FVector& b) {
            double d=0;
            for (int i = 0; i < dim; ++i)
                d += fabs(double(a[i])-double(b[i]));
            return d;
        }
        friend inline double squaredDist(const FVector &a, const FVector& b) {
            double d=0;
            for (int i=0;i<dim;i++) {
                double e=double(a[i])-double(b[i]);
                d+=e*e;
            }
            return d;
        }
        friend inline double dist(const FVector&a, const FVector& b) {
            return std::sqrt( squaredDist(a,b) );
        }
    };


}