Commit f5558f2d authored by Jakub Klinkovský's avatar Jakub Klinkovský
Browse files

Unified tests for StaticVectorExpressions with VectorExpressions and VectorViewExpressions

parent c12a66ba

scripts/make_coverage_report

+1 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ tests=( 
   UnaryVectorOperationsTest-dbg

   StaticArrayTest-dbg

   StaticVectorTest-dbg

   StaticVectorOperationsTest-dbg

   ListTest-dbg

#   MultireductionTest-dbg  # FIXME: CUDA

   MultimapTest-dbg

src/UnitTests/Containers/CMakeLists.txt

+5 −0
Original line number Diff line number Diff line
@@ -81,6 +81,10 @@ ADD_EXECUTABLE( StaticVectorTest StaticVectorTest.cpp ) 
TARGET_COMPILE_OPTIONS( StaticVectorTest PRIVATE ${CXX_TESTS_FLAGS} )

TARGET_LINK_LIBRARIES( StaticVectorTest ${GTEST_BOTH_LIBRARIES} )



ADD_EXECUTABLE( StaticVectorOperationsTest StaticVectorOperationsTest.cpp )

TARGET_COMPILE_OPTIONS( StaticVectorOperationsTest PRIVATE ${CXX_TESTS_FLAGS} )

TARGET_LINK_LIBRARIES( StaticVectorOperationsTest ${GTEST_BOTH_LIBRARIES} )





ADD_TEST( ListTest ${EXECUTABLE_OUTPUT_PATH}/ListTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( ArrayOperationsTest ${EXECUTABLE_OUTPUT_PATH}/ArrayOperationsTest${CMAKE_EXECUTABLE_SUFFIX} )
@@ -103,6 +107,7 @@ ENDIF() 
ADD_TEST( MultireductionTest ${EXECUTABLE_OUTPUT_PATH}/MultireductionTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( StaticArrayTest ${EXECUTABLE_OUTPUT_PATH}/StaticArrayTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( StaticVectorTest ${EXECUTABLE_OUTPUT_PATH}/StaticVectorTest${CMAKE_EXECUTABLE_SUFFIX} )

ADD_TEST( StaticVectorOperationsTest ${EXECUTABLE_OUTPUT_PATH}/StaticVectorOperationsTest${CMAKE_EXECUTABLE_SUFFIX} )





ADD_SUBDIRECTORY( Multimaps )

src/UnitTests/Containers/StaticArrayTest.cpp

+28 −28
Original line number Diff line number Diff line
@@ -62,41 +62,41 @@ TYPED_TEST( StaticArrayTest, constructors ) 
{

   using ArrayType = typename TestFixture::ArrayType;

   using ValueType = typename TestFixture::ValueType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ValueType data[ Size ];

   for( int i = 0; i < Size; i++ )

   ValueType data[ size ];

   for( int i = 0; i < size; i++ )

      data[ i ] = i;



   ArrayType u0;

   EXPECT_TRUE( u0.getData() );



   ArrayType u1( data );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u1[ i ], data[ i ] );



   ArrayType u2( 7 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u2[ i ], 7 );



   ArrayType u3( u1 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u3[ i ], u1[ i ] );



   // initialization with 0 requires special treatment to avoid ambiguity,

   // see https://stackoverflow.com/q/4610503

   ArrayType v( 0 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( v[ i ], 0 );

}



TYPED_TEST( StaticArrayTest, getSize )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u;

   EXPECT_EQ( u.getSize(), Size );

   EXPECT_EQ( u.getSize(), size );

}



TYPED_TEST( StaticArrayTest, getData )
@@ -143,18 +143,18 @@ void checkCoordinates( StaticArray< 3, Value >& u ) 
   EXPECT_EQ( u.z(), 3 );

}



template< int _Size, typename Value >

void checkCoordinates( StaticArray< _Size, Value >& u )

template< int _size, typename Value >

void checkCoordinates( StaticArray< _size, Value >& u )

{

}



TYPED_TEST( StaticArrayTest, CoordinatesGetter )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u;

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      u[ i ] = i;



   checkCoordinates( u );
@@ -163,11 +163,11 @@ TYPED_TEST( StaticArrayTest, CoordinatesGetter ) 
TYPED_TEST( StaticArrayTest, ComparisonOperator )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u1, u2, u3;



   for( int i = 0; i < Size; i++ ) {

   for( int i = 0; i < size; i++ ) {

      u1[ i ] = 1;

      u2[ i ] = i;

      u3[ i ] = i;
@@ -178,12 +178,12 @@ TYPED_TEST( StaticArrayTest, ComparisonOperator ) 
   EXPECT_TRUE( u2 == u3 );



   // comparison with different type

   StaticArray< Size, char > u4( 1 );

   StaticArray< size, char > u4( 1 );

   EXPECT_TRUE( u1 == u4 );

   EXPECT_TRUE( u2 != u4 );

   EXPECT_TRUE( u3 != u4 );



   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      u4[ i ] = i;

   EXPECT_TRUE( u1 != u4 );

   EXPECT_TRUE( u2 == u4 );
@@ -193,11 +193,11 @@ TYPED_TEST( StaticArrayTest, ComparisonOperator ) 
TYPED_TEST( StaticArrayTest, AssignmentOperator )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u1, u2, u3;



   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

   {

      u1[ i ] = 1;

      u2[ i ] = i;
@@ -212,7 +212,7 @@ TYPED_TEST( StaticArrayTest, AssignmentOperator ) 
   EXPECT_TRUE( u3 != u1 );



   // assignment from different type

   StaticArray< Size, char > u4( 127 );

   StaticArray< size, char > u4( 127 );

   u3 = u4;

   EXPECT_TRUE( u3 == u4 );

}
@@ -220,19 +220,19 @@ TYPED_TEST( StaticArrayTest, AssignmentOperator ) 
TYPED_TEST( StaticArrayTest, setValue )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u;

   u.setValue( 42 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u[ i ], 42 );

}



TYPED_TEST( StaticArrayTest, CastToDifferentStaticArray )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   using OtherArray = StaticArray< Size, char >;

   constexpr int size = ArrayType::getSize();

   using OtherArray = StaticArray< size, char >;



   ArrayType u1( 1 );

   OtherArray u2( 1 );
@@ -261,14 +261,14 @@ TYPED_TEST( StaticArrayTest, SaveAndLoad ) 
TYPED_TEST( StaticArrayTest, sort )

{

   using ArrayType = typename TestFixture::ArrayType;

   constexpr int Size = ArrayType::getSize();

   constexpr int size = ArrayType::getSize();



   ArrayType u;

   for( int i = 0; i < Size; i++ )

      u[ i ] = Size - i - 1;

   for( int i = 0; i < size; i++ )

      u[ i ] = size - i - 1;

   u.sort();



   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u[ i ], i );

}

src/UnitTests/Containers/StaticVectorOperationsTest.cpp

0 → 100644
+4 −0
Original line number Diff line number Diff line 
#define STATIC_VECTOR

#include "VectorBinaryOperationsTest.h"

#include "VectorUnaryOperationsTest.h"

#include "../main.h"

src/UnitTests/Containers/StaticVectorTest.cpp

+7 −509
Original line number Diff line number Diff line
@@ -61,120 +61,32 @@ TYPED_TEST( StaticVectorTest, constructors ) 
{

   using VectorType = typename TestFixture::VectorType;

   using RealType = typename TestFixture::RealType;

   constexpr int Size = VectorType::getSize();

   constexpr int size = VectorType::getSize();



   RealType data[ Size ];

   for( int i = 0; i < Size; i++ )

   RealType data[ size ];

   for( int i = 0; i < size; i++ )

      data[ i ] = i;



   VectorType u0;

   EXPECT_TRUE( u0.getData() );



   VectorType u1( data );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u1[ i ], data[ i ] );



   VectorType u2( 7 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u2[ i ], 7 );



   VectorType u3( u1 );

   for( int i = 0; i < Size; i++ )

   for( int i = 0; i < size; i++ )

      EXPECT_EQ( u3[ i ], u1[ i ] );



   // initialization with 0 requires special treatment to avoid ambiguity,

   // see https://stackoverflow.com/q/4610503

   VectorType v( 0 );

   for( int i = 0; i < Size; i++ )

      EXPECT_EQ( v[ i ], 0 );

}



TYPED_TEST( StaticVectorTest, operators )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   static_assert( HasSubscriptOperator< VectorType >::value, "Subscript operator detection by SFINAE does not work for StaticVector." );



   VectorType u1( 1 ), u2( 2 ), u3( 3 );



   u1 += u2;

   EXPECT_EQ( u1[ 0 ], 3 );

   EXPECT_EQ( u1[ size - 1 ], 3 );



   u1 -= u2;

   EXPECT_EQ( u1[ 0 ], 1 );

   EXPECT_EQ( u1[ size - 1 ], 1 );



   u1 *= 2;

   EXPECT_EQ( u1[ 0 ], 2 );

   EXPECT_EQ( u1[ size - 1 ], 2 );



   u3 = u1 + u2;

   EXPECT_EQ( u3[ 0 ], 4 );

   EXPECT_EQ( u3[ size - 1 ], 4 );



   u3 = u1 - u2;

   EXPECT_EQ( u3[ 0 ], 0 );

   EXPECT_EQ( u3[ size - 1 ], 0 );



   u3 = 2 * u1;

   EXPECT_EQ( u3[ 0 ], 4 );

   EXPECT_EQ( u3[ size - 1 ], 4 );



   u3 = u1 * u2;

   EXPECT_EQ( u3[ 0 ], 4 );

   EXPECT_EQ( u3[ size - 1 ], 4 );



   EXPECT_EQ( dot( u1, u2 ), 4 * size );

   EXPECT_EQ( ( u1, u2 ), 4 * size );

}



TYPED_TEST( StaticVectorTest, MinMax )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u1( 1 ), u2( 2 ), u3( 3 ), u4, u_min, u_max;

   for( int i = 0; i < size; i++ )

   {

      u4[ i ] = i;

      u_min[ i ] = TNL::min( i, 3 );

      u_max[ i ] = TNL::max( i, 3 );

   }



   EXPECT_TRUE( min( u1, u2 ) ==  u1 );

   EXPECT_TRUE( max( u1, u2 ) ==  u2 );

   EXPECT_TRUE( min( u3, u4 ) == u_min );

   EXPECT_TRUE( max( u3, u4 ) == u_max );

}



TYPED_TEST( StaticVectorTest, comparisons )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u1( 1 ), u2( 2 ), u3( 3 ), u4;

   for( int i = 0; i < size; i++ )

      u4[ i ] = i;



   EXPECT_TRUE( u1 < u3 );

   EXPECT_TRUE( u1 <= u3 );

   EXPECT_TRUE( u1 < u2 );

   EXPECT_TRUE( u1 <= u2 );

   EXPECT_TRUE( u3 > u1 );

   EXPECT_TRUE( u3 >= u1 );

   EXPECT_TRUE( u2 > u1 );

   EXPECT_TRUE( u2 >= u1 );

   EXPECT_TRUE( u1 != u4 );

   EXPECT_FALSE( u1 == u2 );



   if( size > 2 ) {

      EXPECT_FALSE( u1 < u4 );

      EXPECT_FALSE( u1 <= u4 );

      EXPECT_FALSE( u1 > u4 );

      EXPECT_FALSE( u1 >= u4 );

   }

      EXPECT_EQ( v[ i ], 0 );

}



TYPED_TEST( StaticVectorTest, cast )
@@ -186,420 +98,6 @@ TYPED_TEST( StaticVectorTest, cast ) 
   EXPECT_EQ( (StaticVector< size, double >) u, u );

}



TYPED_TEST( StaticVectorTest, abs )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u;

   for( int i = 0; i < size; i++ )

      u[ i ] = i;



   VectorType v = -u;

   EXPECT_EQ( abs( v ), u );

}



TYPED_TEST( StaticVectorTest, sin )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = sin( u[ i ] );

   }



   EXPECT_EQ( sin( u ), v );

}



TYPED_TEST( StaticVectorTest, cos )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = cos( u[ i ] );

   }



   EXPECT_EQ( cos( u ), v );

}



TYPED_TEST( StaticVectorTest, tan )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = tan( u[ i ] );

   }



   EXPECT_EQ( tan( u ), v );

}



TYPED_TEST( StaticVectorTest, sqrt )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i;

      v[ i ] = sqrt( u[ i ] );

   }



   EXPECT_EQ( sqrt( u ), v );

}



TYPED_TEST( StaticVectorTest, cbrt )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i;

      v[ i ] = cbrt( u[ i ] );

   }



   for( int i = 0; i < size; i++ )

      EXPECT_NEAR( cbrt( u )[ i ], v[ i ], 1.0e-6 );

}



TYPED_TEST( StaticVectorTest, pow )

{

   using VectorType = typename TestFixture::VectorType;

   using RealType = typename VectorType::RealType;

   constexpr int size = VectorType::getSize();



   VectorType u, v, w;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = pow( u[ i ], 2.0 );

      w[ i ] = pow( u[ i ], 3.0 );

   }



   EXPECT_EQ( pow( u, 2.0 ), v );

   EXPECT_EQ( pow( u, 3.0 ), w );

}



TYPED_TEST( StaticVectorTest, floor )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = floor( u[ i ] );

   }



   EXPECT_EQ( floor( u ), v );

}



TYPED_TEST( StaticVectorTest, ceil )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = ceil( u[ i ] );

   }



   EXPECT_EQ( ceil( u ), v );

}



TYPED_TEST( StaticVectorTest, acos )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = ( double )( i - size / 2 ) / ( double ) size;

      v[ i ] = acos( u[ i ] );

   }



   EXPECT_EQ( acos( u ), v );

}



TYPED_TEST( StaticVectorTest, asin )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = ( double ) ( i - size / 2 ) / ( double ) size;

      v[ i ] = asin( u[ i ] );

   }



   EXPECT_EQ( asin( u ), v );

}



TYPED_TEST( StaticVectorTest, atan )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = atan( u[ i ] );

   }



   EXPECT_EQ( atan( u ), v );

}



TYPED_TEST( StaticVectorTest, cosh )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = cosh( u[ i ] );

   }



   // EXPECT_EQ( cosh( u ), v ) does not work here for float, maybe because

   // of some fast-math optimization

   for( int i = 0; i < size; i++ )

      EXPECT_NEAR( cosh( u )[ i ], v[ i ], 1.0e-6 );

}



TYPED_TEST( StaticVectorTest, tanh )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = tanh( u[ i ] );

   }



   EXPECT_EQ( tanh( u ), v );

}



TYPED_TEST( StaticVectorTest, log )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i + 1;

      v[ i ] = log( u[ i ] );

   }



   EXPECT_EQ( log( u ), v );

}



TYPED_TEST( StaticVectorTest, log10 )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i + 1;

      v[ i ] = log10( u[ i ] );

   }



   // EXPECT_EQ( log10( u ), v ) does not work here for float, maybe because

   // of some fast-math optimization

   for( int i = 0; i < size; i++ )

      EXPECT_NEAR( log10( u )[ i ], v[ i ], 1.0e-6 );

}



TYPED_TEST( StaticVectorTest, log2 )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i + 1;

      v[ i ] = log2( u[ i ] );

   }



   EXPECT_EQ( log2( u ), v );

}



TYPED_TEST( StaticVectorTest, exp )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = exp( u[ i ] );

   }



   EXPECT_EQ( exp( u ), v );

}



TYPED_TEST( StaticVectorTest, sign )

{

   using VectorType = typename TestFixture::VectorType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   for( int i = 0; i < size; i++ )

   {

      u[ i ] = i - size / 2;

      v[ i ] = sign( u[ i ] );

   }



   // TODO: replace with EXPECT_EQ when nvcc accepts it

   EXPECT_TRUE( sign( u ) == v );

}



TYPED_TEST( StaticVectorTest, lpNorm )

{

   using VectorType = typename TestFixture::VectorType;

   using RealType = typename TestFixture::RealType;

   constexpr int size = VectorType::getSize();

   const RealType epsilon = std::numeric_limits< RealType >::epsilon();



   VectorType v( 1 );



   const RealType expectedL1norm = size;

   const RealType expectedL2norm = std::sqrt( size );

   const RealType expectedL3norm = std::cbrt( size );

   EXPECT_EQ( lpNorm( v, 1.0 ), expectedL1norm );

   EXPECT_EQ( lpNorm( v, 2.0 ), expectedL2norm );

   EXPECT_NEAR( lpNorm( v, 3.0 ), expectedL3norm, epsilon );

}



TYPED_TEST( StaticVectorTest, verticalOperations )

{

   using VectorType = typename TestFixture::VectorType;



   using RealType = typename VectorType::RealType;

   constexpr int size = VectorType::getSize();



   VectorType u, v;

   RealType sum_( 0.0 ), absSum( 0.0 ), diffSum( 0.0 ), diffAbsSum( 0.0 ),

   absMin( size + 10.0 ), absMax( -size - 10.0 ),

   diffMin( 2 * size + 10.0 ), diffMax( - 2.0 * size - 10.0 ),

   l2Norm( 0.0 ), l2NormDiff( 0.0 );

   for( int i = 0; i < size; i++ )

   {

      const RealType aux = ( RealType )( i - size / 2 ) / ( RealType ) size;

      u[ i ] = aux;

      v[ i ] = -aux;

      absMin = TNL::min( absMin, TNL::abs( aux ) );

      absMax = TNL::max( absMax, TNL::abs( aux ) );

      diffMin = TNL::min( diffMin, 2 * aux );

      diffMax = TNL::max( diffMax, 2 * aux );

      sum_ += aux;

      absSum += TNL::abs( aux );

      diffSum += 2.0 * aux;

      diffAbsSum += TNL::abs( 2.0* aux );

      l2Norm += aux * aux;

      l2NormDiff += 4.0 * aux * aux;

   }

   l2Norm = TNL::sqrt( l2Norm );

   l2NormDiff = TNL::sqrt( l2NormDiff );





   EXPECT_EQ( min( u ), u[ 0 ] );

   EXPECT_EQ( max( u ), u[ size - 1 ] );

   EXPECT_NEAR( sum( u ), sum_, 2.0e-5 );

   EXPECT_EQ( min( abs( u ) ), absMin );

   EXPECT_EQ( max( abs( u ) ), absMax );

   EXPECT_EQ( min( u - v ), diffMin );

   EXPECT_EQ( max( u - v ), diffMax );

   EXPECT_NEAR( sum( u - v ), diffSum, 2.0e-5 );

   EXPECT_NEAR( sum( abs( u - v ) ), diffAbsSum, 2.0e-5 );

   EXPECT_NEAR( lpNorm( u, 2.0 ), l2Norm, 2.0e-5 );

   EXPECT_NEAR( lpNorm( u - v, 2.0 ), l2NormDiff, 2.0e-5 );

}



TYPED_TEST( StaticVectorTest, comparisonOperators )

{

   using namespace TNL::Containers::Expressions;

   using VectorType = typename TestFixture::VectorType;

   using RealType = typename VectorType::RealType;



   VectorType u, v, w;

   u = 1.0;

   v = 2.0;

   w = 4.0;



   EXPECT_EQ( u, u );

   EXPECT_EQ( u, 1.0 );

   EXPECT_EQ( 1.0, u );

   EXPECT_EQ( w, v + v );

   EXPECT_EQ( v + v, w );

   EXPECT_EQ( abs( w ), v + v );

   EXPECT_EQ( v + v, abs( w ) );



   EXPECT_NE( u, v );

   EXPECT_NE( u, 2.0 );

   EXPECT_NE( 2.0, u );

   EXPECT_NE( u, w + w );

   EXPECT_NE( w + v, u );

   EXPECT_NE( abs( w ), abs( u ) );

   EXPECT_NE( ( w + v ), ( u + v ) );

   EXPECT_NE( ( abs( u ) ), ( w + v ) );

   EXPECT_NE( ( 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 ) );

}



#endif





#include "../main.h"