diff --git a/src/TNL/Containers/Expressions/Comparison.h b/src/TNL/Containers/Expressions/Comparison.h
index 0b98092788d7eb11dab4a63da3caf8c113366363..afa346281404fcfeee4134245790862d853a32ee 100644
--- a/src/TNL/Containers/Expressions/Comparison.h
+++ b/src/TNL/Containers/Expressions/Comparison.h
@@ -103,13 +103,13 @@ struct Comparison< T1, T2, ArithmeticVariable, VectorVariable >
 
    static bool EQ( const T1& a, const T2& b )
    {
-      using DeviceType = typename T1::DeviceType;
-      using IndexType = typename T1::IndexType;
+      using DeviceType = typename T2::DeviceType;
+      using IndexType = typename T2::IndexType;
 
       auto fetch = [=] __cuda_callable__ ( IndexType i ) -> bool { return  ( a == b[ i ] ); };
       auto reduction = [=] __cuda_callable__ ( bool& a, const bool& b ) { a &= b; };
       auto volatileReduction = [=] __cuda_callable__ ( volatile bool& a, volatile bool& b ) { a &= b; };
-      return Algorithms::Reduction< DeviceType >::reduce( a.getSize(), reduction, volatileReduction, fetch, true );
+      return Algorithms::Reduction< DeviceType >::reduce( b.getSize(), reduction, volatileReduction, fetch, true );
    }
 
    static bool NE( const T1& a, const T2& b )
diff --git a/src/TNL/Containers/StaticVectorExpressions.h b/src/TNL/Containers/StaticVectorExpressions.h
index 85f4029b4e2bb138c81161be3c0c2abdbf63b260..fac4088c2ea9971e1ae98437d23b435d719f5065 100644
--- a/src/TNL/Containers/StaticVectorExpressions.h
+++ b/src/TNL/Containers/StaticVectorExpressions.h
@@ -19,265 +19,265 @@ namespace TNL {
 
 // operators must be defined in the same namespace as the first operand, otherwise
 // they may not be considered by the compiler (e.g. inside pybind11's macros)
-namespace Containers {
+// namespace Containers { Overriden operators should be in namespace TNL
 
 ////
 // Addition
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Addition >
-operator+( const StaticVector< Size, Real >& a, const ET& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Addition >
+operator+( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Addition >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Addition >( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Addition >
-operator+( const ET& a, const StaticVector< Size, Real >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Addition >
+operator+( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Addition >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Addition >( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Addition >
-operator+( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Addition >
+operator+( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Addition >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Addition >( a, b );
 }
 
 ////
 // Subtraction
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Subtraction >
-operator-( const StaticVector< Size, Real >& a, const ET& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Subtraction >
+operator-( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Subtraction >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Subtraction >( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Subtraction >
-operator-( const ET& a, const StaticVector< Size, Real >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Subtraction >
+operator-( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Subtraction >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Subtraction >( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Subtraction >
-operator-( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Subtraction >
+operator-( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Subtraction >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Subtraction >( a, b );
 }
 
 ////
 // Multiplication
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Multiplication >
-operator*( const StaticVector< Size, Real >& a, const ET& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Multiplication >
+operator*( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Multiplication >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Multiplication >( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Multiplication >
-operator*( const ET& a, const StaticVector< Size, Real >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Multiplication >
+operator*( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Multiplication >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Multiplication >( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Multiplication >
-operator*( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Multiplication >
+operator*( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Multiplication >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Multiplication >( a, b );
 }
 
 ////
 // Division
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Division >
-operator/( const StaticVector< Size, Real >& a, const ET& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Division >
+operator/( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real >, ET, Expressions::Division >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real >, ET, Containers::Expressions::Division >( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Division >
-operator/( const ET& a, const StaticVector< Size, Real >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Division >
+operator/( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< ET, StaticVector< Size, Real >, Expressions::Division >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< ET, Containers::StaticVector< Size, Real >, Containers::Expressions::Division >( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-const Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Division >
-operator/( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+const Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Division >
+operator/( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticBinaryExpressionTemplate< StaticVector< Size, Real1 >, StaticVector< Size, Real2 >, Expressions::Division >( a, b );
+   return Containers::Expressions::StaticBinaryExpressionTemplate< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 >, Containers::Expressions::Division >( a, b );
 }
 
 ////
 // Comparison operations - operator ==
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator==( const StaticVector< Size, Real >& a, const ET& b )
+bool operator==( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::EQ( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::EQ( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator==( const ET& a, const StaticVector< Size, Real >& b )
+bool operator==( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::EQ( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::EQ( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator==( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator==( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::EQ( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::EQ( a, b );
 }
 
 ////
 // Comparison operations - operator !=
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator!=( const StaticVector< Size, Real >& a, const ET& b )
+bool operator!=( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::NE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::NE( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator!=( const ET& a, const StaticVector< Size, Real >& b )
+bool operator!=( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::NE( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::NE( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator!=( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator!=( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::NE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::NE( a, b );
 }
 
 ////
 // Comparison operations - operator <
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator<( const StaticVector< Size, Real >& a, const ET& b )
+bool operator<( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::LT( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::LT( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator<( const ET& a, const StaticVector< Size, Real >& b )
+bool operator<( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::LT( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::LT( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator<( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator<( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::LT( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::LT( a, b );
 }
 
 ////
 // Comparison operations - operator <=
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator<=( const StaticVector< Size, Real >& a, const ET& b )
+bool operator<=( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::LE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::LE( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator<=( const ET& a, const StaticVector< Size, Real >& b )
+bool operator<=( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::LE( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::LE( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator<=( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator<=( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::LE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::LE( a, b );
 }
 
 ////
 // Comparison operations - operator >
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator>( const StaticVector< Size, Real >& a, const ET& b )
+bool operator>( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::GT( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::GT( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator>( const ET& a, const StaticVector< Size, Real >& b )
+bool operator>( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::GT( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::GT( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator>( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator>( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::GT( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::GT( a, b );
 }
 
 ////
 // Comparison operations - operator >=
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-bool operator>=( const StaticVector< Size, Real >& a, const ET& b )
+bool operator>=( const Containers::StaticVector< Size, Real >& a, const ET& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real >, ET >::GE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real >, ET >::GE( a, b );
 }
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-bool operator>=( const ET& a, const StaticVector< Size, Real >& b )
+bool operator>=( const ET& a, const Containers::StaticVector< Size, Real >& b )
 {
-   return Expressions::StaticComparison< ET, StaticVector< Size, Real > >::GE( a, b );
+   return Containers::Expressions::StaticComparison< ET, Containers::StaticVector< Size, Real > >::GE( a, b );
 }
 
 template< int Size, typename Real1, typename Real2 >
 __cuda_callable__
-bool operator>=( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+bool operator>=( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 {
-   return Expressions::StaticComparison< StaticVector< Size, Real1 >, StaticVector< Size, Real2 > >::GE( a, b );
+   return Containers::Expressions::StaticComparison< Containers::StaticVector< Size, Real1 >, Containers::StaticVector< Size, Real2 > >::GE( a, b );
 }
 
 ////
 // Minus
 template< int Size, typename Real >
 __cuda_callable__
-const Expressions::StaticUnaryExpressionTemplate< StaticVector< Size, Real >, Expressions::Minus >
-operator-( const StaticVector< Size, Real >& a )
+const Containers::Expressions::StaticUnaryExpressionTemplate< Containers::StaticVector< Size, Real >, Containers::Expressions::Minus >
+operator-( const Containers::StaticVector< Size, Real >& a )
 {
-   return Expressions::StaticUnaryExpressionTemplate< StaticVector< Size, Real >, Expressions::Minus >( a );
+   return Containers::Expressions::StaticUnaryExpressionTemplate< Containers::StaticVector< Size, Real >, Containers::Expressions::Minus >( a );
 }
 
 ////
 // Scalar product
 template< int Size, typename Real, typename ET >
 __cuda_callable__
-auto operator,( const StaticVector< Size, Real >& a, const ET& b )
+auto operator,( const Containers::StaticVector< Size, Real >& a, const ET& b )
 ->decltype( TNL::sum( a * b ) )
 {
    return TNL::sum( a * b );
@@ -285,7 +285,7 @@ auto operator,( const StaticVector< Size, Real >& a, const ET& b )
 
 template< typename ET, int Size, typename Real >
 __cuda_callable__
-auto operator,( const ET& a, const StaticVector< Size, Real >& b )
+auto operator,( const ET& a, const Containers::StaticVector< Size, Real >& b )
 ->decltype( TNL::sum( a * b ) )
 {
    return TNL::sum( a * b );
@@ -293,14 +293,12 @@ auto operator,( const ET& a, const StaticVector< Size, Real >& b )
 
 template< typename Real1, int Size, typename Real2 >
 __cuda_callable__
-auto operator,( const StaticVector< Size, Real1 >& a, const StaticVector< Size, Real2 >& b )
+auto operator,( const Containers::StaticVector< Size, Real1 >& a, const Containers::StaticVector< Size, Real2 >& b )
 ->decltype( TNL::sum( a * b ) )
 {
    return TNL::sum( a * b );
 }
 
-} // namespace Containers
-
 ////
 // Min
 template< int Size, typename Real, typename ET >
diff --git a/src/UnitTests/Containers/StaticVectorTest.cpp b/src/UnitTests/Containers/StaticVectorTest.cpp
index 6ccbce9c850af04f4c5d65d8ea02de2377316e6e..98236ae653e694b480690934807a9e72470300d6 100644
--- a/src/UnitTests/Containers/StaticVectorTest.cpp
+++ b/src/UnitTests/Containers/StaticVectorTest.cpp
@@ -583,7 +583,7 @@ TYPED_TEST( StaticVectorTest, comparisonOperators )
 
    EXPECT_EQ( u, u );
    EXPECT_EQ( u, 1.0 );
-   EXPECT_EQ( 1.0, u );
+   EXPECT_TRUE( 1.0 == u );
    EXPECT_EQ( w, v + v );
    EXPECT_EQ( v + v, w );
    EXPECT_TRUE( abs( w ) == v + v );
@@ -591,9 +591,9 @@ TYPED_TEST( StaticVectorTest, comparisonOperators )
 
    EXPECT_NE( u, v );
    EXPECT_NE( u, 2.0 );
-   EXPECT_NE( 2.0, u );
+   EXPECT_TRUE( 2.0 != u );
    EXPECT_NE( u, w + w );
-   EXPECT_NE( w + v, u );
+   EXPECT_TRUE( w + v != u );
    EXPECT_TRUE( abs( w ) != abs( u ) );
    EXPECT_TRUE( ( w + v ) != ( u + v ) );
    EXPECT_TRUE( ( abs( u ) ) != ( w + v ) );
diff --git a/src/UnitTests/Containers/VectorTest-1.h b/src/UnitTests/Containers/VectorTest-1.h
index 9706834f6c2b871067d6b0a7d84607b8e88bd07c..dbd5c928a7ad76bfe1c70805bac7616638711985 100644
--- a/src/UnitTests/Containers/VectorTest-1.h
+++ b/src/UnitTests/Containers/VectorTest-1.h
@@ -318,14 +318,104 @@ TYPED_TEST( VectorTest, comparison )
    using ViewType = typename TestFixture::ViewType;
    const int size = VECTOR_TEST_SIZE;
 
-   VectorType _v( size ), _w( size );
-   ViewType v( _v ), w( _w );
-   v = 1.0;
-   w = 2.0;
-
-   EXPECT_TRUE( v < w );
-   EXPECT_TRUE( w > v );
-   EXPECT_TRUE( w + 1.0 < v + 4.0 );
+   VectorType _u( size ), _v( size ), _w( size );
+   ViewType u( _u ), v( _v ), w( _w );
+
+   u = 1.0;
+   v = 2.0;
+   w = 4.0;
+
+   // Test with Vectors
+   EXPECT_EQ( _u, _u );
+   EXPECT_EQ( _u, 1.0 );
+   EXPECT_TRUE( 1.0 == _u );
+   EXPECT_EQ( _w, _v + _v );
+   EXPECT_TRUE( _v + _v == _w );
+   EXPECT_TRUE( abs( _w ) == _v + _v );
+   EXPECT_TRUE( _v + _v == abs( _w ) );
+
+   EXPECT_NE( _u, _v );
+   EXPECT_NE( _u, 2.0 );
+   EXPECT_TRUE( 2.0 != _u );
+   EXPECT_NE( _u, _w + _w );
+   EXPECT_TRUE( _w + _v != _u );
+   EXPECT_TRUE( abs( _w ) != abs( _u ) );
+   EXPECT_TRUE( ( _w + _v ) != ( _u + _v ) );
+   EXPECT_TRUE( ( abs( _u ) ) != ( _w + _v ) );
+   EXPECT_TRUE( ( _w + _v ) != ( abs( _u ) ) );
+
+   EXPECT_LT( _u, _v );
+   EXPECT_LT( _u, 2.0 );
+   EXPECT_LT( 0.0, _u );
+   EXPECT_LT( _u, _v + _w );
+   EXPECT_LT( _u + _v, _w );
+   EXPECT_LT( abs( _u ), abs( _w ) );
+   EXPECT_LT( abs( _u ), _v + _w );
+   EXPECT_LT( _u + _v, abs( _w ) );
+   EXPECT_LT( _u + _v, _u + _w );
+
+   EXPECT_LE( _u, _v );
+   EXPECT_LE( _u, 2.0 );
+   EXPECT_LE( 0.0, _u );
+   EXPECT_LE( _u, _v + _w );
+   EXPECT_LE( _u + _v, _w );
+   EXPECT_LE( abs( _u ), abs( _w ) );
+   EXPECT_LE( abs( _u ), _v + _w );
+   EXPECT_LE( _u + _v, abs( _w ) );
+
+   EXPECT_GT( _v, _u );
+   EXPECT_GT( _v, 1.0 );
+   EXPECT_GT( 3.0, _v );
+   EXPECT_GT( _w, _u + _v );
+   EXPECT_GT( _v + _w, _u );
+   EXPECT_GT( abs( _w ), _u + _v );
+   EXPECT_GT( _v + _w, abs( _u ) );
+
+   // Test with VectorViews
+   EXPECT_EQ( u, u );
+   EXPECT_EQ( u, 1.0 );
+   EXPECT_TRUE( 1.0 == u );
+   EXPECT_EQ( w, v + v );
+   EXPECT_EQ( v + v, w );
+   EXPECT_TRUE( abs( w ) == v + v );
+   EXPECT_TRUE( v + v == abs( w ) );
+
+   EXPECT_NE( u, v );
+   EXPECT_NE( u, 2.0 );
+   EXPECT_TRUE( 2.0 != u );
+   EXPECT_NE( u, w + w );
+   EXPECT_TRUE( w + v != u );
+   EXPECT_TRUE( abs( w ) != abs( u ) );
+   EXPECT_TRUE( ( w + v ) != ( u + v ) );
+   EXPECT_TRUE( ( abs( u ) ) != ( w + v ) );
+   EXPECT_TRUE( ( w + v ) != ( abs( u ) ) );
+
+   EXPECT_LT( u, v );
+   EXPECT_LT( u, 2.0 );
+   EXPECT_LT( 0.0, u );
+   EXPECT_LT( u, v + w );
+   EXPECT_LT( u + v, w );
+   EXPECT_LT( abs( u ), abs( w ) );
+   EXPECT_LT( abs( u ), v + w );
+   EXPECT_LT( u + v, abs( w ) );
+   EXPECT_LT( u + v, u + w );
+
+   EXPECT_LE( u, v );
+   EXPECT_LE( u, 2.0 );
+   EXPECT_LE( 0.0, u );
+   EXPECT_LE( u, v + w );
+   EXPECT_LE( u + v, w );
+   EXPECT_LE( abs( u ), abs( w ) );
+   EXPECT_LE( abs( u ), v + w );
+   EXPECT_LE( u + v, abs( w ) );
+
+   EXPECT_GT( v, u );
+   EXPECT_GT( v, 1.0 );
+   EXPECT_GT( 3.0, v );
+   EXPECT_GT( w, u + v );
+   EXPECT_GT( v + w, u );
+   EXPECT_GT( abs( w ), u + v );
+   EXPECT_GT( v + w, abs( u ) );
 }
 
 TYPED_TEST( VectorTest, horizontalOperations )