vec.h

Go to the documentation of this file.

#ifndef _RHEO_VEC_H
#define _RHEO_VEC_H

# include "rheolef/array.h"
# include "boost/numeric/ublas/storage.hpp"

namespace rheolef {

using boost::numeric::ublas::basic_range;
using boost::numeric::ublas::range;
template <class Expr>       struct vec_expr;
template <class T, class M> class vec_range;
template <class T, class M> class vec_range_const;

template <class T, class M> class vec_concat_value;

template <class T, class M = rheo_default_memory_model>
class vec : public array<T, M> {
public:


    typedef array<T, M> base;
    typedef typename base::size_type                         size_type;
    typedef std::ptrdiff_t                                   difference_type;
#ifdef TODO
    typedef typename base::difference_type                   difference_type;
#endif // TODO
    typedef basic_range<size_type, difference_type>          range_type;
    typedef typename base::reference                         reference;
    typedef typename base::const_reference                   const_reference;
    typedef typename base::iterator                          iterator;
    typedef typename base::const_iterator                    const_iterator;

// allocator/deallocator:

    vec (const distributor& ownership,
        const T&  init_val = std::numeric_limits<T>::max());

    vec(size_type dis_size = 0,
        const T&  init_val = std::numeric_limits<T>::max());

    void resize (
        const distributor& ownership,
        const T&  init_val = std::numeric_limits<T>::max());

    void resize (
        size_type size = 0,
        const T&  init_val = std::numeric_limits<T>::max());


    const_reference operator[] (size_type i) const;
    reference       operator[] (size_type i);

    T max_abs () const;


    vec(const vec_range<T,M>& vr);
    vec(const vec_range_const<T,M>& vr);
    vec<T,M>& operator= (const vec_range<T,M>& vr);
    vec<T,M>& operator= (const vec_range_const<T,M>& vr);

    vec_range_const<T,M> operator[] (const range_type& r) const;
    vec_range<T,M>       operator[] (const range_type& r);


    vec<T,M>& operator= (const int& expr);
    vec<T,M>& operator= (const T& expr);


    template<typename Expr>
    vec (const vec_expr<Expr>& expr);

    template<typename Expr>
    vec<T,M>& operator= (const vec_expr<Expr>& expr);


#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
    vec (const std::initializer_list<vec_concat_value<T,M> >& init_list);
    vec<T,M>& operator= (const std::initializer_list<vec_concat_value<T,M> >& init_list);
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST
};
@endcode

template <class T, class M>
inline
vec<T,M>::vec (
    const distributor& ownership,
    const T&  init_val)
  : array<T,M>(ownership,init_val)
{
}
template <class T, class M>
inline
vec<T,M>::vec (
    size_type dis_size,
    const T&  init_val)
  : array<T,M>(dis_size,init_val)
{
}
template <class T, class M>
inline
void
vec<T,M>::resize (
        const distributor& ownership,
        const T&  init_val)
{
    base::resize (ownership, init_val);
}
template <class T, class M>
inline
void
vec<T,M>::resize (
        size_type dis_size,
        const T&  init_val)
{
    base::resize (dis_size, init_val);
}
template <class T, class M>
inline
vec<T,M>&
vec<T,M>::operator= (const int& expr)
{
    std::fill (array<T,M>::begin(), array<T,M>::end(), expr);
    return *this;
}
template <class T, class M>
inline
vec<T,M>&
vec<T,M>::operator= (const T& expr)
{
    std::fill (array<T,M>::begin(), array<T,M>::end(), expr);
    return *this;
}
template <class T, class M>
inline
vec<T,M>&
vec<T,M>::operator= (const vec_range_const<T,M>& vr)
{
    distributor ownership (distributor::decide, vr._u.comm(), vr._r.size());
    resize (ownership);
    std::copy (vr.begin(), vr.end(), base::begin());
    return *this;
}
template <class T, class M>
inline
vec<T,M>&
vec<T,M>::operator= (const vec_range<T,M>& vr)
{
    operator= (vec_range_const<T,M>(vr));
    return *this;
}
template <class T, class M>
inline
vec<T,M>::vec(const vec_range<T,M>& vr)
  : array<T,M>()
{
    operator= (vr);
}
template <class T, class M>
inline
vec<T,M>::vec(const vec_range_const<T,M>& vr)
  : array<T,M>()
{
    operator= (vr);
}
template <class T, class M>
inline
typename vec<T,M>::const_reference
vec<T,M>::operator[] (size_type i) const
{
    return base::operator[] (i);
}
template <class T, class M>
inline
typename vec<T,M>::reference
vec<T,M>::operator[] (size_type i)
{
    return base::operator[] (i);
}
template <class T, class M>
inline
vec_range<T,M>
vec<T,M>::operator[] (const range_type& r)
{
    return vec_range<T,M> (*this, r);
}
template <class T, class M>
inline
vec_range_const<T,M>
vec<T,M>::operator[] (const range_type& r) const
{
    return vec_range_const<T,M> (*this, r);
}
template <class T, class M>
inline
T
vec<T,M>::max_abs () const
{
    T val = 0;
    for (const_iterator iter = base::begin(), last = base::end(); iter != last; iter++) {
      val = std::max(val, abs(*iter));
    }
#ifdef _RHEOLEF_HAVE_MPI
    val = mpi::all_reduce (base::comm(), val, mpi::maximum<T>());
#endif // _RHEOLEF_HAVE_MPI
    return val;
}
template <class T>
inline
idiststream&
operator >> (idiststream& ips,  vec<T,sequential>& x)
{ 
    return x.get_values(ips);
}
template <class T, class M> 
inline
odiststream&
operator << (odiststream& ods, const vec<T,M>& x)
{
    iorheo::flag_type format = iorheo::flags(ods.os()) & iorheo::format_field;
    if (format [iorheo::matlab] || format [iorheo::sparse_matlab]) {
      return x.data().put_matlab (ods);
    }
    return x.put_values(ods);
}
#ifdef _RHEOLEF_HAVE_MPI
template <class T>
inline
idiststream&
operator >> (idiststream& ips,  vec<T,distributed>& x)
{ 
    return x.get_values(ips); 
}
#ifdef TO_CLEAN
template <class T> 
inline
odiststream&
operator << (odiststream& ods, const vec<T,distributed>& x)
{
    iorheo::flag_type format = iorheo::flags(ods.os()) & iorheo::format_field;
    if (format [iorheo::matlab] || format [iorheo::sparse_matlab]) {
      warning_macro ("put_matlab");
      return x.put_matlab (ods);
    }
    warning_macro ("put_default");
    return x.put_values(ods);
}
#endif // TO_CLEAN
#endif // _RHEOLEF_HAVE_MPI

} // namespace rheolef
#endif // _RHEO_VEC_H