Improved vector and matrix documentation on C++ extension

Documentation/Doxygen/dsp.dxy.in

@@ -773,7 +773,7 @@ SHOW_FILES             = YES
 # Folder Tree View (if specified).
 # The default value is: YES.
 
-SHOW_NAMESPACES        = YES
+SHOW_NAMESPACES        = NO
 
 # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 # doxygen should invoke to get the current version for each file (typically from
@@ -2430,7 +2430,7 @@ INCLUDE_FILE_PATTERNS  =
 # recursively expanded use the := operator instead of the = operator.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-PREDEFINED             = ARM_MATH_NEON=1 ARM_FLOAT16_SUPPORTED=1 __STATIC_FORCEINLINE= __ALIGNED(x)=
+PREDEFINED             = HAS_VECTOR HAS_PREDICATED_LOOP ARM_MATH_NEON=1 ARM_FLOAT16_SUPPORTED=1 __STATIC_FORCEINLINE= __ALIGNED(x)=
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
 # tag can be used to specify a list of macro names that should be expanded. The

dsppp/Include/dsppp/algorithms.hpp

@@ -2,13 +2,11 @@
 /** @file */ 
 #pragma once 
 
-/** \addtogroup DSPPP C++ extension
+/** \defgroup DSPPP C++ extension
  *  C++ template extension to CMSIS-DSP. It is not yet part of
  *  the pack but the headers can be found on the 
  *  [CMSIS-DSP github](https://github.com/ARM-software/CMSIS-DSP/dsppp/Include)
  *  The principles are described in this @ref dsppp_main "page"
- *  @{
- *  @}
  */
 
 
@@ -22,7 +20,7 @@ namespace arm_cmsis_dsp {
 
 /** \addtogroup ALGO Architecture independent algorithms
  *  \ingroup DSPPP
- *  @{
+ *  Algorithms written in an architecture independent way
  */
 
 /*
@@ -32,13 +30,16 @@ Matrix transpose
 */
 
 
-/**
- * Transpose a matrix.
- *
- * @param dst Destination matrix.
- * @param src Source matrix.
- *
- */
+
+ /** @ingroup ALGO
+  *  @brief Transpose a matrix.
+  *
+  * @tparam MA Any matrix type
+  * @tparam MB Any matrix type
+  * @param dst Destination matrix.
+  * @param src Source matrix.
+  *
+  */
 template<typename MA,
          typename MB,
          typename std::enable_if<
@@ -52,6 +53,7 @@ inline void transposeTo(MA &dst,
 }
 
 
+
 /*
 
 Init a diagonal matrix (0 outside of diagonal)
@@ -110,7 +112,17 @@ inline void _identity(Matrix<P,R,R,A> &v,
 }
 
 
-
+/**
+ * @ingroup ALGO
+ * @brief Matrix x Vector product.
+ *
+ * @tparam M Any matrix type
+ * @tparam V Any vector type
+ * @param m matrix.
+ * @param v vector.
+ * @return The matrix x vector product
+ *
+ */
 template<typename M,
          typename V,
          typename std::enable_if<CompatibleStaticMatVecProduct<M,V>::value,bool>::type = true>
@@ -141,6 +153,17 @@ inline void dot(RES && res,const M&m,const V&v)
    _dot_m_v(res,m,v,CURRENT_ARCH);
 }
 
+
+ /** @ingroup ALGO
+  *  @brief Matrix x Matrix product.
+  *
+  * @tparam MA Any matrix type
+  * @tparam MB Any matrix type
+  * @param ma Matrix.
+  * @param mb Matrix.
+  * @return ma x mb matrix product
+  *
+  */
 template<typename MA,
          typename MB,
          typename std::enable_if<CompatibleStaticMatMatProduct<MA,MB>::value &&
@@ -197,13 +220,21 @@ inline typename OutputMatrix<MA,MB>::type dot(const MA&ma,const MB&mb)
    return(res);
 }
 
-/*
-
-
-Get res matrix as argument to avoid memory allocation when
-assigning the result to a different type of Matrix (like a Matrix view).
-
-*/
+ /** @ingroup ALGO
+  *  @brief Matrix x Matrix product
+  *
+  * @tparam MA Any matrix type
+  * @tparam MB Any matrix type
+  * @tparam RES Any matrix type
+  * @param res Output matrix. Result of ma x mb is written to this argument
+  * @param ma Matrix.
+  * @param mb Matrix.
+  * 
+  * Used in dynamic mode (dimension of matrix not know at build time)
+  * to avoid a memory allocation if the result matrix is already available
+  * (Enable to reuse the same matrix storage for the result in some algorithms)
+  *
+  */
 template<typename MA,
          typename MB,
          typename RES,
@@ -246,7 +277,14 @@ inline typename OutputMatrix<MA,MB>::type dot(const MA&ma,const MB&mb,const TMP
 }
 
 
-
+ /** @ingroup ALGO
+  *  @brief Create identity matrix
+  *
+  * @tparam P Datatype of matrix elements
+  * @param l Dimension of matrix (l x l)
+  * @return Identity matrix. It is a dynamic matrix (size not know at build time)
+  * 
+  */
 template<typename P>
 Matrix<P,DYNAMIC,DYNAMIC,TMP_ALLOC> mk_identity(const vector_length_t l)
 {
@@ -256,6 +294,14 @@ Matrix<P,DYNAMIC,DYNAMIC,TMP_ALLOC> mk_identity(const vector_length_t l)
 };
 
 
+ /** @ingroup ALGO
+  *  @brief Create identity matrix
+  *
+  * @tparam P Datatype of matrix elements
+  * @tparam L Matrix dimension (L x L)
+  * @return Identity matrix. It is a static matrix : size known at build time.
+  * 
+  */
 template<typename P,int L>
 Matrix<P,L,L,TMP_ALLOC> mk_identity()
 {
@@ -264,6 +310,4 @@ Matrix<P,L,L,TMP_ALLOC> mk_identity()
        return(res);
 };
 
-/*! @} */
-
 }

dsppp/Include/dsppp/matrix.hpp

@@ -463,20 +463,42 @@ struct VecRef<Matrix<P,R,C,A>,((R<0) || (C<0))>
  * 
  ****************/
 
+/**
+ * @brief  Outer product operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @tparam RHS Right hand side datatype
+ * @tparam DerivedOp Operator for the Outer operation
+ * 
+ * vector `op` vector (including matrix)
+ */
 template<typename LHS,typename RHS,typename DerivedOp>
 struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
 {
+    //! Type of vector elements
     using Scalar = typename traits<LHS>::Scalar;
 #if defined(HAS_VECTOR)
+    //! Type of vector in the architecture
     using Vector = typename traits<LHS>::Vector;
 #endif
+    /**
+    * @brief      Create an Outer operator
+    *
+    * @param lhs Left hand side expression
+    * @param rhs Right hand side expression
+    * @param op operator
+    */
     _Outer(const LHS &lhs,
             const RHS &rhs,
             const _BinaryOperator<Scalar,DerivedOp> &op):
             lhs_(lhs),rhs_(rhs),op_(op){
     }
 
-    
+    /**
+    * @brief      Create an Outer operator from another operator of same type
+    *
+    * @param other the other operator
+    */
     _Outer(const _Outer &other):
     lhs_(other.lhs_),rhs_(other.rhs_),op_(other.op_){
     }
@@ -484,6 +506,11 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
     _Outer& operator=(const _Outer& other) = delete;
     _Outer& operator=(_Outer&& other) = delete;
 
+    /**
+    * @brief   Move semantic for _Outer operator
+    *
+    * @param other the other operator
+    */
     _Outer(_Outer &&other): 
     lhs_(std::move(other.lhs_)),rhs_(std::move(other.rhs_)),op_(std::move(other.op_))
     {
@@ -491,12 +518,26 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
 
     
 
+    /**
+    * @brief   Length of the matrix (seen as vector) resulting from the outer operator
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    *
+    * @return  vector dimension
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<L>::value && IsVector<R>::value,bool>::type = true>
     vector_length_t length() const {
         return(lhs_.length() * rhs_.length());
     }
 
+    /**
+    * @brief   Rows of the matrix
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    *
+    * @return  number of rows
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<L>::value,bool>::type = true>
     vector_length_t rows() const {
@@ -504,7 +545,13 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
     }
 
 
-
+    /**
+    * @brief   Columns of the matrix
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    *
+    * @return  number of columns
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<R>::value,bool>::type = true>
     vector_length_t columns() const {
@@ -512,7 +559,15 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
     }
 
 
-
+    /**
+    * @brief   Expression value at given position
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    * @param r row index
+    * @param c column index
+    *
+    * @return  expression value
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<L>::value && 
                         IsVector<R>::value,bool>::type = true>
@@ -523,13 +578,25 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
 
   
 #if defined(HAS_VECTOR)
-    /*************
+    /*
      * 
      * For matrix
      * 
      */
 
     /* V + V */
+
+    /**
+    * @brief   Expression vector value at given position
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    * @param r row index
+    * @param c column index
+    *
+    * @return  expression vector value
+    *
+    * Vector + Vector (matrix interpreted as a Vector)
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<L>::value && 
                         IsVector<R>::value,bool>::type = true>
@@ -538,6 +605,18 @@ struct _Outer: _Expr<_Outer<LHS,RHS,DerivedOp>>
         return(op_(lhs_[r],rhs_.vector_op(c)));
     }
 
+    /**
+    * @brief   Expression vector value at given position with tail predication
+    * @tparam R Right hand side datatype
+    * @tparam L Left hand side datatype
+    * @param r row index
+    * @param c column index
+    * @param remaining remaining number of samples in loop
+    *
+    * @return  expression vector value
+    *
+    * Vector + Vector (matrix interpreted as a Vector)
+    */
     template<typename R=RHS, typename L=LHS,
              typename std::enable_if<IsVector<L>::value && 
                         IsVector<R>::value,bool>::type = true>
@@ -623,6 +702,16 @@ struct NbCols<_Outer<LHS,RHS,OP>>
 };
 
 
+/**
+* @brief   Outer product
+* @tparam VA Right hand side datatype
+* @tparam VB Left hand side datatype
+* @param a Vector a
+* @param b Vector b
+*
+* @return  Outer product of a and b
+*
+*/
 template<typename VA,typename VB,
 typename std::enable_if<vector_idx_pair<VA,VB>(),bool>::type = true>
 inline auto outer(const VA&a,const VB&b)

dsppp/Include/dsppp/matrix_view.hpp

@@ -24,18 +24,43 @@ namespace arm_cmsis_dsp {
  *  @{
  */
 
+/** @brief Matrix
+ *  @tparam T Type of the scalar
+ *  @tparam S Stride
+ */
 template<typename T,int S=1>
 struct MatrixView
 {
+   /** @brief Number of rows
+    *  @return Number of rows
+    */
    vector_length_t rows() const {return(nb_rows_);}
+
+   /** @brief Number of columns
+    *  @return Number of columns
+    */
    vector_length_t columns() const {return(nb_cols_);}
+
+    /** @brief Number of stride
+    *  @return Number of stride
+    */
    constexpr uint32_t stride() const {return(S);}
 
+    /** @brief Create matrix view on a buffer (buffer not owned by the view)
+    * @param v buffer
+    * @param rows number of rows
+    * @param cols number of columns
+    */
    explicit MatrixView(T* v,
               const vector_length_t rows,
               const vector_length_t cols):
    v_(v),nb_rows_(rows),nb_cols_(cols){};
 
+    /** @brief Create matrix view on vector (vector not owned by the view)
+    * @param v vector
+    * @param rows number of rows
+    * @param cols number of columns
+    */
    explicit MatrixView(const Vector_Base<T> &v,
               const vector_length_t rows,
               const vector_length_t cols):
@@ -55,17 +80,35 @@ struct MatrixView
    MatrixView& operator=(const MatrixView& other) = delete;
    MatrixView& operator=(MatrixView&& other)  = delete;
 
+   /** @brief Access matrix view element at given position
+    * @param r Row index
+    * @param c Column index
+    * @return reference to element
+    *
+    */
    T& operator()(const index_t r,const index_t c)
    {
      return(v_[r*stride()+c]);
    }
 
+    /** @brief Access matrix view element at given position
+    * @param r Row index
+    * @param c Column index
+    * @return reference to element
+    *
+    */
    T const operator()(const index_t r,const index_t c) const
    {
      return(v_[r*stride()+c]);
    }
 
 
+   /** @brief Assign matrix from expression
+    * @tparam Derived Datatype representing the abstract syntax tree of the expression
+    * @param other Expression
+    * @return the matrix
+    * 
+    */
    template<typename Derived>
    MatrixView& operator=(const _Expr<Derived>&other)
    {
@@ -73,6 +116,11 @@ struct MatrixView
       return(*this);
    }
 
+    /** @brief Assign constant from expression
+    * @param val The constant
+    * @return the matrix
+    * 
+    */
    MatrixView& operator=(const T val)
    {
         _Fill2D(*this,val,rows(),columns(),CURRENT_ARCH);
@@ -81,6 +129,12 @@ struct MatrixView
    }
 
 
+    /** @brief Add matrix from expression
+    * @tparam Derived Datatype representing the abstract syntax tree of the expression
+    * @param other Expression
+    * @return the matrix
+    * 
+    */
    template<typename Derived>
    MatrixView& operator +=(const _Expr<Derived>& other)
    {
@@ -88,18 +142,35 @@ struct MatrixView
       return(*this);
    };
 
+    /** @brief Add matrix from matrix view
+    * @param other Other matrix
+    * @return the matrix
+    * 
+    */
    MatrixView& operator +=(const MatrixView& other)
    {
       eval2D(*this,*this + other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+
+    /** @brief Add constant to matrix view
+    * @param other The constant
+    * @return the matrix
+    * 
+    */
    MatrixView& operator +=(const T other)
    {
       eval2D(*this,*this + other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+    /** @brief Subtract matrix from expression
+    * @tparam Derived Datatype representing the abstract syntax tree of the expression
+    * @param other expression
+    * @return the matrix
+    * 
+    */
    template<typename Derived>
    MatrixView& operator -=(const _Expr<Derived>& other)
    {
@@ -107,19 +178,34 @@ struct MatrixView
       return(*this);
    };
 
-   
+    /** @brief Subtract matrix view
+    * @param other Other matrix view
+    * @return the matrix
+    * 
+    */
    MatrixView& operator -=(const MatrixView& other)
    {
       eval2D(*this,*this - other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+    /** @brief Subtract constant
+    * @param other Other matrix
+    * @return the matrix
+    * 
+    */
    MatrixView& operator -=(const T other)
    {
       eval2D(*this,*this - other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+    /** @brief Elementwise multiply matrix view with expression
+    * @tparam Derived Datatype representing the abstract syntax tree of the expression
+    * @param other expression
+    * @return the matrix
+    * 
+    */
    template<typename Derived>
    MatrixView& operator *=(const _Expr<Derived>& other)
    {
@@ -127,18 +213,35 @@ struct MatrixView
       return(*this);
    };
 
+   /** @brief Elementwise multiply matrix view with matrix view
+    * @param other Other matrix
+    * @return the matrix
+    * 
+    */
    MatrixView& operator *=(const MatrixView& other)
    {
       eval2D(*this,*this * other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+   /** @brief Elementwise multiply matrix view constant
+    * @param other constant
+    * @return the matrix
+    * 
+    */
    MatrixView& operator *=(const T other)
    {
       eval2D(*this,*this * other,rows(),columns(),CURRENT_ARCH);
       return(*this);
    };
 
+  /**
+    * @brief  Display the matrix content for debug purpose
+    * @param stream Output stream
+    * @param other The matrix to display
+    * @return the stream
+    * 
+    */
   friend std::ostream& operator<< (std::ostream& stream, const MatrixView& other) {
         for(index_t row=0;row<other.rows();row++)
         {
@@ -152,44 +255,100 @@ struct MatrixView
         return(stream);
     }
 
+   /** @brief Create a row view with stride 1
+    * @param i row index
+    * @param start Start index in row
+    * @return row view vector
+    *
+    */
    VectorView<T,1> row(const index_t i,const index_t start=0)
    {
      return(VectorView<T,1>(v_,i*stride()+start,i*stride()+columns()));
    }
 
+    /** @brief Create a row view with stride 1
+    * @param i row index
+    * @param start Start index in row
+    * @param stop Stop index in row
+    * @return row view vector
+    *
+    */
    VectorView<T,1> row(const index_t i,const index_t start,const index_t stop)
    {
      return(VectorView<T,1>(v_,i*stride()+start,i*stride()+stop));
    }
 
+   /** @brief Create a constant row view with stride 1
+    * @param i row index
+    * @param start Start index in row
+    * @return row view vector
+    *
+    */
    const VectorView<T,1> row(const index_t i,const index_t start=0) const
    {
      return(VectorView<T,1>(v_,i*stride()+start,i*stride()+columns()));
    }
 
+   /** @brief Create a constant row view with stride 1
+    * @param i row index
+    * @param start Start index in row
+    * @param stop Stop index in row
+    * @return row view vector
+    *
+    */
    const VectorView<T,1> row(const index_t i,const index_t start,const index_t stop) const
    {
      return(VectorView<T,1>(v_,i*stride()+start,i*stride()+stop));
    }
 
+    /** @brief Create a column view vector
+    * @tparam CS column stride
+    * @param i column index
+    * @param start Start index in column
+    * @return column view vector
+    *
+    */
    template<int CS=1>
    VectorView<T,CS*S> col(const index_t i,const index_t start=0)
    {
      return(VectorView<T,CS*S>(v_,i+stride()*start,i+stride()*rows()));
    }
 
+    /** @brief Create a column view vector
+    * @tparam CS column stride
+    * @param i column index
+    * @param start Start index in column
+    * @param stop Stop index in column
+    * @return column view vector
+    *
+    */
    template<int CS=1>
    VectorView<T,CS*S> col(const index_t i,const index_t start,const index_t stop)
    {
      return(VectorView<T,CS*S>(v_,i+stride()*start,i+stride()*stop));
    }
 
+   /** @brief Create a constant column view vector
+    * @tparam CS column stride
+    * @param i column index
+    * @param start Start index in column
+    * @return column view vector
+    *
+    */
    template<int CS=1>
    const VectorView<T,CS*S> col(const index_t i,const index_t start=0) const
    {
      return(VectorView<T,CS*S>(v_,i+stride()*start,i+stride()*rows()));
    }
 
+    /** @brief Create a constant column view vector
+    * @tparam CS column stride
+    * @param i column index
+    * @param start Start index in column
+    * @param stop Stop index in column
+    * @return column view vector
+    *
+    */
    template<int CS=1>
    const VectorView<T,CS*S> col(const index_t i,const index_t start,const index_t stop) const
    {
@@ -197,7 +356,20 @@ struct MatrixView
    }
 
    #if defined(HAS_VECTOR)
+    //! Type of vectors for a vector architecture and for scalar datatype P
     using VectorType = typename vector_traits<T>::vector;
+
+    /**
+    * @brief   %Vector store at a given row,column position
+    *
+    * @param row row index
+    * @param col column index
+    * @param val %Vector value
+    * 
+    * On an architecture supporting vectors, if the scalar datatype T
+    * has a corresponding vector datatype, this function stores a vector
+    * value at row,column in this matrix.
+    */
     void matrix_store(const index_t row,
                       const index_t col,
                       const VectorType val) const
@@ -206,6 +378,19 @@ struct MatrixView
     }
 
 #if defined(HAS_PREDICATED_LOOP)
+    /**
+    * @brief   %Vector store at a given row,column position with predicated tail
+    *
+    * @param row row index
+    * @param col column index
+    * @param remaining Number of remaining samples in the loop
+    * @param val Vector value to write at index i with tail predication
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function stores a vector value at row,column index in this matrix datatype
+    * with predication
+    */
     void matrix_store_tail(const index_t row,
                            const index_t col,
                            const vector_length_t remaining,
@@ -214,6 +399,19 @@ struct MatrixView
         inner::vstore1_z<1>((typename std::remove_cv<T>::type*)(&v_[row*stride() + col]),val,remaining,inner::vctpq<T>::mk(remaining));
     }
 
+     /**
+    * @brief   %Vector operation at a given row,column position with predicated tail
+    *
+    * @param row row index
+    * @param col column index
+    * @param remaining Number of remaining samples in the loop
+    * @return the vector result of the operation
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function compute an operation at row,column index in this matrix datatype
+    * with predication
+    */
     VectorType const matrix_op_tail(const index_t row,
                                 const index_t col,
                                 const vector_length_t remaining) const
@@ -222,6 +420,17 @@ struct MatrixView
     }
 #endif
 
+     /**
+    * @brief   %Vector operation at a given row,column position
+    *
+    * @param row row index
+    * @param col column index
+    * @return the vector result of the operation
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function compute an operation at row,column index in this matrix datatype
+    */
     VectorType const matrix_op(const index_t row,
                            const index_t col) const
     {
@@ -229,6 +438,11 @@ struct MatrixView
     }
 #endif
 
+    /** @brief Fill diagonal of a matrix with a vector
+    * @tparam VA Vector datatype
+    * @param a Vector for initializing the diagonal
+    * 
+    */
     template<typename VA,
             typename std::enable_if<IsVector<VA>::value && 
             SameElementType<VA,T>::value,bool>::type = true>
@@ -237,6 +451,10 @@ struct MatrixView
        _fill_diagonal(*this,a,this->length());
     }
 
+    /** @brief Create the transposed matrix
+    * @return a matrix
+    *   
+    */
     Matrix<T,DYNAMIC,DYNAMIC,TMP_ALLOC> transpose() const
     {
        Matrix<T,DYNAMIC,DYNAMIC,TMP_ALLOC> res(columns(),rows());
@@ -244,13 +462,26 @@ struct MatrixView
        return(res);
     }
 
+    /** @brief Create a matrix of same type
+    * @return a matrix
+    *   
+    */
     Matrix<T,DYNAMIC,DYNAMIC,TMP_ALLOC> create() const
     {
        Matrix<T,DYNAMIC,DYNAMIC,TMP_ALLOC> res(rows(),columns());
        return(res);
     }
 
+     /**
+    * @brief      Pointer to storage buffer
+    * @return Pointer to storage
+    */
     T* ptr() const {return(v_);}
+
+     /**
+    * @brief      Constant pointer to storage buffer
+    * @return Pointer to storage
+    */
     const T* const_ptr() const {return(v_);}
 
 protected:

dsppp/Include/dsppp/vec.hpp

@@ -317,6 +317,17 @@ using StaticType=typename std::conditional<IsDynamic<VA>::value,VB,VA>::type;
 
 
 
+/**
+ * @brief  Addition operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @tparam RHS Right hand side datatype
+ * @param a Left hand side expression tree
+ * @param b Right hand side expression tree
+ * @return Expression representing the add
+ * 
+ * vector + vector (including matrix)
+ */
 template<typename LHS,typename RHS,
 typename std::enable_if<(!is_scalar<LHS>() || 
                         !is_scalar<RHS>()) && 
@@ -331,6 +342,16 @@ inline auto operator+(const LHS &a,const RHS &b)
     return(_Binary<typename VecLHS::type,typename VecRHS::type,_AddOp<Scalar>>(VecLHS::ref(a),VecRHS::ref(b),_AddOp<Scalar>()));
 };
 
+
+/**
+ * @brief  + operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @param a Left hand side expression tree
+ * @return Expression representing + vector
+ * 
+ * +vector  (including matrix)
+ */
 template<typename LHS,
 typename std::enable_if<!is_scalar<LHS>(),bool>::type = true>
 inline auto operator+(const LHS &a)
@@ -352,6 +373,18 @@ VectorView = expr(VectorView) or copy
 we cannot rely on the copy or move constructors.
 
 */
+
+/**
+ * @brief  Identity operator for expression
+ *
+ * @tparam LHS Left hand side datatype
+ * @param a Left hand side expression tree
+ * @return Expression representing the identity
+ * 
+ * Used to consider a vector view as an expression and force the copy
+ * of this vector view when assigned to another vector entity.
+ * 
+ */
 template<typename LHS,
 typename std::enable_if<!is_scalar<LHS>(),bool>::type = true>
 inline auto expr(const LHS &a)
@@ -361,6 +394,17 @@ inline auto expr(const LHS &a)
     return(_Unary<typename VecLHS::type,_NoOp<Scalar>>(VecLHS::ref(a),_NoOp<Scalar>()));
 };
 
+/**
+ * @brief  Identity operator for expression
+ *
+ * @tparam LHS Left hand side datatype
+ * @param a Left hand side expression tree
+ * @return Expression representing the identity
+ * 
+ * Used to consider a vector view as an expression and force the copy
+ * of this vector view when assigned to another vector entity.
+ * 
+ */
 template<typename LHS,
 typename std::enable_if<!is_scalar<LHS>(),bool>::type = true>
 inline auto copy(const LHS &a)
@@ -370,6 +414,18 @@ inline auto copy(const LHS &a)
     return(_Unary<typename VecLHS::type,_NoOp<Scalar>>(VecLHS::ref(a),_NoOp<Scalar>()));
 };
 
+
+/**
+ * @brief  Subtraction operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @tparam RHS Right hand side datatype
+ * @param a Left hand side expression tree
+ * @param b Right hand side expression tree
+ * @return Expression representing the add
+ * 
+ * vector - vector (including matrix)
+ */
 template<typename LHS,typename RHS,
 typename std::enable_if<(!is_scalar<LHS>() || 
                         !is_scalar<RHS>()) && 
@@ -385,6 +441,16 @@ inline auto operator-(const LHS &a,const RHS &b)
         VecLHS::ref(a),VecRHS::ref(b),_SubOp<Scalar>()));
 };
 
+
+/**
+ * @brief  - operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @param a Left hand side expression tree
+ * @return Expression representing the - vector
+ * 
+ * -vector (including matrix)
+ */
 template<typename LHS,
 typename std::enable_if<!is_scalar<LHS>(),bool>::type = true>
 inline auto operator-(const LHS &a)
@@ -396,6 +462,17 @@ inline auto operator-(const LHS &a)
 };
 
 
+/**
+ * @brief  Element wise multiplication operator for expressions
+ *
+ * @tparam LHS Left hand side datatype
+ * @tparam RHS Right hand side datatype
+ * @param a Left hand side expression tree
+ * @param b Right hand side expression tree
+ * @return Expression representing the *
+ * 
+ * elementwise vector * vector (including matrix)
+ */
 template<typename LHS,typename RHS,
 typename std::enable_if<(!is_scalar<LHS>() || 
                         !is_scalar<RHS>())  && 

dsppp/Include/dsppp/vector_impl.hpp

@@ -31,25 +31,79 @@ Generic evaluators.
 #include "Helium/basic.hpp"
 #include "Neon/basic.hpp"
 
-
+/** @brief Storage for a vector
+ *  @tparam P Type of the scalar
+ */
 template<typename P>
 struct Vector_Base {
 
+    //! Type of vector elements
     typedef P element_type;
 
+
+    /**
+    * @brief   Vector dimension
+    * @return Vector dimension
+    *
+    */
     vector_length_t length() const   {return(length_);};
 
+    /**
+    * @brief      Pointer to storage buffer
+    * @return Pointer to storage
+    */
     P* ptr() const {return(values_);}
+
+    /**
+    * @brief      Pointer to storage buffer at index i
+    *
+    * @param i Index in buffer
+    * @return Pointer to storage
+    *
+    */
     P* ptr(const index_t i) const {return(&values_[i]);}
 
+    /**
+    * @brief      Pointer to storage buffer
+    * @return Pointer to constant storage
+    *
+    */
     const P* const_ptr() const {return(values_);}
+
+    /**
+    * @brief      Pointer to storage buffer at index i
+    *
+    * @param i Index in buffer
+    * @return Pointer to constant storage
+    *
+    */
     const P* const_ptr(const index_t i) const {return(&values_[i]);}
 
 
+    
+    /**
+    * @brief   Iterator begin
+    *
+    * @return Pointer to start of buffer
+    *
+    */
     P* begin() const {return(values_);}
-    P* end() const {return(values_+length_);}
 
+    /**
+    * @brief   Iterator end
+    *
+    * @return Pointer to first element after end of buffer
+    *
+    */
+    P* end() const {return(values_+length_);}
 
+    /**
+    * @brief  Display the vector content for debug purpose
+    * @param stream Output stream
+    * @param other The vector to display
+    * @return the stream
+    * 
+    */
     friend std::ostream& operator<< (std::ostream& stream, const Vector_Base<P>& other) {
         constexpr int nb = 10;
         int i=0;
@@ -81,19 +135,44 @@ struct Vector_Base {
    Vector_Base(const Vector_Base& other) = delete;
    //   length_(other.length_),values_(other.values_){};
 
+
+   /**
+    * @brief      Element at index i
+    *
+    * @param i index
+    * @return     Reference to element
+    */
    P& operator[](const index_t i)
    {
        return(values_[i]);
    }
 
+   /**
+    * @brief      Element at index i
+    *
+    * @param i index
+    * @return     Reference to element
+    */
    P& operator[](const index_t i) const
    {
        return(values_[i]);
    }
 
 #if defined(HAS_VECTOR)
+    //! Type of vectors for a vector architecture and for scalar datatype P
     using Vector = typename vector_traits<P>::vector;
 
+    /**
+    * @brief   %Vector store at index i
+    *
+    * @tparam T scalar datatype
+    * @param i index
+    * @param val Vector value
+    * 
+    * On an architecture supporting vectors, if the scalar datatype T
+    * has a corresponding vector datatype, this function stores a vector
+    * value at index i in this vector datatype
+    */
     template<typename T=P,
              typename std::enable_if<vector_traits<T>::has_vector,bool>::type = true>
     void vector_store(const index_t i,const Vector val) const
@@ -102,17 +181,52 @@ struct Vector_Base {
     }
 
 #if defined(HAS_PREDICATED_LOOP)
+    /**
+    * @brief   %Vector store at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @param val Vector value to write at index i with tail predication
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function stores a vector value at index i in this vector datatype
+    * with predication
+    */
     void vector_store_tail(const index_t i,const vector_length_t remaining,const Vector val) const
     {
         inner::vstore1_z<1>((typename std::remove_cv<P>::type*)(&values_[i]),val,remaining,inner::vctpq<P>::mk(remaining));
     }
 
+    /**
+    * @brief   %Vector operation at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i with predication.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op_tail(const index_t i,const vector_length_t remaining) const
     {
         return(inner::vload1_z<1>((typename std::remove_cv<P>::type*)(&values_[i]),remaining,inner::vctpq<P>::mk(remaining)));
     }
 #endif
     
+    /**
+    * @brief   %Vector operation at index i
+    *
+    * @param i index
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op(const index_t i) const
     {
         return(inner::vload1<1>((typename std::remove_cv<P>::type*)(&values_[i])));
@@ -169,7 +283,7 @@ struct traits<Vector_Base<T>>
 #endif
 };
 
-/** @brief Vector template
+/** @brief Vector template for size knonw at build time
  *  @tparam P Type of the scalar
  *  @tparam L Vector length in number of elements. 
  *            Negative if length not known at build time. It is the default value
@@ -215,6 +329,7 @@ struct Vector:Vector_Base<P> {
    /**
     * @brief      Construct a new vector and initialize it with a list
     * 
+    *             A vector can be initialized like an array using {} syntax
     *             The length is known at build time.
     *      
     * @param l Initialization list         
@@ -233,6 +348,11 @@ struct Vector:Vector_Base<P> {
         //std::memcpy(Vector_Base<P>::values_,other.values_,vector_size);
   };
 
+  /**
+    * @brief      Create a vector from a vector using a different memory allocator
+    * 
+    * @param other Other vector using a different memory allocator
+    */
    template<template<int> typename OtherAllocator>
    explicit Vector(const Vector<P,L,OtherAllocator>& other):Vector_Base<P>(L,Vector::allocate())
    {
@@ -248,6 +368,12 @@ struct Vector:Vector_Base<P> {
         }
    };
 
+    /**
+    * @brief      Create a vector from a VectorView
+    * 
+    * @tparam S The stride of the vector view known at build time
+    * @param other The vector view
+    */
    template<int S>
    explicit Vector(const VectorView<P,S>& other):Vector_Base<P>(L,Vector::allocate())
    {
@@ -256,7 +382,16 @@ struct Vector:Vector_Base<P> {
    
 
   
-
+    /**
+    * @brief      Create a vector from an expression
+    * 
+    * @tparam Derived The type representing the abstract syntax tree
+    * @param other The expression
+    * 
+    * It is the mechanism allowing to evaluate an expression
+    * and merge all of the operators the of the expression in the
+    * same loop
+    */
    template<typename Derived>
    Vector(const _Expr<Derived>& other):Vector_Base<P>(L,Vector::allocate())
    {
@@ -284,6 +419,17 @@ struct Vector:Vector_Base<P> {
       return(*this);
    }
 
+  /**
+  * @brief      Copy result of an expression to a vector content
+  * 
+  * @tparam Derived The type representing the abstract syntax tree
+  * @param other The expression
+  * @return A reference to the vector
+  * 
+  * It is the mechanism allowing to evaluate an expression
+  * and merge all of the operators the of the expression in the
+  * same loop
+  */
   template<typename Derived>
   Vector& operator=(const _Expr<Derived>&other)
   {
@@ -292,6 +438,14 @@ struct Vector:Vector_Base<P> {
   }
 
 
+  /**
+  * @brief      Fill a vector with a constant
+  * 
+  * @tparam T The constant datatype
+  * @param other The const
+  * @return A reference to the vector
+  * 
+  */
   template<typename T,
            typename std::enable_if<is_scalar<T>(),bool>::type = true>
   Vector& operator=(const T other)
@@ -303,7 +457,14 @@ struct Vector:Vector_Base<P> {
 
    
 
-   
+   /**
+   * @brief    Elementwise add the result of an expression to a vector
+   * 
+   * @tparam Derived The type representing the abstract syntax tree of the expression
+   * @param other The expression
+   * @return A reference to the vector
+   * 
+   */
    template<typename Derived>
    Vector& operator +=(const _Expr<Derived>& other)
    {
@@ -311,18 +472,42 @@ struct Vector:Vector_Base<P> {
       return(*this);
    };
 
+   /**
+   * @brief    Elementwise add vector to another vector
+   * 
+   * @param other The vector
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator +=(const Vector& other)
    {
       eval(*this,*this + other,(vector_length_t)L,CURRENT_ARCH);
       return(*this);
    };
 
+
+   /**
+   * @brief    Elementwise add a constant to a vector
+   * 
+   * @tparam P The constant datatype
+   * @param other The expression
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator +=(const P other)
    {
       eval(*this,*this + other,(vector_length_t)L,CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+   * @brief    Elementwise subtract the result of an expression from a vector
+   * 
+   * @tparam Derived The type representing the abstract syntax tree of the expression
+   * @param other The expression
+   * @return A reference to the vector
+   * 
+   */
    template<typename Derived>
    Vector& operator -=(const _Expr<Derived>& other)
    {
@@ -330,18 +515,43 @@ struct Vector:Vector_Base<P> {
       return(*this);
    };
 
+
+   /**
+   * @brief    Elementwise subtract a vector from a vector
+   * 
+   * @param other The other vector
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator -=(const Vector& other)
    {
       eval(*this,*this - other,(vector_length_t)L,CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+   * @brief    Elementwise subtract a constant from a vector
+   * 
+   * @tparam P Datatype of the constant
+   * @param other The constant
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator -=(const P other)
    {
       eval(*this,*this - other,(vector_length_t)L,CURRENT_ARCH);
       return(*this);
    };
 
+
+   /**
+   * @brief    Elementwise multiply the result of an expression with a vector
+   * 
+   * @tparam Derived The type representing the abstract syntax tree of the expression
+   * @param other The expression
+   * @return A reference to the vector
+   * 
+   */
    template<typename Derived>
    Vector& operator *=(const _Expr<Derived>& other)
    {
@@ -349,12 +559,27 @@ struct Vector:Vector_Base<P> {
       return(*this);
    };
 
+   /**
+   * @brief    Elementwise multiply a vector with a vector
+   * 
+   * @param other The othr vector
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator *=(const Vector& other)
    {
       eval(*this,*this * other,(vector_length_t)L,CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+   * @brief    Elementwise multiply a constant with a vector
+   * 
+   * @tparam Derived Constant datatype
+   * @param other The constant
+   * @return A reference to the vector
+   * 
+   */
    Vector& operator *=(const P other)
    {
       eval(*this,*this * other,(vector_length_t)L,CURRENT_ARCH);
@@ -363,7 +588,16 @@ struct Vector:Vector_Base<P> {
 
 
 
-  
+   /**
+   * @brief    Create a vector view
+   * 
+   * @tparam S Stride known at build time
+   * @param start Start index for the vector view
+   * @param stop Stop index for the vector view (first element after the vector view)
+   *             Default is length of the vector if known at build time.
+   * @return A reference to the vector view
+   * 
+   */
    template<int S=1>
    VectorView<P,S> sub(const index_t start=0,const index_t stop=L)
    {
@@ -390,26 +624,59 @@ struct Vector:Vector_Base<P> {
 };
 
 
-
+/** @brief Vector template for dynamic vector (size known at runtime)
+ *  @tparam P Type of the scalar
+ *  @tparam Allocator Memory allocator to use. By default it is the macro `TMP_ALLOC`
+ */
 template<typename P,
          template<int> typename Allocator>
 struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
 
+    /**
+    * @brief      Allocate a buffer for this vector using the memory allocator
+    *
+    * @param length Vector dimension
+    * @return     A new memory buffer
+    */
     static char* allocate(vector_length_t length){return(Allocator<DYNAMIC>::allocate(sizeof(P)*length));};
 
     Vector() = delete;
 
+    /**
+    * @brief  Create a new vector
+    *
+    * @param length Vector dimension
+    * @param init_val Initialization value
+    */
     explicit Vector(vector_length_t length,P init_val):
     Vector_Base<P>(length,Vector::allocate(length),init_val){};
       
+    /**
+    * @brief  Create a new vector
+    *
+    * @param length Vector dimension
+    */
     explicit Vector(vector_length_t length):
     Vector_Base<P>(length,Vector::allocate(length)){};
 
+
+    /**
+    * @brief  Create a new vector
+    *
+    * @param l Initializer list
+    *          A vector can be initialized like an array using {} syntax
+    */
     explicit Vector(const std::initializer_list<P> &l)
     :Vector_Base<P>(l.size(),Vector::allocate(l.size())){
        std::memcpy(Vector_Base<P>::values_,l.data(),sizeof(P)*l.size());
     };
    
+   /**
+    * @brief  Create a new vector from a vector using a different memory allocator
+    *
+    * @tparam K Dimension of other vector (statically known or dynamic)
+    * @param other The vector to copy
+    */
    template<int K,template<int> typename OtherAllocator>
    explicit Vector(const Vector<P,K,OtherAllocator>& other):Vector_Base<P>(other.length(),Vector::allocate(other.length()))
    {
@@ -417,6 +684,11 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
    };
 
    
+   /**
+    * @brief  Create a new vector from a vector of same type
+    *
+    * @param other The vector to copy
+    */
    Vector(const Vector& other):Vector_Base<P>(other.length(),Vector::allocate(other.length()))
    {
         eval(*this,+other,Vector_Base<P>::length(),CURRENT_ARCH);
@@ -424,12 +696,24 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
         //std::memcpy(Vector_Base<P>::values_,other.values_,vector_size);
    };
 
+   /**
+    * @brief  Create a new vector from a vector view
+    *
+    * @tparam S Stride of vector view known at build time
+    * @param other The vector to copy
+    */
    template<int S>
    explicit Vector(const VectorView<P,S>& other):Vector_Base<P>(other.length(),Vector::allocate(other.length()))
    {
         eval(*this,+other,Vector_Base<P>::length(),CURRENT_ARCH);
    };
 
+   /**
+    * @brief  Create a new vector from an expressipn
+    *
+    * @tparam Derived Type representing the abstract syntax tree of the expression
+    * @param other The expression to evaluate
+    */
    template<typename Derived>
    Vector(const _Expr<Derived>& other):Vector_Base<P>(other.length(),Vector::allocate(other.length()))
    {
@@ -460,6 +744,13 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
    }
 
+  /**
+    * @brief  Fill a vector with an expression
+    *
+    * @tparam Derived Type representing the abstract syntax tree of the expression
+    * @param other The expression to evaluate
+    * @return A reference to the vector
+    */
   template<typename Derived>
   Vector& operator=(const _Expr<Derived>&other)
   {
@@ -467,6 +758,13 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
   }
 
+  /**
+    * @brief  Fill a vector with a scalar
+    *
+    * @tparam T Scalar datatype
+    * @param other The scalar
+    * @return A reference to the vector
+    */
   template<typename T,
            typename std::enable_if<is_scalar<T>(),bool>::type = true>
   Vector& operator=(const T other)
@@ -475,6 +773,13 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
   }
 
+    /**
+    * @brief  Elementwise add an expression to a vector
+    *
+    * @tparam Derived Type representing the abstract syntax tree of the expression
+    * @param other The expression to evaluate
+    * @return A reference to the vector
+    */
    template<typename Derived>
    Vector& operator +=(const _Expr<Derived>& other)
    {
@@ -482,18 +787,38 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise add a vector to a vector
+    *
+    * @param other The vector to add
+    * @return A reference to the vector
+    */
    Vector& operator +=(const Vector& other)
    {
       eval(*this,*this + other,Vector_Base<P>::length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise add a scalar to a vector
+    *
+    * @tparam P Scalar datatype
+    * @param other The scalar
+    * @return A reference to the vector
+    */
    Vector& operator +=(const P other)
    {
       eval(*this,*this + other,Vector_Base<P>::length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise subtract an expression to a vector
+    *
+    * @tparam Derived Type representing the abstract syntax tree of the expression
+    * @param other The expression to evaluate
+    * @return A reference to the vector
+    */
    template<typename Derived>
    Vector& operator -=(const _Expr<Derived>& other)
    {
@@ -501,18 +826,38 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise subtract a vector to a vector
+    *
+    * @param other The vector to add
+    * @return A reference to the vector
+    */
    Vector& operator -=(const Vector& other)
    {
       eval(*this,*this - other,Vector_Base<P>::length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise subtract a scalar to a vector
+    *
+    * @tparam P Scalar datatype
+    * @param other The scalar
+    * @return A reference to the vector
+    */
    Vector& operator -=(const P other)
    {
       eval(*this,*this - other,Vector_Base<P>::length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise multiply an expression with a vector
+    *
+    * @tparam Derived Type representing the abstract syntax tree of the expression
+    * @param other The expression to evaluate
+    * @return A reference to the vector
+    */
    template<typename Derived>
    Vector& operator *=(const _Expr<Derived>& other)
    {
@@ -520,6 +865,12 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise multiply a vector with a vector
+    *
+    * @param other The vector to add
+    * @return A reference to the vector
+    */
    Vector& operator *=(const Vector& other)
    {
       eval(*this,*this * other,Vector_Base<P>::length(),CURRENT_ARCH);
@@ -527,12 +878,28 @@ struct Vector<P,DYNAMIC,Allocator>:Vector_Base<P> {
    };
 
 
+  /**
+    * @brief  Elementwise multiply a scalar with a vector
+    *
+    * @tparam P Scalar datatype
+    * @param other The scalar
+    * @return A reference to the vector
+    */
    Vector& operator *=(const P other)
    {
       eval(*this,*this * other,Vector_Base<P>::length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Create a vector view
+    *
+    * @tparam S stride
+    * @param start Start index of view
+    * @param stop Stop index of view (first index after end of view)
+    *              By default it is the length of the vector.
+    * @return The vector view
+    */
    template<int S=1>
    VectorView<P,S> sub(const index_t start=0,const index_t stop=-1)
    {

dsppp/Include/dsppp/vector_view.hpp

@@ -22,6 +22,10 @@ namespace arm_cmsis_dsp {
  *  @{
  */
 
+/** @brief Vector view
+ *  @tparam T Type of the scalar
+ *  @tparam S Stride known at build time (default 1)
+ */
 template<typename T,int stride=1>
 struct VectorView
 {
@@ -34,58 +38,180 @@ struct VectorView
     */
     VectorView() = delete;
 
+    /**
+    * @brief  Compute the number of elements in the vector view
+    * @param start Vector view start index
+    * @param stop Vector view stop index (first elemnt after the view)
+    * @return Vector dimension
+    *
+    */
     constexpr static vector_length_t compute_length(const index_t start,const index_t stop)
     {
         return(1+(stop-1 -start)/stride);
     }
 
+    /**
+    * @brief  Create a vector view on a buffer
+    * @param v Buffer of samples (not owned by the view)
+    * @param start Start index of the view
+    * @param stop Stop index of the view (first elemnt after the view)
+    *
+    */
     explicit VectorView(T *v,const vector_length_t start,const vector_length_t stop):
       v_(v+start),nb_samples_(compute_length(start,stop)){};
 
+   /**
+    * @brief  Create a vector on a vector
+    * @param v Vector storage (not owned by the view)
+    *
+    */
     explicit VectorView(const Vector_Base<T> &v):
       v_(v.ptr()),nb_samples_(compute_length(0,v.length())){};
 
+    /**
+    * @brief  Create a vector view on vector
+    * @param v Vector storage (not owned by the view)
+    * @param start Start index of the view
+    * @param stop Stop index of the view (first elemnt after the view)
+    *
+    */
     explicit VectorView(const Vector_Base<T> &v,const index_t start,const index_t stop):
       v_(v.ptr()+start),nb_samples_(compute_length(start,stop)){};
 
+    /**
+    * @brief  Vector view dimension
+    * @return Number of elements 
+    *
+    */
     vector_length_t length() const {return(nb_samples_);};
 
 
+    /**
+    * @brief  Pointer to view storage
+    * @return Pointer to start of storage
+    *
+    */
     T* ptr() const {return(v_);}
+
+    /**
+    * @brief  Pointer to view storage at index i
+    * @param i Index
+    * @return Pointer to storage at index i
+    *
+    * The stride is used to compute this pointer.
+    * The index is scaled by the stride.
+    */
     T* ptr(const index_t i) const {return(&v_[i*stride]);}
 
+    /**
+    * @brief  Pointer to view constant storage
+    * @return Pointer to start of constant storage
+    *
+    */
     const T* const_ptr() const {return(v_);}
+
+    /**
+    * @brief  Pointer to view constant storage at index i
+    * @param i Index
+    * @return Pointer to constant storage at index i
+    *
+    * The stride is used to compute this pointer.
+    * The index is scaled by the stride.
+    */
     const T* const_ptr(const index_t i) const {return(&v_[i*stride]);}
 
+    /**
+    * @brief  Element at index i
+    * @param i Index
+    * @return Reference to element
+    *
+    * The stride is used to compute this reference.
+    * The index is scaled by the stride.
+    */
     T& operator[](const index_t i)
     {
         return(v_[i*stride]);
     }
    
+    /**
+    * @brief  Element at index i
+    * @param i Index
+    * @return Reference to element
+    *
+    * The stride is used to compute this reference.
+    * The index is scaled by the stride.
+    */
     T& operator[](const index_t i) const
     {
         return(v_[i*stride]);
     }
    
 #if defined(HAS_VECTOR)
+     //! Type of vectors for a vector architecture and for scalar datatype P
     using Vector = typename vector_traits<T>::vector;
+
+    /**
+    * @brief   %Vector store at index i
+    *
+    * @param i index
+    * @param val Vector value
+    * 
+    * On an architecture supporting vectors, if the scalar datatype T
+    * has a corresponding vector datatype, this function stores a vector
+    * value at index i in this vector datatype
+    */
     void vector_store(const index_t i,const Vector val)
     {
         inner::vstore1<stride>((typename std::remove_cv<T>::type*)(&v_[i*stride]),val);
     }
 
 #if defined(HAS_PREDICATED_LOOP)
+    /**
+    * @brief   %Vector store at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @param val Vector value to write at index i with tail predication
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function stores a vector value at index i in this vector datatype
+    * with predication
+    */
     void vector_store_tail(const index_t i,const vector_length_t remaining,const Vector val)
     {
         inner::vstore1_z<stride>((typename std::remove_cv<T>::type*)(&v_[i*stride]),val,remaining,inner::vctpq<T>::mk(remaining));
     }
 
+    /**
+    * @brief   %Vector operation at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i with predication.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op_tail(const index_t i,const vector_length_t remaining) const
     {
         return(inner::vload1_z<stride>((typename std::remove_cv<T>::type*)(&v_[i*stride]),remaining,inner::vctpq<T>::mk(remaining)));
     }
 #endif
 
+    /**
+    * @brief   %Vector operation at index i
+    *
+    * @param i index
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op(const index_t i) const
     {
         return(inner::vload1<stride>((typename std::remove_cv<T>::type*)(&v_[i*stride])));
@@ -94,10 +220,28 @@ struct VectorView
 
     virtual ~VectorView() {};
 
+    /**
+    * @brief  Create a vector view from another view
+    * @param other the other vector view
+    *
+    * The new vector view will point to the same storage as the
+    * other vector view. No copy of element is occuring.
+    * To copy vector view content, the expr and copy operators
+    * are needed.
+    */
     VectorView(const VectorView& other):
     v_(other.v_),nb_samples_(other.nb_samples_){};
   
 
+    /**
+    * @brief  Move a vector view to another view
+    * @param other the other vector view
+    *
+    * The new vector view will point to the same storage as the
+    * other vector view. No copy of element is occuring.
+    *
+    * The other vector view is no more valid (points to null storage)
+    */
     VectorView(VectorView&& other) :
      v_(std::move(other.v_)),nb_samples_(other.nb_samples_)
      {
@@ -108,7 +252,14 @@ VectorView& operator=(const VectorView& other) = delete;
 VectorView& operator=(VectorView&& other)  = delete;
 
 
-
+   /**
+    * @brief  Assign an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    * Evaluate an expression an assign its result to the vector view
+    */
    template<typename Derived>
    VectorView& operator=(const _Expr<Derived>&other)
    {
@@ -117,6 +268,12 @@ VectorView& operator=(VectorView&& other)  = delete;
    }
 
 
+   /**
+    * @brief  Assign a scalar to a vector view
+    * @param val the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator=(const T val)
    {
         _Fill(*this,val,length(),CURRENT_ARCH);
@@ -124,6 +281,13 @@ VectorView& operator=(VectorView&& other)  = delete;
         return(*this);
    }
 
+   /**
+    * @brief  Elementwise  add an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator +=(const _Expr<Derived>& other)
    {
@@ -131,18 +295,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise add a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator +=(const VectorView& other)
    {
       eval(*this,*this + other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise  add a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator +=(const T other)
    {
       eval(*this,*this + other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise  subtract an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator -=(const _Expr<Derived>& other)
    {
@@ -150,19 +333,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
-   
+    /**
+    * @brief  Elementwise subtract a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator -=(const VectorView& other)
    {
       eval(*this,*this - other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise  subtract a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator -=(const T other)
    {
       eval(*this,*this - other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise multiply an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator *=(const _Expr<Derived>& other)
    {
@@ -170,18 +371,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise multiply a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator *=(const VectorView& other)
    {
       eval(*this,*this * other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise  multiply a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator *=(const T other)
    {
       eval(*this,*this * other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+  /**
+    * @brief  Display the vector view content for debug purpose
+    * @param stream Output stream
+    * @param other The vector view to display
+    * @return the stream
+    * 
+    */
   friend std::ostream& operator<< (std::ostream& stream, const VectorView<T,stride>& other) {
         constexpr int nb = 10;
         int i=0;
@@ -199,6 +419,15 @@ VectorView& operator=(VectorView&& other)  = delete;
         return(stream);
     }
 
+   /**
+    * @brief  Create a sub vector (a view of a view)
+    * @tparam S stride known at build time
+    * @param start Start index
+    * @param stop Stop index (first element after the view)
+    *             By default it is the vector view length
+    * @return the vector view
+    * 
+    */
    template<int S=1>
    VectorView<T,S*stride> sub(const index_t start=0,const index_t stop=-1)
    {
@@ -212,6 +441,15 @@ VectorView& operator=(VectorView&& other)  = delete;
      }
    }
 
+   /**
+    * @brief  Create a constant sub vector (a view of a view)
+    * @tparam S stride known at build time
+    * @param start Start index
+    * @param stop Stop index (first element after the view)
+    *             By default it is the vector view length
+    * @return the vector view
+    * 
+    */
    template<int S=1>
    const VectorView<T,S*stride> sub(const index_t start=0,const index_t stop=-1) const
    {
@@ -231,6 +469,9 @@ protected:
     const vector_length_t nb_samples_;
 };
 
+/** @brief Vector view with dynamic stride (not known at build time)
+ *  @tparam T Type of the scalar
+ */
 template<typename T>
 struct VectorView<T,DYNAMIC>
 {
@@ -243,58 +484,190 @@ struct VectorView<T,DYNAMIC>
     */
     VectorView() = delete;
 
+    /**
+    * @brief  Compute the number of elements in the vector view
+    * @param start Vector view start index
+    * @param stop Vector view stop index (first elemnt after the view)
+    * @param stride Stride (only known at runtime)
+    * @return Vector dimension
+    *
+    */
     vector_length_t compute_length(const index_t start,const index_t stop,const index_t stride) const
     {
         return(1+(stop-1 -start)/stride);
     }
 
+    /**
+    * @brief  Create a vector view on a buffer
+    * @param v Buffer of samples (not owned by the view)
+    * @param start Start index of the view
+    * @param stop Stop index of the view (first elemnt after the view)
+    * @param stride Stride (only known at runtime)
+    *
+    */
     explicit VectorView(T *v,const index_t start,const index_t stop,const index_t stride):
       v_(v+start),nb_samples_(compute_length(start,stop,stride)),stride_(stride){};
 
+    
+    /**
+    * @brief  Create a vector view on a vector
+    * @param v Vector owning the storage (not owned by the view)
+    * @param stride Stride (only known at runtime)
+    * 
+    * start is 0
+    * stop is defined by the length of the vector
+    *
+    */
     explicit VectorView(const Vector_Base<T> &v,const index_t stride):
       v_(v.ptr()),nb_samples_(compute_length(0,v.length(),stride)),stride_(stride){};
 
+    /**
+    * @brief  Create a vector view on a vector
+    * @param v Vector owning the storage (not owned by the view)
+    * @param start Start index of the view
+    * @param stop Stop index
+    * @param stride Stride (only known at runtime)
+    * 
+    *
+    */
     explicit VectorView(const Vector_Base<T> &v,const index_t start,const index_t stop,const index_t stride):
       v_(v.ptr()+start),nb_samples_(compute_length(start,stop,stride)),stride_(stride){};
 
+    /**
+    * @brief  Vector view dimension
+    * @return Number of elements 
+    *
+    */
     vector_length_t length() const {return(nb_samples_);};
 
 
+    /**
+    * @brief  Pointer to view storage
+    * @return Pointer to start of storage
+    *
+    */
     T* ptr() const {return(v_);}
+
+    /**
+    * @brief  Pointer to view storage at index i
+    * @param i Index
+    * @return Pointer to storage at index i
+    *
+    * The stride is used to compute this pointer.
+    * The index is scaled by the stride.
+    */
     T* ptr(const index_t i) const {return(&v_[i*stride_]);}
 
+
+    /**
+    * @brief  Pointer to view constant storage
+    * @return Pointer to start of constant storage
+    *
+    */
     const T* const_ptr() const {return(v_);}
+
+    /**
+    * @brief  Pointer to view constant storage at index i
+    * @param i Index
+    * @return Pointer to constant storage at index i
+    *
+    * The stride is used to compute this pointer.
+    * The index is scaled by the stride.
+    */
     const T* const_ptr(const index_t i) const {return(&v_[i*stride_]);}
 
+    /**
+    * @brief  Element at index i
+    * @param i Index
+    * @return Reference to element
+    *
+    * The stride is used to compute this reference.
+    * The index is scaled by the stride.
+    */
     T& operator[](index_t i)
     {
         return(v_[i*stride_]);
     }
    
+    /**
+    * @brief  Element at index i
+    * @param i Index
+    * @return Reference to element
+    *
+    * The stride is used to compute this reference.
+    * The index is scaled by the stride.
+    */
     T& operator[](index_t i) const
     {
         return(v_[i*stride_]);
     }
    
 #if defined(HAS_VECTOR)
+    //! Type of vectors for a vector architecture and for scalar datatype P
     using Vector = typename vector_traits<T>::vector;
+
+    /**
+    * @brief   %Vector store at index i
+    *
+    * @param i index
+    * @param val Vector value
+    * 
+    * On an architecture supporting vectors, if the scalar datatype T
+    * has a corresponding vector datatype, this function stores a vector
+    * value at index i in this vector datatype
+    */
     void vector_store(index_t i,Vector val)
     {
         inner::vstore1((typename std::remove_cv<T>::type*)(&v_[i*stride_]),stride_,val);
     }
 
 #if defined(HAS_PREDICATED_LOOP)
+    /**
+    * @brief   %Vector store at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @param val Vector value to write at index i with tail predication
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function stores a vector value at index i in this vector datatype
+    * with predication
+    */
     void vector_store_tail(index_t i,vector_length_t remaining,Vector val)
     {
         inner::vstore1_z((typename std::remove_cv<T>::type*)(&v_[i*stride_]),stride_,val,remaining,inner::vctpq<T>::mk(remaining));
     }
 
+     /**
+    * @brief   %Vector operation at index i with predicated tail
+    *
+    * @param i index
+    * @param remaining Number of remaining samples in the loop
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors and predicated loops, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i with predication.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op_tail(index_t i,vector_length_t remaining) const
     {
         return(inner::vload1_z((typename std::remove_cv<T>::type*)(&v_[i*stride_]),stride_,remaining,inner::vctpq<T>::mk(remaining)));
     }
 #endif
     
+    /**
+    * @brief   %Vector operation at index i
+    *
+    * @param i index
+    * @return Result of operation
+    * 
+    * On an architecture supporting vectors, if the 
+    * scalar datatype T has a corresponding vector datatype, this 
+    * function execute an operation at index i.
+    * In the case of a vector, this operation is a load
+    */
     Vector const vector_op(index_t i) const
     {
         return(inner::vload1((typename std::remove_cv<T>::type*)(&v_[i*stride_]),stride_));
@@ -303,10 +676,28 @@ struct VectorView<T,DYNAMIC>
 
     virtual ~VectorView() {};
 
+    /**
+    * @brief  Create a vector view from another view
+    * @param other the other vector view
+    *
+    * The new vector view will point to the same storage as the
+    * other vector view. No copy of element is occuring.
+    * To copy vector view content, the expr and copy operators
+    * are needed.
+    */
     VectorView(const VectorView& other):
     v_(other.v_),nb_samples_(other.nb_samples_),stride_(other.stride_){};
   
 
+    /**
+    * @brief  Move a vector view to another view
+    * @param other the other vector view
+    *
+    * The new vector view will point to the same storage as the
+    * other vector view. No copy of element is occuring.
+    *
+    * The other vector view is no more valid (points to null storage)
+    */
     VectorView(VectorView&& other) :
      v_(std::move(other.v_)),nb_samples_(other.nb_samples_),stride_(other.stride_)
      {
@@ -318,6 +709,14 @@ VectorView& operator=(VectorView&& other)  = delete;
 
 
 
+   /**
+    * @brief  Assign an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    * Evaluate an expression an assign its result to the vector view
+    */
    template<typename Derived>
    VectorView& operator=(const _Expr<Derived>&other)
    {
@@ -326,6 +725,12 @@ VectorView& operator=(VectorView&& other)  = delete;
    }
 
 
+    /**
+    * @brief  Assign a scalar to a vector view
+    * @param val the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator=(const T val)
    {
         _Fill(*this,val,length(),CURRENT_ARCH);
@@ -333,6 +738,13 @@ VectorView& operator=(VectorView&& other)  = delete;
         return(*this);
    }
 
+   /**
+    * @brief  Elementwise  add an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator +=(const _Expr<Derived>& other)
    {
@@ -340,18 +752,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise add a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator +=(const VectorView& other)
    {
       eval(*this,*this + other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise  add a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator +=(const T other)
    {
       eval(*this,*this + other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise  subtract an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator -=(const _Expr<Derived>& other)
    {
@@ -359,19 +790,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
-   
+    /**
+    * @brief  Elementwise subtract a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator -=(const VectorView& other)
    {
       eval(*this,*this - other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise  subtract a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator -=(const T other)
    {
       eval(*this,*this - other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise multiply an expression to a vector view
+    * @tparam Derived the datatype representing the abstract syntax tree of the view
+    * @param other the expression
+    * @return the vector view
+    * 
+    */
    template<typename Derived>
    VectorView& operator *=(const _Expr<Derived>& other)
    {
@@ -379,18 +828,37 @@ VectorView& operator=(VectorView&& other)  = delete;
       return(*this);
    };
 
+    /**
+    * @brief  Elementwise multiply a vector view to a vector view
+    * @param other the vector view to add
+    * @return the vector view
+    * 
+    */
    VectorView& operator *=(const VectorView& other)
    {
       eval(*this,*this * other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Elementwise  multiply a scalar to a vector view
+    * @param other the scalar
+    * @return the vector view
+    * 
+    */
    VectorView& operator *=(const T other)
    {
       eval(*this,*this * other,length(),CURRENT_ARCH);
       return(*this);
    };
 
+   /**
+    * @brief  Display the vector view content for debug purpose
+    * @param stream Output stream
+    * @param other The vector view to display
+    * @return the stream
+    * 
+    */
   friend std::ostream& operator<< (std::ostream& stream, const VectorView<T,DYNAMIC>& other) {
         constexpr int nb = 10;
         int i=0;
@@ -408,9 +876,23 @@ VectorView& operator=(VectorView&& other)  = delete;
         return(stream);
     }
 
+    /**
+    * @brief  Stride of the vector view
+    * @return the stride
+    * 
+    */
     index_t stride() const {return stride_;}
 
   
+   /**
+    * @brief  Create a sub vector (a view of a view)
+    * @tparam S stride known at build time
+    * @param start Start index
+    * @param stop Stop index (first element after the view)
+    *             By default it is the vector view length
+    * @return the vector view
+    * 
+    */
    template<int S=1>
    VectorView<T,DYNAMIC> sub(const index_t start=0,const index_t stop=-1)
    {
@@ -424,6 +906,15 @@ VectorView& operator=(VectorView&& other)  = delete;
      }
    }
 
+   /**
+    * @brief  Create a constant sub vector (a view of a view)
+    * @tparam S stride known at build time
+    * @param start Start index
+    * @param stop Stop index (first element after the view)
+    *             By default it is the vector view length
+    * @return the vector view
+    * 
+    */
    template<int S=1>
    const VectorView<T,DYNAMIC> sub(const index_t start=0,const index_t stop=-1) const
    {