Add uniqueByRows.

src/Function1D.cpp

@@ -123,6 +123,45 @@ namespace {
     des[3] = outputPtr[3];
 
     }
+
+    bool compare(const Matrix& aA, const Matrix& aB)
+    {
+        size_t dataSize = aA.getDataSize();
+        size_t sizeB = aB.getDataSize();
+        if(dataSize > sizeB)
+        {
+            dataSize = sizeB;
+        }
+
+        for(size_t i=0; i<dataSize; ++i)
+        {
+            if(aA[i] != aB[i])
+            {
+                return aA[i] < aB[i];
+            }
+        }
+        return false;
+    }
+
+    bool isEqual(const Matrix& aA, const Matrix& aB)
+    {
+        size_t sizeA = aA.getDataSize();
+        size_t sizeB = aB.getDataSize();
+        if(sizeA != sizeB)
+        {
+            return false;
+        }
+
+        for(size_t i=0; i<sizeA; ++i)
+        {
+            if(aA[i] != aB[i])
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }
 
 
@@ -1068,3 +1107,49 @@ Matrix Aurora::convertfp16tofloat(short* aData, int aRows, int aColumns)
     }
     return Matrix::New(output,aRows,aColumns,1);
 }
+
+Matrix Aurora::uniqueByRows(const Matrix& aMatrix, Matrix& aIndexResult)
+{
+    if(aMatrix.isNull())
+    {
+        return Matrix();
+    }
+    Matrix transposeMatrix = transpose(aMatrix);
+    double* transposeMatrixData = transposeMatrix.getData();
+    int rows = transposeMatrix.getDimSize(0);
+    int columns = transposeMatrix.getDimSize(1);
+    std::vector<Matrix> uniqueResult;
+    for(int i=1; i<=columns; ++i)
+    {
+        Matrix rowData = Matrix::fromRawData(new double[rows], rows);
+        std::copy(transposeMatrixData, transposeMatrixData + rows, rowData.getData());
+        uniqueResult.push_back(rowData);
+        transposeMatrixData += rows;
+    }
+
+    std::vector<Matrix> matrixsCopy = uniqueResult;
+    std::sort(uniqueResult.begin(), uniqueResult.end(), compare);
+    auto uniqueIndex = std::unique(uniqueResult.begin(), uniqueResult.end(), isEqual);
+    uniqueResult.erase(uniqueIndex, uniqueResult.end());
+    
+    std::vector<double> indexResultData;
+    for(int i=0; i<matrixsCopy.size();++i)
+    {
+        auto index = lower_bound(uniqueResult.begin(), uniqueResult.end(), matrixsCopy[i], compare);
+        int value = distance(uniqueResult.begin(), index);
+        indexResultData.push_back(value);
+    }
+
+    aIndexResult = Matrix::copyFromRawData(indexResultData.data(), indexResultData.size());
+    size_t resultSize = rows * uniqueResult.size();
+    double* resultData = new double[resultSize];
+    Matrix result = Matrix::fromRawData(resultData, rows, uniqueResult.size()) ;
+    for(size_t i=0; i<uniqueResult.size(); ++i)
+    {
+        std::copy(uniqueResult[i].getData(), uniqueResult[i].getData() + rows, resultData);
+        resultData += rows;
+    }
+    result = transpose(result);
+
+    return result;
+}

src/Function1D.h

@@ -94,6 +94,8 @@ namespace Aurora {
     Matrix deleteColumn(const Matrix& aMatrix, int aColumnIndex);
 
     Matrix createVectorMatrix(double aStartValue, double aStepValue, double aEndValue);
+
+    Matrix uniqueByRows(const Matrix& aMatrix, Matrix& aIndexResult);
     /**
      * 并集
      * @param aIa, [C,ia,~] = intersect(A,B)用法中ia的返回值