diff --git a/src/TNL/Containers/VectorExpressions.h b/src/TNL/Containers/VectorExpressions.h
index f6fdd51d042d7699db05aa15d63b8b4cc28ec4df..2357ca2f1335ea4b022d185626ea1e0a0e6d66d9 100644
--- a/src/TNL/Containers/VectorExpressions.h
+++ b/src/TNL/Containers/VectorExpressions.h
@@ -17,6 +17,7 @@
 #include <TNL/Containers/Expressions/VerticalOperations.h>
 
 #include "VectorView.h"
+#include "Vector.h"
 
 namespace TNL {
 
@@ -50,7 +51,7 @@ operator+( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 
 template< typename Real1, typename Real2, typename Device, typename Index >
 const Containers::Expressions::BinaryExpressionTemplate< 
-   typename Containers::VectorView< Real1, Device, Index >::ConstViewType,
+   typename Containers::Vector< Real1, Device, Index >::ConstViewType,
    typename Containers::VectorView< Real2, Device, Index >::ConstViewType,
    Containers::Expressions::Addition >
 operator+( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
@@ -63,7 +64,7 @@ operator+( const Containers::Vector< Real1, Device, Index >& a, const Containers
 ////
 // Subtraction
 template< typename Real, typename Device, typename Index, typename ET >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Subtraction >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Subtraction >
 operator-( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -71,7 +72,7 @@ operator-( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Subtraction >
+const Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Subtraction >
 operator-( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -80,7 +81,7 @@ operator-( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 
 template< typename Real1, typename Real2, typename Device, typename Index >
 const Containers::Expressions::BinaryExpressionTemplate< 
-   typename Containers::VectorView< Real1, Device, Index >::ConstViewType,
+   typename Containers::Vector< Real1, Device, Index >::ConstViewType,
    typename Containers::VectorView< Real2, Device, Index >::ConstViewType,
    Containers::Expressions::Subtraction >
 operator-( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
@@ -93,7 +94,7 @@ operator-( const Containers::Vector< Real1, Device, Index >& a, const Containers
 ////
 // Multiplication
 template< typename Real, typename Device, typename Index, typename ET >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Multiplication >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Multiplication >
 operator*( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -101,7 +102,7 @@ operator*( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Multiplication >
+const Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >
 operator*( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -109,7 +110,7 @@ operator*( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 }
 
 template< typename Real1, typename Real2, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Multiplication >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >
 operator*( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
    using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
@@ -120,7 +121,7 @@ operator*( const Containers::Vector< Real1, Device, Index >& a, const Containers
 ////
 // Division
 template< typename Real, typename Device, typename Index, typename ET >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Division >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Division >
 operator/( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -128,7 +129,7 @@ operator/( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Division >
+const Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Division >
 operator/( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -136,7 +137,7 @@ operator/( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 }
 
 template< typename Real1, typename Real2, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Division >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Division >
 operator/( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
    using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
@@ -147,7 +148,7 @@ operator/( const Containers::Vector< Real1, Device, Index >& a, const Containers
 ////
 // Min
 template< typename Real, typename Device, typename Index, typename ET >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Min >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Min >
 min( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -155,7 +156,7 @@ min( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Min >
+const Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Min >
 min( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -163,7 +164,7 @@ min( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 }
 
 template< typename Real1, typename Real2, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Min >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Min >
 min( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
    using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
@@ -174,7 +175,7 @@ min( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vect
 ////
 // Max
 template< typename Real, typename Device, typename Index, typename ET >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Max >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Max >
 max( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -182,7 +183,7 @@ max( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Max >
+const Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Max >
 max( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -190,7 +191,7 @@ max( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 }
 
 template< typename Real1, typename Real2, typename Device, typename Index >
-const Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Max >
+const Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Max >
 max( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
    using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
@@ -275,7 +276,7 @@ bool operator<( const ET& a, const Containers::Vector< Real, Device, Index >& b
 template< typename Real1, typename Real2, typename Device, typename Index >
 bool operator<( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
-   using ConstView1 = typename Containers::VectorView< Real1, Device, Index >::ConstViewType;
+   using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
    using ConstView2 = typename Containers::VectorView< Real2, Device, Index >::ConstViewType;
    return Containers::Expressions::Comparison< ConstView1, ConstView2 >::LT( a.getView(), b.getView() );
 }
@@ -299,7 +300,7 @@ bool operator<=( const ET& a, const Containers::Vector< Real, Device, Index >& b
 template< typename Real1, typename Real2, typename Device, typename Index >
 bool operator<=( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
-   using ConstView1 = typename Containers::VectorView< Real1, Device, Index >::ConstViewType;
+   using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
    using ConstView2 = typename Containers::VectorView< Real2, Device, Index >::ConstViewType;
    return Containers::Expressions::Comparison< ConstView1, ConstView2 >::LE( a.getView(), b.getView() );
 }
@@ -323,7 +324,7 @@ bool operator>( const ET& a, const Containers::Vector< Real, Device, Index >& b
 template< typename Real1, typename Real2, typename Device, typename Index >
 bool operator>( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
-   using ConstView1 = typename Containers::VectorView< Real1, Device, Index >::ConstViewType;
+   using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
    using ConstView2 = typename Containers::VectorView< Real2, Device, Index >::ConstViewType;
    return Containers::Expressions::Comparison< ConstView1, ConstView2 >::GT( a.getView(), b.getView() );
 }
@@ -347,7 +348,7 @@ bool operator>=( const ET& a, const Containers::Vector< Real, Device, Index >& b
 template< typename Real1, typename Real2, typename Device, typename Index >
 bool operator>=( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
-   using ConstView1 = typename Containers::VectorView< Real1, Device, Index >::ConstViewType;
+   using ConstView1 = typename Containers::Vector< Real1, Device, Index >::ConstViewType;
    using ConstView2 = typename Containers::VectorView< Real2, Device, Index >::ConstViewType;
    return Containers::Expressions::Comparison< ConstView1, ConstView2 >::GE( a.getView(), b.getView() );
 }
@@ -355,7 +356,7 @@ bool operator>=( const Containers::Vector< Real1, Device, Index >& a, const Cont
 ////
 // Minus
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Minus >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Minus >
 operator-( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -365,7 +366,7 @@ operator-( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Abs
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Abs >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Abs >
 abs( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -375,7 +376,7 @@ abs( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Sine
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Sin >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Sin >
 sin( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -385,7 +386,7 @@ sin( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Cosine
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Cos >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Cos >
 cos( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -395,7 +396,7 @@ cos( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Tangent
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Tan >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Tan >
 tan( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -405,7 +406,7 @@ tan( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Sqrt
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Sqrt >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Sqrt >
 sqrt( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -415,7 +416,7 @@ sqrt( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Cbrt
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Cbrt >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Cbrt >
 cbrt( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -425,7 +426,7 @@ cbrt( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Power
 template< typename Real, typename Device, typename Index, typename ExpType >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Pow, ExpType >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Pow, ExpType >
 pow( const Containers::Vector< Real, Device, Index >& a, const ExpType& exp )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -435,7 +436,7 @@ pow( const Containers::Vector< Real, Device, Index >& a, const ExpType& exp )
 ////
 // Floor
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Floor >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Floor >
 floor( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -445,7 +446,7 @@ floor( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Ceil
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Ceil >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Ceil >
 ceil( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -455,7 +456,7 @@ ceil( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Acos
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Acos >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Acos >
 acos( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -465,7 +466,7 @@ acos( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Asin
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Asin >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Asin >
 asin( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -475,7 +476,7 @@ asin( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Atan
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Atan >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Atan >
 atan( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -485,7 +486,7 @@ atan( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Cosh
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Cosh >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Cosh >
 cosh( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -495,7 +496,7 @@ cosh( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Tanh
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Tanh >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Tanh >
 tanh( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -505,7 +506,7 @@ tanh( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Log
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Log >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Log >
 log( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -515,7 +516,7 @@ log( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Log10
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Log10 >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Log10 >
 log10( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -525,7 +526,7 @@ log10( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Log2
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Log2 >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Log2 >
 log2( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -535,7 +536,7 @@ log2( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Exp
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Exp >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Exp >
 exp( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -545,7 +546,7 @@ exp( const Containers::Vector< Real, Device, Index >& a )
 ////
 // Sign
 template< typename Real, typename Device, typename Index >
-const Containers::Expressions::UnaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, Containers::Expressions::Sign >
+const Containers::Expressions::UnaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Sign >
 sign( const Containers::Vector< Real, Device, Index >& a )
 {
    using ConstView = typename Containers::Vector< Real, Device, Index >::ConstViewType;
@@ -706,23 +707,23 @@ template< typename Real, typename Device, typename Index, typename ET >
 Containers::VectorView< Real, Device, Index >
 Scale( const Containers::Vector< Real, Device, Index >& a, const ET& b )
 {
-   Containers::VectorView< Real, Device, Index > result = Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real, Device, Index >, ET, Containers::Expressions::Multiplication >( a.getView(), b );
+   Containers::VectorView< Real, Device, Index > result = Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real, Device, Index >::ConstViewType, ET, Containers::Expressions::Multiplication >( a.getView(), b );
    return result;
 }
 
 template< typename ET, typename Real, typename Device, typename Index >
-Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Multiplication >
+Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >
 Scale( const ET& a, const Containers::Vector< Real, Device, Index >& b )
 {
-   Containers::VectorView< Real, Device, Index > result =  Containers::Expressions::BinaryExpressionTemplate< ET, Containers::VectorView< Real, Device, Index >, Containers::Expressions::Multiplication >( a, b.getView() );
+   Containers::VectorView< Real, Device, Index > result =  Containers::Expressions::BinaryExpressionTemplate< ET, typename Containers::Vector< Real, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >( a, b.getView() );
    return result;
 }
 
 template< typename Real1, typename Real2, typename Device, typename Index >
-Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Multiplication >
+Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >
 Scale( const Containers::Vector< Real1, Device, Index >& a, const Containers::Vector< Real2, Device, Index >& b )
 {
-   Containers::VectorView< Real1, Device, Index > result =  Containers::Expressions::BinaryExpressionTemplate< Containers::VectorView< Real1, Device, Index >, Containers::VectorView< Real2, Device, Index >, Containers::Expressions::Multiplication >( a.getView(), b.getView() );
+   Containers::VectorView< Real1, Device, Index > result =  Containers::Expressions::BinaryExpressionTemplate< typename Containers::Vector< Real1, Device, Index >::ConstViewType, typename Containers::Vector< Real2, Device, Index >::ConstViewType, Containers::Expressions::Multiplication >( a.getView(), b.getView() );
    return result;
 }
 
diff --git a/src/TNL/Containers/VectorView.h b/src/TNL/Containers/VectorView.h
index d67660d4110ca36f34aeacbe01b8b6ec04c91860..d38fbccb3774d9c998059e66a3e49bc1a4bcce56 100644
--- a/src/TNL/Containers/VectorView.h
+++ b/src/TNL/Containers/VectorView.h
@@ -93,7 +93,7 @@ public:
     * however, replaced with the VectorView size.
     */
    __cuda_callable__
-   ConstViewType getConstView( IndexType begin = 0, IndexType end = 0 ) const;
+   ConstViewType getView( IndexType begin = 0, IndexType end = 0 ) const;
 
    /**
     * \brief Returns a non-modifiable view of the vector view.
@@ -106,8 +106,7 @@ public:
     * however, replaced with the VectorView size.
     */
    __cuda_callable__
-   ConstViewType getConstView( const IndexType begin = 0, IndexType end = 0 ) const;
-
+   ConstViewType getConstView( IndexType begin = 0, IndexType end = 0 ) const;
 
    static String getType();
 
diff --git a/src/TNL/Containers/VectorView.hpp b/src/TNL/Containers/VectorView.hpp
index 7cfefb8d1d99c426455bd0c6bbfdb11cb8ea8638..8d2119e3aa78bc5d8390c51d2ec57140368efc4e 100644
--- a/src/TNL/Containers/VectorView.hpp
+++ b/src/TNL/Containers/VectorView.hpp
@@ -64,7 +64,7 @@ getView( IndexType begin, IndexType end ) const
 {
    if( end == 0 )
       end = this->getSize();
-   return ConstViewType( &getData()[ begin ], end - begin );;
+   return ConstViewType( this->getData()[ begin ], end - begin );;
 }
 
 template< typename Real,
diff --git a/src/UnitTests/Containers/VectorTest-1.h b/src/UnitTests/Containers/VectorTest-1.h
index e3746ffee5782ec3d568d439f1da37f8ce0b0f30..0dd8f8f85c685c300b99833433a724167e2d55bb 100644
--- a/src/UnitTests/Containers/VectorTest-1.h
+++ b/src/UnitTests/Containers/VectorTest-1.h
@@ -133,18 +133,18 @@ TEST( VectorSpecialCasesTest, operationsOnConstView )
    u.setValue( 1 );
    v.setValue( 1 );
 
-   EXPECT_EQ( u_view.max(), 1 );
-   EXPECT_EQ( u_view.min(), 1 );
-   EXPECT_EQ( u_view.absMax(), 1 );
-   EXPECT_EQ( u_view.absMin(), 1 );
-   EXPECT_EQ( u_view.lpNorm( 1 ), 100 );
-   EXPECT_EQ( u_view.differenceMax( v_view ), 0 );
-   EXPECT_EQ( u_view.differenceMin( v_view ), 0 );
-   EXPECT_EQ( u_view.differenceAbsMax( v_view ), 0 );
-   EXPECT_EQ( u_view.differenceAbsMin( v_view ), 0 );
-   EXPECT_EQ( u_view.differenceLpNorm( v_view, 1 ), 0 );
-   EXPECT_EQ( u_view.differenceSum( v_view ), 0 );
-   EXPECT_EQ( u_view.scalarProduct( v_view ), 100 );
+   EXPECT_EQ( max( u_view ), 1 );
+   EXPECT_EQ( min( u_view ), 1 );
+   EXPECT_EQ( max( abs( u_view ) ), 1 );
+   EXPECT_EQ( min( abs( u_view ) ), 1 );
+   EXPECT_EQ( lpNorm( u_view, 1 ), 100 );
+   EXPECT_EQ( max( u_view - v_view ), 0 );
+   EXPECT_EQ( min( u_view - v_view ), 0 );
+   EXPECT_EQ( max( abs( u_view - v_view ) ), 0 );
+   EXPECT_EQ( min( abs( u_view - v_view ) ), 0 );
+   EXPECT_EQ( lpNorm( u_view - v_view, 1 ), 0 );
+   EXPECT_EQ( sum( u_view - v_view ), 0 );
+   EXPECT_EQ( ( u_view, v_view ), 100 );
 }
 
 TEST( VectorSpecialCasesTest, initializationOfVectorViewByArrayView )
@@ -159,7 +159,7 @@ TEST( VectorSpecialCasesTest, initializationOfVectorViewByArrayView )
 
    VectorViewType v_view( a_view );
    EXPECT_EQ( v_view.getData(), a_view.getData() );
-   EXPECT_EQ( v_view.sum(), 0 );
+   EXPECT_EQ( sum( v_view ), 0 );
 }
 
 TYPED_TEST( VectorTest, scalarMultiplication )
@@ -210,35 +210,39 @@ TYPED_TEST( VectorTest, addVector )
    y.setSize( size );
    ViewType x_view( x ), y_view( y );
 
-   typename VectorType::HostType expected1, expected2;
-   expected1.setSize( size );
-   expected2.setSize( size );
+   VectorType expected1( size ), expected2( size );
    for( int i = 0; i < size; i++ ) {
-      expected1[ i ] = 2.0 + 3.0 * i;
-      expected2[ i ] = 1.0 + 3.0 * i;
+      expected1.setElement( i, 2.0 + 3.0 * i );
+      expected2.setElement( i, 1.0 + 3.0 * i );
    }
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
+   EXPECT_TRUE( 2.0 * x + 3.0 * y == expected1 );
    VectorOperations::addVector( x, y, 3.0, 2.0 );
    EXPECT_EQ( x, expected1 );
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
+   EXPECT_TRUE( x + 3.0 * y == expected2 );
    x.addVector( y, 3.0, 1.0 );
    EXPECT_EQ( x, expected2 );
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
+   EXPECT_TRUE( x_view + 3.0 * y_view == expected2 );
    x_view.addVector( y_view, 3.0, 1.0 );
    EXPECT_EQ( x, expected2 );
 
    // multiplication by floating-point scalars which produces integer values
    setConstantSequence( x, 2 );
    setConstantSequence( y, 4 );
+   EXPECT_EQ( min( -1.5 * x + 2.5 * y ), 7 );
+   EXPECT_EQ( max( -1.5 * x + 2.5 * y ), 7 );
    x.addVector( y, 2.5, -1.5 );
-   EXPECT_EQ( x.min(), 7 );
-   EXPECT_EQ( x.max(), 7 );
+   EXPECT_EQ( min( x ), 7 );
+   EXPECT_EQ( max( x ), 7 );
+
 }
 
 TYPED_TEST( VectorTest, addVectors )
@@ -254,29 +258,30 @@ TYPED_TEST( VectorTest, addVectors )
    z.setSize( size );
    ViewType x_view( x ), y_view( y ), z_view( z );
 
-   typename VectorType::HostType expected1, expected2;
-   expected1.setSize( size );
-   expected2.setSize( size );
+   VectorType expected1( size ), expected2( size );
    for( int i = 0; i < size; i++ ) {
-      expected1[ i ] = 1.0 + 3.0 * i + 2.0;
-      expected2[ i ] = 2.0 + 3.0 * i + 2.0;
+      expected1.setElement( i, 1.0 + 3.0 * i + 2.0;
+      expected2.setElement( i, 2.0 + 3.0 * i + 2.0;
    }
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
    setConstantSequence( z, 2 );
+   EXPECT_TRUE( 3.0 * y + z + x == expected1 );
    VectorOperations::addVectors( x, y, 3.0, z, 1.0, 1.0 );
    EXPECT_EQ( x, expected1 );
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
    setConstantSequence( z, 2 );
+   EXPECT_TRUE( 3.0 * y + z + 2.0 * x == expected2 );
    x.addVectors( y, 3.0, z, 1.0, 2.0 );
    EXPECT_EQ( x, expected2 );
 
    setConstantSequence( x, 1 );
    setLinearSequence( y );
    setConstantSequence( z, 2 );
+   EXPECT_TRUE( 3.0 * y_view + z_view + 2.0 * x_view == expected2 );
    x_view.addVectors( y_view, 3.0, z_view, 1.0, 2.0 );
    EXPECT_EQ( x, expected2 );
 
@@ -284,9 +289,11 @@ TYPED_TEST( VectorTest, addVectors )
    setConstantSequence( x, 2 );
    setConstantSequence( y, 4 );
    setConstantSequence( z, 6 );
+   EXPECT_EQ( min( 2.5 * y - 1.5 * z - 1.5 * x ), -2 );
+   EXPECT_EQ( max( 2.5 * y - 1.5 * z - 1.5 * x ), -2 );
    x.addVectors( y, 2.5, z, -1.5, -1.5 );
-   EXPECT_EQ( x.min(), -2 );
-   EXPECT_EQ( x.max(), -2 );
+   EXPECT_EQ( min( x ), -2 );
+   EXPECT_EQ( max( x ), -2 );
 }
 
 TYPED_TEST( VectorTest, abs )
diff --git a/src/UnitTests/Containers/VectorTest-2.h b/src/UnitTests/Containers/VectorTest-2.h
index 30a706e39e738e3bb34bc460b976c9b12ac16348..93a15168f561162b5b4a5ff74e1f06f9ca4f6513 100644
--- a/src/UnitTests/Containers/VectorTest-2.h
+++ b/src/UnitTests/Containers/VectorTest-2.h
@@ -250,9 +250,6 @@ void setupFlags( FlagsView& f )
 {
    auto f1 = [] __cuda_callable__ ( typename FlagsView::IndexType i ) { return ( i % 5 ) == 0; };
    f.evaluate( f1 );
-   EXPECT_EQ( max( u - v ), size - 1 - size / 2 );
-   EXPECT_EQ( max( u_view - v_view ), size - 1 - size / 2 );
-   EXPECT_EQ( VectorOperations::getVectorDifferenceMax( u, v ), size - 1 - size / 2 );
 }
 
 /*
diff --git a/src/UnitTests/Containers/VectorTest-3.h b/src/UnitTests/Containers/VectorTest-3.h
index ad79049c4213e658193b008d3cdca6fc56b13ea6..9e2746d7261acbbc74e37fd54bde03f4a9f1e55c 100644
--- a/src/UnitTests/Containers/VectorTest-3.h
+++ b/src/UnitTests/Containers/VectorTest-3.h
@@ -31,8 +31,8 @@ TYPED_TEST( VectorTest, max )
    ViewType v_view( v );
    setLinearSequence( v );
 
-   EXPECT_EQ( v.max(), size - 1 );
-   EXPECT_EQ( v_view.max(), size - 1 );
+   EXPECT_EQ( max( v ), size - 1 );
+   EXPECT_EQ( max( v_view ), size - 1 );
    EXPECT_EQ( VectorOperations::getVectorMax( v ), size - 1 );
 }
 
@@ -48,8 +48,8 @@ TYPED_TEST( VectorTest, min )
    ViewType v_view( v );
    setLinearSequence( v );
 
-   EXPECT_EQ( v.min(), 0 );
-   EXPECT_EQ( v_view.min(), 0 );
+   EXPECT_EQ( min( v ), 0 );
+   EXPECT_EQ( min( v_view ), 0 );
    EXPECT_EQ( VectorOperations::getVectorMin( v ), 0 );
 }
 
@@ -62,19 +62,15 @@ TYPED_TEST( VectorTest, absMax )
    // this test expect an even size
    const int size = VECTOR_TEST_SIZE % 2 ? VECTOR_TEST_SIZE - 1 : VECTOR_TEST_SIZE;
 
-   VectorType v( size );
-   ViewType v_view( v );
+   VectorType u( size ), v( size );
+   ViewType u_view( u ), v_view( v );
    setNegativeLinearSequence( v );
 
    EXPECT_EQ( max( abs( v ) ), size - 1 );
-   EXPECT_EQ( max( abs( v_view ) ),, size - 1 );
+   EXPECT_EQ( max( abs( v_view ) ), size - 1 );
    EXPECT_EQ( VectorOperations::getVectorAbsMax( v ), size - 1 );
 
-   VectorType u( size ), v( size );
-   ViewType u_view( u ), v_view( v );
-   
    v.setValue( 1.0 );
-
    setConstantSequence( u, 2 );
    EXPECT_EQ( sum( u - v ), size );
    EXPECT_EQ( sum( u_view - v_view ), size );
@@ -108,8 +104,8 @@ TYPED_TEST( VectorTest, absMin )
    ViewType v_view( v );
    setNegativeLinearSequence( v );
 
-   EXPECT_EQ( v.absMin(), 0 );
-   EXPECT_EQ( v_view.absMin(), 0 );
+   EXPECT_EQ( min( abs( v ) ), 0 );
+   EXPECT_EQ( min( abs( v_view ) ), 0 );
    EXPECT_EQ( VectorOperations::getVectorAbsMin( v ), 0 );
 }
 
@@ -130,12 +126,12 @@ TYPED_TEST( VectorTest, lpNorm )
    const RealType expectedL1norm = size;
    const RealType expectedL2norm = std::sqrt( size );
    const RealType expectedL3norm = std::cbrt( size );
-   EXPECT_EQ( v.lpNorm( 1.0 ), expectedL1norm );
-   EXPECT_EQ( v.lpNorm( 2.0 ), expectedL2norm );
-   EXPECT_NEAR( v.lpNorm( 3.0 ), expectedL3norm, epsilon );
-   EXPECT_EQ( v_view.lpNorm( 1.0 ), expectedL1norm );
-   EXPECT_EQ( v_view.lpNorm( 2.0 ), expectedL2norm );
-   EXPECT_NEAR( v_view.lpNorm( 3.0 ), expectedL3norm, epsilon );
+   EXPECT_EQ( lpNorm( v, 1.0 ), expectedL1norm );
+   EXPECT_EQ( lpNorm( v, 2.0 ), expectedL2norm );
+   EXPECT_NEAR( lpNorm( v, 3.0 ), expectedL3norm, epsilon );
+   EXPECT_EQ( lpNorm( v_view, 1.0 ), expectedL1norm );
+   EXPECT_EQ( lpNorm( v_view, 2.0 ), expectedL2norm );
+   EXPECT_NEAR( lpNorm( v_view, 3.0 ), expectedL3norm, epsilon );
    EXPECT_EQ( VectorOperations::getVectorLpNorm( v, 1.0 ), expectedL1norm );
    EXPECT_EQ( VectorOperations::getVectorLpNorm( v, 2.0 ), expectedL2norm );
    EXPECT_NEAR( VectorOperations::getVectorLpNorm( v, 3.0 ), expectedL3norm, epsilon );
diff --git a/src/UnitTests/Containers/VectorTest-4.h b/src/UnitTests/Containers/VectorTest-4.h
index 950d46ef6a429dbb4ef3d65fe22364437afc82c5..8560ef525c52b6fe6d28e67ca477c0ff54ec2abe 100644
--- a/src/UnitTests/Containers/VectorTest-4.h
+++ b/src/UnitTests/Containers/VectorTest-4.h
@@ -32,23 +32,23 @@ TYPED_TEST( VectorTest, sum )
    ViewType v_view( v );
 
    setConstantSequence( v, 1 );
-   EXPECT_EQ( v.sum(), size );
-   EXPECT_EQ( v_view.sum(), size );
+   EXPECT_EQ( sum( v ), size );
+   EXPECT_EQ( sum( v_view ), size );
    EXPECT_EQ( VectorOperations::getVectorSum( v ), size );
 
    setLinearSequence( v );
-   EXPECT_EQ( v.sum(), 0.5 * size * ( size - 1 ) );
-   EXPECT_EQ( v_view.sum(), 0.5 * size * ( size - 1 ) );
+   EXPECT_EQ( sum( v ), 0.5 * size * ( size - 1 ) );
+   EXPECT_EQ( sum( v_view ), 0.5 * size * ( size - 1 ) );
    EXPECT_EQ( VectorOperations::getVectorSum( v ), 0.5 * size * ( size - 1 ) );
 
    setNegativeLinearSequence( v );
-   EXPECT_EQ( v.sum(), - 0.5 * size * ( size - 1 ) );
-   EXPECT_EQ( v_view.sum(), - 0.5 * size * ( size - 1 ) );
+   EXPECT_EQ( sum( v ), - 0.5 * size * ( size - 1 ) );
+   EXPECT_EQ( sum( v_view ), - 0.5 * size * ( size - 1 ) );
    EXPECT_EQ( VectorOperations::getVectorSum( v ), - 0.5 * size * ( size - 1 ) );
 
    setOscilatingSequence( v, 1.0 );
-   EXPECT_EQ( v.sum(), 0 );
-   EXPECT_EQ( v_view.sum(), 0 );
+   EXPECT_EQ( sum( v ), 0 );
+   EXPECT_EQ( sum( v_view ), 0 );
    EXPECT_EQ( VectorOperations::getVectorSum( v ), 0 );
 }
 
@@ -63,38 +63,38 @@ TEST( VectorSpecialCasesTest, sumOfBoolVector )
    v.setValue( true );
    w.setValue( false );
 
-   const int sum = v.sum< int >();
-   const int l1norm = v.lpNorm< int >( 1.0 );
-   const float l2norm = v.lpNorm< float >( 2.0 );
-   const float l3norm = v.lpNorm< float >( 3.0 );
+   const int sum = TNL::sum( v );
+   const int l1norm = lpNorm( v, 1.0 );
+   const float l2norm = lpNorm( v, 2.0 );
+   const float l3norm = lpNorm( v, 3.0 );
    EXPECT_EQ( sum, 512 );
    EXPECT_EQ( l1norm, 512 );
    EXPECT_NEAR( l2norm, std::sqrt( 512 ), epsilon );
    EXPECT_NEAR( l3norm, std::cbrt( 512 ), epsilon );
 
-   const int diff_sum = v.differenceSum< int >( w );
-   const int diff_l1norm = v.differenceLpNorm< int >( w, 1.0 );
-   const float diff_l2norm = v.differenceLpNorm< float >( w, 2.0 );
-   const float diff_l3norm = v.differenceLpNorm< float >( w, 3.0 );
+   const int diff_sum = TNL::sum( v - w );
+   const int diff_l1norm = lpNorm( v - w, 1.0 );
+   const float diff_l2norm = lpNorm( v - w, 2.0 );
+   const float diff_l3norm = lpNorm( v - w, 3.0 );
    EXPECT_EQ( diff_sum, 512 );
    EXPECT_EQ( diff_l1norm, 512 );
    EXPECT_NEAR( diff_l2norm, std::sqrt( 512 ), epsilon );
    EXPECT_NEAR( diff_l3norm, std::cbrt( 512 ), epsilon );
 
    // test views
-   const int sum_view = v_view.sum< int >();
-   const int l1norm_view = v_view.lpNorm< int >( 1.0 );
-   const float l2norm_view = v_view.lpNorm< float >( 2.0 );
-   const float l3norm_view = v_view.lpNorm< float >( 3.0 );
+   const int sum_view = TNL::sum( v_view );
+   const int l1norm_view = lpNorm( v_view, 1.0 );
+   const float l2norm_view = lpNorm( v_view, 2.0 );
+   const float l3norm_view = lpNorm( v_view, 3.0 );
    EXPECT_EQ( sum_view, 512 );
    EXPECT_EQ( l1norm_view, 512 );
    EXPECT_NEAR( l2norm_view, std::sqrt( 512 ), epsilon );
    EXPECT_NEAR( l3norm_view, std::cbrt( 512 ), epsilon );
 
-   const int diff_sum_view = v_view.differenceSum< int >( w_view );
-   const int diff_l1norm_view = v_view.differenceLpNorm< int >( w_view, 1.0 );
-   const float diff_l2norm_view = v_view.differenceLpNorm< float >( w_view, 2.0 );
-   const float diff_l3norm_view = v_view.differenceLpNorm< float >( w_view, 3.0 );
+   const int diff_sum_view = TNL::sum( v_view - w_view );
+   const int diff_l1norm_view = lpNorm( v_view -w_view, 1.0 );
+   const float diff_l2norm_view = lpNorm( v_view - w_view, 2.0 );
+   const float diff_l3norm_view = lpNorm( v_view - w_view, 3.0 );
    EXPECT_EQ( diff_sum_view, 512 );
    EXPECT_EQ( diff_l1norm_view, 512 );
    EXPECT_NEAR( diff_l2norm_view, std::sqrt( 512 ), epsilon );
@@ -114,11 +114,11 @@ TYPED_TEST( VectorTest, scalarProduct )
    setOscilatingSequence( u, 1.0 );
    setConstantSequence( v, 1 );
 
-   EXPECT_EQ( u.scalarProduct( v ), 1.0 );
-   EXPECT_EQ( u_view.scalarProduct( v_view ), 1.0 );
+   EXPECT_EQ( dot( u, v ), 1.0 );
+   EXPECT_EQ( dot( u_view, v_view ), 1.0 );
    EXPECT_EQ( VectorOperations::getScalarProduct( u, v ), 1.0 );
-   EXPECT_EQ( (u, v), 1.0 );
-   EXPECT_EQ( (u_view, v_view), 1.0 );
+   EXPECT_EQ( ( u, v ), 1.0 );
+   EXPECT_EQ( ( u_view, v_view ), 1.0 );
 }
 
 TYPED_TEST( VectorTest, differenceLpNorm )
@@ -138,12 +138,12 @@ TYPED_TEST( VectorTest, differenceLpNorm )
    const RealType expectedL1norm = 2.0 * size;
    const RealType expectedL2norm = std::sqrt( 4.0 * size );
    const RealType expectedL3norm = std::cbrt( 8.0 * size );
-   EXPECT_EQ( u.differenceLpNorm( v, 1.0 ), expectedL1norm );
-   EXPECT_EQ( u.differenceLpNorm( v, 2.0 ), expectedL2norm );
-   EXPECT_NEAR( u.differenceLpNorm( v, 3.0 ), expectedL3norm, epsilon );
-   EXPECT_EQ( u_view.differenceLpNorm( v_view, 1.0 ), expectedL1norm );
-   EXPECT_EQ( u_view.differenceLpNorm( v_view, 2.0 ), expectedL2norm );
-   EXPECT_NEAR( u_view.differenceLpNorm( v_view, 3.0 ), expectedL3norm, epsilon );
+   EXPECT_EQ( lpNorm( u - v, 1.0 ), expectedL1norm );
+   EXPECT_EQ( lpNorm( u - v, 2.0 ), expectedL2norm );
+   EXPECT_NEAR( lpNorm( u - v, 3.0 ), expectedL3norm, epsilon );
+   EXPECT_EQ( lpNorm( u_view - v_view, 1.0 ), expectedL1norm );
+   EXPECT_EQ( lpNorm( u_view - v_view, 2.0 ), expectedL2norm );
+   EXPECT_NEAR( lpNorm( u_view - v_view, 3.0 ), expectedL3norm, epsilon );
    EXPECT_EQ( VectorOperations::getVectorDifferenceLpNorm( u, v, 1.0 ), expectedL1norm );
    EXPECT_EQ( VectorOperations::getVectorDifferenceLpNorm( u, v, 2.0 ), expectedL2norm );
    EXPECT_NEAR( VectorOperations::getVectorDifferenceLpNorm( u, v, 3.0 ), expectedL3norm, epsilon );
@@ -162,23 +162,23 @@ TYPED_TEST( VectorTest, differenceSum )
    v.setValue( 1.0 );
 
    setConstantSequence( u, 2 );
-   EXPECT_EQ( u.differenceSum( v ), size );
-   EXPECT_EQ( u_view.differenceSum( v_view ), size );
+   EXPECT_EQ( sum( u - v ), size );
+   EXPECT_EQ( sum( u_view - v_view ), size );
    EXPECT_EQ( VectorOperations::getVectorDifferenceSum( u, v ), size );
 
    setLinearSequence( u );
-   EXPECT_EQ( u.differenceSum( v ), 0.5 * size * ( size - 1 ) - size );
-   EXPECT_EQ( u_view.differenceSum( v_view ), 0.5 * size * ( size - 1 ) - size );
+   EXPECT_EQ( sum( u - v ), 0.5 * size * ( size - 1 ) - size );
+   EXPECT_EQ( sum( u_view - v_view ), 0.5 * size * ( size - 1 ) - size );
    EXPECT_EQ( VectorOperations::getVectorDifferenceSum( u, v ), 0.5 * size * ( size - 1 ) - size );
 
    setNegativeLinearSequence( u );
-   EXPECT_EQ( u.differenceSum( v ), - 0.5 * size * ( size - 1 ) - size );
-   EXPECT_EQ( u_view.differenceSum( v_view ), - 0.5 * size * ( size - 1 ) - size );
+   EXPECT_EQ( sum( u - v ), - 0.5 * size * ( size - 1 ) - size );
+   EXPECT_EQ( sum( u_view - v_view ), - 0.5 * size * ( size - 1 ) - size );
    EXPECT_EQ( VectorOperations::getVectorDifferenceSum( u, v ), - 0.5 * size * ( size - 1 ) - size );
 
    setOscilatingSequence( u, 1.0 );
-   EXPECT_EQ( u.differenceSum( v ), - size );
-   EXPECT_EQ( u_view.differenceSum( v_view ), - size );
+   EXPECT_EQ( sum( u - v ), - size );
+   EXPECT_EQ( sum( u_view - v_view ), - size );
    EXPECT_EQ( VectorOperations::getVectorDifferenceSum( u, v ), - size );
 }
 
diff --git a/src/UnitTests/Containers/VectorTest-5.h b/src/UnitTests/Containers/VectorTest-5.h
index f2a53df10e85d512ec38a32c69643911562af516..0e460af0f338dd7bcd40711cda0ecd1bac95e534 100644
--- a/src/UnitTests/Containers/VectorTest-5.h
+++ b/src/UnitTests/Containers/VectorTest-5.h
@@ -31,8 +31,8 @@ TYPED_TEST( VectorTest, differenceMax )
    setLinearSequence( u );
    setConstantSequence( v, size / 2 );
 
-   EXPECT_EQ( u.differenceMax( v ), size - 1 - size / 2 );
-   EXPECT_EQ( u_view.differenceMax( v_view ), size - 1 - size / 2 );
+   EXPECT_EQ( max( u - v ), size - 1 - size / 2 );
+   EXPECT_EQ( max( u_view - v_view ), size - 1 - size / 2 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceMax( u, v ), size - 1 - size / 2 );
 }
 
@@ -48,11 +48,11 @@ TYPED_TEST( VectorTest, differenceMin )
    setLinearSequence( u );
    setConstantSequence( v, size / 2 );
 
-   EXPECT_EQ( u.differenceMin( v ), - size / 2 );
-   EXPECT_EQ( u_view.differenceMin( v_view ), - size / 2 );
+   EXPECT_EQ( min( u - v ), - size / 2 );
+   EXPECT_EQ( min( u_view - v_view ), - size / 2 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceMin( u, v ), - size / 2 );
-   EXPECT_EQ( v.differenceMin( u ), size / 2 - size + 1 );
-   EXPECT_EQ( v_view.differenceMin( u_view ), size / 2 - size + 1 );
+   EXPECT_TRUE( min( v, u ) == size / 2 - size + 1 );
+   EXPECT_TRUE( min( v_view, u_view ) == size / 2 - size + 1 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceMin( v, u ), size / 2 - size + 1 );
 }
 
@@ -69,8 +69,8 @@ TYPED_TEST( VectorTest, differenceAbsMax )
    setNegativeLinearSequence( u );
    setConstantSequence( v, - size / 2 );
 
-   EXPECT_EQ( u.differenceAbsMax( v ), size - 1 - size / 2 );
-   EXPECT_EQ( u_view.differenceAbsMax( v_view ), size - 1 - size / 2 );
+   EXPECT_EQ( max( abs( u - v ) ), size - 1 - size / 2 );
+   EXPECT_EQ( max( abs( u_view - v_view ) ), size - 1 - size / 2 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceAbsMax( u, v ), size - 1 - size / 2 );
 }
 
@@ -86,11 +86,11 @@ TYPED_TEST( VectorTest, differenceAbsMin )
    setNegativeLinearSequence( u );
    setConstantSequence( v, - size / 2 );
 
-   EXPECT_EQ( u.differenceAbsMin( v ), 0 );
-   EXPECT_EQ( u_view.differenceAbsMin( v_view ), 0 );
+   EXPECT_EQ( min( abs( u - v ) ), 0 );
+   EXPECT_EQ( min( abs( u_view - v_view ) ), 0 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceAbsMin( u, v ), 0 );
-   EXPECT_EQ( v.differenceAbsMin( u ), 0 );
-   EXPECT_EQ( v_view.differenceAbsMin( u_view ), 0 );
+   EXPECT_EQ( min( abs( v - u ) ), 0 );
+   EXPECT_EQ( min( abs( v_view - u_view ) ), 0 );
    EXPECT_EQ( VectorOperations::getVectorDifferenceAbsMin( v, u ), 0 );
 }
 
diff --git a/src/UnitTests/Containers/VectorTest-6.h b/src/UnitTests/Containers/VectorTest-6.h
index 9b64c73a94f5afb360a2493fffef64ef906b3c77..5bdc13b5d18c3458128a82549535639fa6477eee 100644
--- a/src/UnitTests/Containers/VectorTest-6.h
+++ b/src/UnitTests/Containers/VectorTest-6.h
@@ -141,8 +141,8 @@ TEST( VectorSpecialCasesTest, assignmentThroughView )
    using VectorType = Containers::Vector< int, Devices::Host >;
    using ViewType = VectorView< int, Devices::Host >;
 
-   static_assert( Algorithms::Details::HasSubscriptOperator< VectorType >::value, "Subscript operator detection by SFINAE does not work for Vector." );
-   static_assert( Algorithms::Details::HasSubscriptOperator< ViewType >::value, "Subscript operator detection by SFINAE does not work for VectorView." );
+   static_assert( Containers::Algorithms::detail::HasSubscriptOperator< VectorType >::value, "Subscript operator detection by SFINAE does not work for Vector." );
+   static_assert( Containers::Algorithms::detail::HasSubscriptOperator< ViewType >::value, "Subscript operator detection by SFINAE does not work for VectorView." );
 
    VectorType u( 100 ), v( 100 );
    ViewType u_view( u ), v_view( v );
@@ -175,18 +175,18 @@ TEST( VectorSpecialCasesTest, operationsOnConstView )
    u.setValue( 1 );
    v.setValue( 1 );
 
-   EXPECT_EQ( u_view.max(), 1 );
-   EXPECT_EQ( u_view.min(), 1 );
-   EXPECT_EQ( u_view.absMax(), 1 );
-   EXPECT_EQ( u_view.absMin(), 1 );
-   EXPECT_EQ( u_view.lpNorm( 1 ), 100 );
+   EXPECT_EQ( max( u_view ), 1 );
+   EXPECT_EQ( min( u_view ), 1 );
+   EXPECT_EQ( max( abs( u_view ) ), 1 );
+   EXPECT_EQ( min( abs( u_view ) ), 1 );
+   EXPECT_EQ( lpNorm( u_view, 1 ), 100 );
    EXPECT_EQ( max( u_view - v_view ), 0 );
    EXPECT_EQ( min( u_view - v_view ), 0 );
    EXPECT_EQ( max( abs( u_view - v_view ) ), 0 );
    EXPECT_EQ( min( abs( u_view - v_view ) ), 0 );
    EXPECT_EQ( lpNorm( u_view - v_view, 1.0 ), 0 );
    EXPECT_EQ( sum( u_view - v_view ), 0 );
-   EXPECT_EQ( u_view.scalarProduct( v_view ), 100 );
+   EXPECT_EQ( dot( u_view, v_view ), 100 );
 }
 
 TEST( VectorSpecialCasesTest, initializationOfVectorViewByArrayView )