diff --git a/CMakeLists.txt b/CMakeLists.txt
index 16fae3f..fa5b445 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,13 +1,15 @@
 cmake_minimum_required(VERSION 3.16)
 project(Aurora)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(Aurora_USE_CUDA ON)
 
 if (Aurora_USE_CUDA)
 set(CMAKE_CUDA_COMPILER /usr/local/cuda/bin/nvcc)
+
+
 enable_language(CUDA)
 find_package(CUDAToolkit REQUIRED)
 add_definitions(-DUSE_CUDA)
@@ -44,7 +46,7 @@ if (Aurora_USE_CUDA)
 target_include_directories(Aurora PRIVATE ./src /usr/local/cuda/include) 
 set_target_properties(Aurora PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_compile_options(Aurora PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
-    -arch=sm_75
+    -arch=sm_75 --expt-extended-lambda
 >)
 target_link_libraries(Aurora PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
 endif(Aurora_USE_CUDA)
@@ -70,7 +72,7 @@ if (Aurora_USE_CUDA)
 target_include_directories(Aurora_Test PRIVATE ./src /usr/local/cuda/include) 
 set_target_properties(Aurora_Test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 target_compile_options(Aurora_Test PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:
-    -arch=sm_75
+    -arch=sm_75 --expt-extended-lambda
 >)
 target_link_libraries(Aurora_Test PRIVATE ${CUDA_RUNTIME_LIBRARY} CUDA::cufft CUDA::cudart)
 endif(Aurora_USE_CUDA)
diff --git a/src/Function1D.cu b/src/Function1D.cu
index d2339f8..fbfd7e0 100644
--- a/src/Function1D.cu
+++ b/src/Function1D.cu
@@ -6,9 +6,12 @@
 #include <thrust/device_vector.h>
 #include <thrust/transform.h>
 #include <thrust/iterator/constant_iterator.h>
+#include <thrust/iterator/counting_iterator.h>
+#include <thrust/complex.h>
 #include <cuda_runtime.h>
 
 using namespace Aurora;
+using namespace thrust::placeholders;
 
 namespace
 {
@@ -247,7 +250,7 @@ CudaMatrix Aurora::abs(const CudaMatrix& aMatrix)
     float* data = nullptr;
     cudaMalloc((void**)&data, sizeof(float) * size);
     int blocksPerGrid = (size + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK;
-    absKernel<<<blocksPerGrid, THREADS_PER_BLOCK>>>(aMatrix.getData(), data, size, aMatrix.isComplex());
+    absKernel<<<blocksPerGrid,THREADS_PER_BLOCK >>>(aMatrix.getData(), data, size, aMatrix.isComplex());
     cudaDeviceSynchronize();
     return Aurora::CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2));
 }
@@ -313,6 +316,268 @@ CudaMatrix Aurora::sign(const CudaMatrix&& aMatrix)
     return Aurora::CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2), aMatrix.getValueType());
 }
 
+
+void Aurora::compareSet(CudaMatrix& aValueMatrix,float compareValue, float newValue,CompareOp op)
+{
+    switch (op)
+    {
+    case GT:
+    {
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x>compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    case NG:{
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x<=compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    case EQ:{
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x==compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    case NE:{
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x!=compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    case NL:{
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x>=compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    case LT:{
+        auto lambda = [=] __host__ __device__ (const float& x){
+            return x<compareValue?newValue:x;
+        };
+        thrust::transform(thrust::device,aValueMatrix.getData(),aValueMatrix.getData()+aValueMatrix.getDataSize(),aValueMatrix.getData(),lambda);
+        break;
+    }
+    default:
+        break;
+    }
+
+}
+
+void Aurora::compareSet(CudaMatrix& aValueMatrix,CudaMatrix& aCompareMatrix,float compareValue, float newValue,CompareOp op){
+    switch (op)
+    {
+    case GT:
+    {
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NG:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<=compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    case EQ:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x==compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NE:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x!=compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NL:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>=compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    case LT:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<compareValue?newValue:y;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aValueMatrix.getDataSize(),
+            aValueMatrix.getData(), aValueMatrix.getData(),
+            lambda);
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+void Aurora::compareSet(CudaMatrix& aDesAndCompareMatrix,CudaMatrix& aOtherCompareMatrix, float newValue,CompareOp op){
+    switch (op)
+    {
+    case GT:
+    {
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NG:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<=y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case EQ:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x==y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NE:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x!=y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NL:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>=y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case LT:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<y?newValue:x;
+        };
+        thrust::transform(thrust::device,aDesAndCompareMatrix.getData(),
+            aDesAndCompareMatrix.getData()+aDesAndCompareMatrix.getDataSize(),
+            aOtherCompareMatrix.getData(), aDesAndCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+void Aurora::compareSet(CudaMatrix& aCompareMatrix,float compareValue, CudaMatrix& aNewValueMatrix,CompareOp op)
+{
+    switch (op)
+    {
+    case GT:
+    {
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NG:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<=compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case EQ:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x==compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NE:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x!=compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case NL:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x>=compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    case LT:{
+        auto lambda = [=] __host__ __device__ (const float& x, const float& y){
+            return x<compareValue?y:x;
+        };
+        thrust::transform(thrust::device,aCompareMatrix.getData(),
+            aCompareMatrix.getData()+aCompareMatrix.getDataSize(),
+            aNewValueMatrix.getData(), aCompareMatrix.getData(),
+            lambda);
+        break;
+    }
+    default:
+        break;
+    }
+}
+
 __global__ void repMatKernel(float* aInputData, float* aOutput, unsigned int aInputSize, bool aIsComplex)
 {
     unsigned int idX = blockIdx.x * blockDim.x + threadIdx.x;
diff --git a/src/Function1D.cuh b/src/Function1D.cuh
index 0bedd57..fbe6387 100644
--- a/src/Function1D.cuh
+++ b/src/Function1D.cuh
@@ -2,6 +2,7 @@
 #define AURORA_CUDA_FUNCTION1D_H
 
 #include "CudaMatrix.h"
+#include "Function1D.h"
 
 namespace Aurora
 {
@@ -33,6 +34,8 @@ namespace Aurora
     CudaMatrix sqrt(const CudaMatrix&& aMatrix);
 
     CudaMatrix abs(const CudaMatrix& aMatrix);
+    CudaMatrix abs2(const CudaMatrix& aMatrix);
+
 
     CudaMatrix abs(const CudaMatrix&& aMatrix);
 
@@ -47,6 +50,16 @@ namespace Aurora
     CudaMatrix repmat3d(const CudaMatrix& aMatrix,int aRowTimes, int aColumnTimes, int aSliceTimes);
 
     CudaMatrix log(const CudaMatrix& aMatrix, int aBaseNum = -1);
+
+
+
+    // ------compareSet----------------------------------------------------
+
+
+    void compareSet(CudaMatrix& aValueMatrix,float compareValue, float newValue,CompareOp op);
+    void compareSet(CudaMatrix& aValueMatrix,CudaMatrix& aCompareMatrix,float compareValue, float newValue,CompareOp op);
+    void compareSet(CudaMatrix& aDesAndCompareMatrix,CudaMatrix& aOtherCompareMatrix, float newValue,CompareOp op);
+    void compareSet(CudaMatrix& aCompareMatrix,float compareValue, CudaMatrix& aNewValueMatrix,CompareOp op);
 }
 
 #endif //AURORA_CUDA_FUNCTION1D_H
\ No newline at end of file
diff --git a/test/Function1D_Cuda_Test.cpp b/test/Function1D_Cuda_Test.cpp
index 57818b5..c1784e8 100644
--- a/test/Function1D_Cuda_Test.cpp
+++ b/test/Function1D_Cuda_Test.cpp
@@ -173,24 +173,33 @@ TEST_F(Function1D_Cuda_Test, sqrt)
 
 TEST_F(Function1D_Cuda_Test, abs)
 {
-    Aurora::Matrix hostMatrix = Aurora::Matrix::fromRawData(new float[8]{1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8}, 2,4);
+    Aurora::Matrix hostMatrix = Aurora::Matrix::fromRawData(new float[10000]{0}, 1,10000);
+    for (size_t i = 0; i < 10000; i++)
+    {
+        hostMatrix[i]=i;
+    }
+    
     Aurora::CudaMatrix deviceMatrix = hostMatrix.toDeviceMatrix();
     
     auto result1 = Aurora::abs(hostMatrix);
     auto result2 = Aurora::abs(deviceMatrix).toHostMatrix();
-    EXPECT_EQ(result2.getDataSize(), 8);
+    // EXPECT_EQ(result2.getDataSize(), 8);
     EXPECT_EQ(result2.getValueType(), Aurora::Normal);
+
     for(size_t i=0; i<result1.getDataSize(); ++i)
     {
         EXPECT_EQ(result1[i], result2[i]);
+
     }
 
     hostMatrix = Aurora::Matrix::fromRawData(new float[8]{1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8}, 2,2,1,Aurora::Complex);
     deviceMatrix = hostMatrix.toDeviceMatrix();
     result1 = Aurora::abs(hostMatrix);
     result2 = Aurora::abs(deviceMatrix).toHostMatrix();
+
     EXPECT_EQ(result2.getDataSize(), 4);
     EXPECT_EQ(result2.getValueType(), Aurora::Normal);
+
     for(size_t i=0; i<result1.getDataSize() * result1.getValueType(); ++i)
     {
         EXPECT_EQ(result1[i], result2[i]);
@@ -294,3 +303,347 @@ TEST_F(Function1D_Cuda_Test, log)
         EXPECT_FLOAT_AE(result1[i], result2[i]);
     }
 }
+
+
+TEST_F(Function1D_Cuda_Test, compareSet)
+{
+    Aurora::Matrix A =Aurora::Matrix::fromRawData(new float[9]{0},9,1);
+    Aurora::Matrix B =Aurora::Matrix::fromRawData(new float[9]{0},9,1);
+    for (int i = 0; i < 9; ++i) {
+        A[i]=(float)(i-3);
+        B[i]=(float)(i+2);
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,0,0,Aurora::LT);
+        compareSet(A,0,0,Aurora::LT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        auto A = dA.toHostMatrix();
+        compareSet(dA,0,0,Aurora::GT);
+        compareSet(A,0,0,Aurora::GT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        auto A = dA.toHostMatrix();
+        compareSet(dA,-1,0,Aurora::EQ);
+        compareSet(A,-1,0,Aurora::EQ);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        auto A = dA.toHostMatrix();
+        compareSet(dA,-1,0,Aurora::NE);
+        compareSet(A,-1,0,Aurora::NE);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        auto A = dA.toHostMatrix();
+        compareSet(dA,-1,0,Aurora::NL);
+        compareSet(A,-1,0,Aurora::NL);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    {
+
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        auto A = dA.toHostMatrix();
+        compareSet(dA,-1,0,Aurora::NG);
+        compareSet(A,-1,0,Aurora::NG);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //Function m m v v
+    //NE
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,4,-1,Aurora::NE);
+        compareSet(A,B,4,-1,Aurora::NE);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //EQ
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,4,-1,Aurora::EQ);
+        compareSet(A,B,4,-1,Aurora::EQ);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //GT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,1,-1,Aurora::GT);
+        compareSet(A,B,1,-1,Aurora::GT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::LT);
+        compareSet(A,B,3,-1,Aurora::LT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //NL
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::NL);
+        compareSet(A,B,3,-1,Aurora::NL);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::NG);
+        compareSet(A,B,3,-1,Aurora::NG);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //Function m m v 
+    //NE
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::NE);
+        compareSet(A,B,-1,Aurora::NE);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //EQ
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::EQ);
+        compareSet(A,B,-1,Aurora::EQ);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //GT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::GT);
+        compareSet(A,B,-1,Aurora::GT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::LT);
+        compareSet(A,B,-1,Aurora::LT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //NL
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::NL);
+        compareSet(A,B,-1,Aurora::NL);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,-1,Aurora::NG);
+        compareSet(A,B,-1,Aurora::NG);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+        //Function m m v v
+    //NE
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,4,-1,Aurora::NE);
+        compareSet(A,B,4,-1,Aurora::NE);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //EQ
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,4,-1,Aurora::EQ);
+        compareSet(A,B,4,-1,Aurora::EQ);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //GT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,1,-1,Aurora::GT);
+        compareSet(A,B,1,-1,Aurora::GT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::LT);
+        compareSet(A,B,3,-1,Aurora::LT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //NL
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::NL);
+        compareSet(A,B,3,-1,Aurora::NL);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,dB,3,-1,Aurora::NG);
+        compareSet(A,B,3,-1,Aurora::NG);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //Function m v m
+    //NE
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::NE);
+        compareSet(A,-1,B,Aurora::NE);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //EQ
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::EQ);
+        compareSet(A,-1,B,Aurora::EQ);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //GT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::GT);
+        compareSet(A,-1,B,Aurora::GT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::LT);
+        compareSet(A,-1,B,Aurora::LT);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //NL
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::NL);
+        compareSet(A,-1,B,Aurora::NL);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+    //LT
+    {
+        Aurora::CudaMatrix dB = B.toDeviceMatrix();
+        Aurora::CudaMatrix dA = A.toDeviceMatrix();
+        compareSet(dA,-1,dB,Aurora::NG);
+        compareSet(A,-1,B,Aurora::NG);
+        for (size_t i = 0; i < 9; i++)
+        {
+            EXPECT_EQ(dA.getValue(i), A[i]);
+        }
+    }
+}