AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

array.h

Go to the documentation of this file.

#ifndef __________animal_array_h_________________
#define __________animal_array_h_________________

#include <iostream>
//#include <animal/io.h>
#include <animal/boost/array_boost.h>
//#include <animal/container_traits.h>
#include <animal/linear.h>
#include <animal/value.h>

namespace animal {

template<std::size_t N, class T>
struct Array : public boost::array<T,N>
{   
    Array(){}
    
    explicit Array( const T& t)
    {
        for( typename animal::Array<N,T>::size_type i=0; i<N; ++i ) 
            (*this)[i]=t;   
    }
    
    // garder celle-ci ? Provoque des erreurs sur v = 0 (assignement pris pour une copie de tableau, core dumped)
    Array( const T t[N])
    {
        for( typename animal::Array<N,T>::size_type i=0; i<N; ++i ) 
            (*this)[i]=t[i];
    }
    
    Array( const T& x, const T& y )
    {
        assert( N==2 );
        (*this)[0] = x;
        (*this)[1] = y;
    } 

    Array( const T& x, const T& y, const T& z )
    {
        assert( N==3 );
        (*this)[0] = x;
        (*this)[1] = y;
        (*this)[2] = z;
    } 

    Array( const T& x, const T& y, const T& z, const T& t )
    {
        assert( N==4 );
        (*this)[0] = x;
        (*this)[1] = y;
        (*this)[2] = z;
        (*this)[3] = t;
    } 

    Array& operator += (const Array& v )
    {
        v_peq(*this,v);
        return (*this);
    }

    Array& operator -= (const Array& v )
    {
        v_meq(*this,v);
        return (*this);
    }

    Array& operator *= (const T& a )
    {
        v_teq(*this,a);
        return (*this);
    }

    Array operator + (const Array& v ) const
    {
        Array w = (*this);
        w += v;
        return w;
    }

    Array operator - (const Array& v ) const
    {
        Array w(*this);
        w -= v;
        return w;
    }

    Array operator * ( const T& a ) const
    {
        Array w = (*this);
        v_teq(w,a);
        return w;
    }
  
  friend Array operator* (const float a, const Array &u)
  {
    Array w = u;
        v_teq(w,a);
        return w;
  }

    T operator * ( const Array& v ) const
    {
        return animal::v_dot(*this,v);
    }

    Array operator - () const
    {
        Array w(*this);
        v_teq(w,-1);
        return w;
    }
    
//  /// Assign all entries
//  Array& operator = (const T& a)
//  {
//      for(std::size_t i=0; i<N; ++i)
//          (*this)[i] = a;
//      return *this;
//  }
    
};
/* \example vec2_test.cpp */
/* \example vec3_test.cpp */


template<class T,std::size_t N> inline
Array<N,T> operator * ( const T& a, const Array<N,T>& v )
{
    Array<N,T> w = v;
    v_teq(w,a);
    return w;
}

//template<class T, std::size_t N>
//std::ostream& operator << ( std::ostream& out, const animal::Array<N,T>& a )
//{
//  animal::Array<N,T>::const_iterator i,iend;
//  for( i=a.begin(), iend=a.end(); i!=iend; ++i )
//      out << *i << " ";
//  return out;
//}

template<class T, std::size_t N>
std::ostream& operator << ( std::ostream& out, const Array<N,T>& a )
{
    typename Array<N,T>::const_iterator i,iend;
    for( i=a.begin(), iend=a.end(); i!=iend; ++i )
        out << *i << " ";
    return out;
}

//template<class T, std::size_t N>
//std::istream& operator >> ( std::istream& in, animal::Array<N,T>& a )
//{
//  animal::Array<N,T>::iterator i,iend;
//  for( i=a.begin(), iend=a.end(); i!=iend; ++i )
//      in >> *i;
//  return in;
//}

template<class T, std::size_t N>
std::istream& operator >> ( std::istream& in, Array<N,T>& a )
{
    typename Array<N,T>::iterator i,iend;
    for( i=a.begin(), iend=a.end(); i!=iend; ++i )
        in >> *i;
    return in;
}

//-------------------------------------------------------------------------
// template<>
// template<int N,class T>
// struct Value< Array<N,T> >
// {
//  static inline Array<N,T> zero(){ return Array<N,T>( Value<T>::zero() ); }
// };
template<typename T,std::size_t N>
struct Value< Array<N,T> >
{
    static inline animal::Array<N,T> zero(){ return animal::Array<N,T>( animal::Value<T>::zero() ); }
};

}//animal

template<class T,int N> inline
animal::Array<N,T> cross( const animal::Array<N,T>& v, const animal::Array<N,T>& w )
{
    animal::Array<N,T> u;
    animal::v_eq_cross(u,v,w);
    return u;
}

template<class T,int N> inline
T dot( const animal::Array<N,T>& v, const animal::Array<N,T>& w )
{
    return animal::v_dot(v,w);
}













// /// dot product
// template<int N> inline
// double operator * ( const animal::Array<double,N>& v, const animal::Array<N,double>& w )
// {
//  return animal::v_dot(v,w);
// }





















// /// \f$ u * a \f$ where a is a scalar
// template<class T,std::size_t N> inline
// animal::Array<N,T> operator * ( const animal::Array<N,T>& v, const animal::Array<N,T>::value_type& a )
// {
//  animal::Array<N,T> w = v;
//  v_teq(w,a);
//  return w;
// }
// 


// 
//   /// Norm (aka l-2 norm, euclidean norm)
//   Element norm() const {
//      return Numerics<Element>::sqroot( sqnorm() );
//  }
//   
//   /// Square norm
//   Element sqnorm() const {
//      Element sqn = 0;
//      for( Natural i=0; i<SIZE ; ++i ){
//          sqn += _value[i] * _value[i];
//      }
//      return sqn;
//  }
//   
//   /// Infinite norm (aka l-infinity norm)
//   Element inftNorm() const {
//      Element infn = fabs( _value[0] );
//      for( Natural i=1; i<SIZE ; ++i ){
//          Element f = fabs( _value[i] );
//          if( f > infn ) infn = f;
//      }
//      return infn;
//  }
  






#endif

---