fix comparison between sparse and sparse or sparsebool and sparsebool ( intel compile...

sparse(1) == sparse(1)
sparse(1) == sparse(ones(5,5))
sparse(ones(5,5)) == sparse(1)
sparse(ones(5,5)) == sparse(ones(5,5))

test_run ast comparisonequal
test_run ast comparisonnonequal

Change-Id: I4d0d0c4ce182d8bf94f3ccddca5d2137fce10e76

diff --git a/scilab/modules/ast/includes/types/sparse.hxx b/scilab/modules/ast/includes/types/sparse.hxx
index ec02063..7af8868 100644 (file)
--- a/scilab/modules/ast/includes/types/sparse.hxx
+++ b/scilab/modules/ast/includes/types/sparse.hxx
@@ -452,7 +452,7 @@ struct EXTERN_AST Sparse : GenericType
        @return ptr to a new Sparse matrix where each element is the result of the logical operator
         '==' between the elements of *this and those of o.
      */
-    SparseBool* newEqualTo(Sparse const&o) const;
+    SparseBool* newEqualTo(Sparse &o);
 
     /**
        output 1-base column numbers of the non zero elements
@@ -729,7 +729,7 @@ struct EXTERN_AST SparseBool : GenericType
 
     Sparse* newOnes() const;
     SparseBool* newNotEqualTo(SparseBool const&o) const;
-    SparseBool* newEqualTo(SparseBool const&o) const;
+    SparseBool* newEqualTo(SparseBool& o);
 
     SparseBool* newLogicalOr(SparseBool const&o) const;
     SparseBool* newLogicalAnd(SparseBool const&o) const;

diff --git a/scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp b/scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp
index 841ad27..725ec22 100644 (file)
--- a/scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp
+++ b/scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp
@@ -2690,55 +2690,6 @@ InternalType* compequal_M_M<Sparse, Sparse, SparseBool>(Sparse* _pL, Sparse* _pR
         return new Bool(false);
     }
 
-    //int nnzL = static_cast<int>(_pL->nonZeros());
-    //int rowL = _pL->getRows();
-    //int colL = _pL->getCols();
-    //std::vector<int> rowcolL(nnzL * 2, 0);
-    //_pL->outputRowCol(rowcolL.data());
-
-    //int nnzR = static_cast<int>(_pR->nonZeros());
-    //int rowR = _pR->getRows();
-    //int colR = _pR->getCols();
-    //std::vector<int> rowcolR(nnzR * 2, 0);
-    //_pR->outputRowCol(rowcolR.data());
-
-    //int row = std::max(rowL, rowR);
-    //int col = std::max(colL, colR);
-
-    ////create a boolean sparse matrix with dims of sparses
-    //types::SparseBool* ret = new types::SparseBool(row, col);
-    //ret->setTrue(false);
-
-    ////set %f in each pL values
-    //for (int i = 0; i < nnzL; ++i)
-    //{
-    //    ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, false, false);
-    //}
-
-    ////set _pR[i] == _pL[i] for each _pR values
-    //if(_pL->isComplex() || _pR->isComplex())
-    //{
-    //    for (int i = 0; i < nnzR; ++i)
-    //    {
-    //        std::complex<double> l = _pL->getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
-    //        std::complex<double> r = _pR->getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
-    //        ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
-    //    }
-    //}
-    //else
-    //{
-    //    for (int i = 0; i < nnzR; ++i)
-    //    {
-    //        double l = _pL->get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
-    //        double r = _pR->get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
-    //        ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
-    //    }
-    //}
-
-    //ret->finalize();
-    //return ret;
-
-
     return _pR->newEqualTo(*_pL);
 }
 

diff --git a/scilab/modules/ast/src/cpp/types/sparse.cpp b/scilab/modules/ast/src/cpp/types/sparse.cpp
index 02e66bc..81c1176 100644 (file)
--- a/scilab/modules/ast/src/cpp/types/sparse.cpp
+++ b/scilab/modules/ast/src/cpp/types/sparse.cpp
@@ -2260,9 +2260,131 @@ SparseBool* Sparse::newGreaterOrEqual(Sparse const&o) const
     return cwiseOp<std::greater_equal>(*this, o);
 }
 
-SparseBool* Sparse::newEqualTo(Sparse const&o) const
+SparseBool* Sparse::newEqualTo(Sparse &o)
 {
-    return cwiseOp<std::equal_to>(*this, o);
+    int rowL = getRows();
+    int colL = getCols();
+
+    int rowR = o.getRows();
+    int colR = o.getCols();
+    int row = std::max(rowL, rowR);
+    int col = std::max(colL, colR);
+
+    //create a boolean sparse matrix with dims of sparses
+    types::SparseBool* ret = new types::SparseBool(row, col);
+
+    std::cout << "row " << row << std::endl << "col " << col << std::endl;
+
+    if (isScalar() && o.isScalar())
+    {
+        if (isComplex() || o.isComplex())
+        {
+            std::complex<double> l = getImg(0, 0);
+            std::complex<double> r = o.getImg(0, 0);
+            ret->set(0, 0, l == r, false);
+        }
+        else
+        {
+            double l = get(0, 0);
+            double r = o.get(0, 0);
+            ret->set(0, 0, l == r, false);
+        }
+    }
+    else if (isScalar())
+    {
+        int nnzR = static_cast<int>(o.nonZeros());
+        std::vector<int> rowcolR(nnzR * 2, 0);
+        o.outputRowCol(rowcolR.data());
+
+        //compare all items of R with R[0]
+        if (isComplex() || o.isComplex())
+        {
+            std::complex<double> l = getImg(0, 0);
+            for (int i = 0; i < nnzR; ++i)
+            {
+                std::complex<double> r = o.getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+            }
+        }
+        else
+        {
+            double l = get(0, 0);
+            for (int i = 0; i < nnzR; ++i)
+            {
+                double r = o.get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+            }
+        }
+    }
+    else if (o.isScalar())
+    {
+        int nnzL = static_cast<int>(nonZeros());
+        std::vector<int> rowcolL(nnzL * 2, 0);
+        outputRowCol(rowcolL.data());
+
+        if (isComplex() || o.isComplex())
+        {
+            std::complex<double> r = o.getImg(0, 0);
+            for (int i = 0; i < nnzL; ++i)
+            {
+                std::complex<double> l = getImg(rowcolL[i] - 1, rowcolL[i + nnzL] - 1);
+                ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
+            }
+        }
+        else
+        {
+            double r = get(0, 0);
+            for (int i = 0; i < nnzL; ++i)
+            {
+                double l = get(rowcolL[i] - 1, rowcolL[i + nnzL] - 1);
+                ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
+            }
+        }
+    }
+    else
+    {
+        int nnzR = static_cast<int>(o.nonZeros());
+        std::vector<int> rowcolR(nnzR * 2, 0);
+        o.outputRowCol(rowcolR.data());
+        int nnzL = static_cast<int>(nonZeros());
+        std::vector<int> rowcolL(nnzL * 2, 0);
+        outputRowCol(rowcolL.data());
+        //set all values to %t
+        ret->setTrue(false);
+        //set %f in each pL values
+        for (int i = 0; i < nnzL; ++i)
+        {
+            ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, false, false);
+        }
+        ret->finalize();
+
+        //set _pR[i] == _pL[i] for each _pR values
+        if (isComplex() || o.isComplex())
+        {
+            for (int i = 0; i < nnzR; ++i)
+            {
+                //get l and r following non zeros value of R
+                std::complex<double> l = getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                std::complex<double> r = o.getImg(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                //set value following non zeros value of R
+                ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < nnzR; ++i)
+            {
+                //get l and r following non zeros value of R
+                double l = get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                double r = o.get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+                //set value following non zeros value of R
+                ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+            }
+        }
+    }
+
+    ret->finalize();
+    return ret;
 }
 
 bool Sparse::reshape(int* _piDims, int _iDims)
@@ -3545,9 +3667,82 @@ SparseBool* SparseBool::newNotEqualTo(SparseBool const&o) const
     return cwiseOp<std::not_equal_to>(*this, o);
 }
 
-SparseBool* SparseBool::newEqualTo(SparseBool const&o) const
+SparseBool* SparseBool::newEqualTo(SparseBool& o)
 {
-    return cwiseOp<std::equal_to>(*this, o);
+    int rowL = getRows();
+    int colL = getCols();
+
+    int rowR = o.getRows();
+    int colR = o.getCols();
+    int row = std::max(rowL, rowR);
+    int col = std::max(colL, colR);
+
+    //create a boolean sparse matrix with dims of sparses
+    types::SparseBool* ret = new types::SparseBool(row, col);
+
+    if (isScalar() && o.isScalar())
+    {
+        bool l = get(0, 0);
+        bool r = o.get(0, 0);
+        ret->set(0, 0, l == r, false);
+    }
+    else if (isScalar())
+    {
+        int nnzR = static_cast<int>(o.nbTrue());
+        std::vector<int> rowcolR(nnzR * 2, 0);
+        o.outputRowCol(rowcolR.data());
+
+        //compare all items of R with R[0]
+        bool l = get(0, 0);
+        for (int i = 0; i < nnzR; ++i)
+        {
+            bool r = o.get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+            ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+        }
+    }
+    else if (o.isScalar())
+    {
+        int nnzL = static_cast<int>(nbTrue());
+        std::vector<int> rowcolL(nnzL * 2, 0);
+        outputRowCol(rowcolL.data());
+
+        bool r = get(0, 0);
+        for (int i = 0; i < nnzL; ++i)
+        {
+            bool l = get(rowcolL[i] - 1, rowcolL[i + nnzL] - 1);
+            ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, l == r, false);
+        }
+    }
+    else
+    {
+        int nnzR = static_cast<int>(o.nbTrue());
+        std::vector<int> rowcolR(nnzR * 2, 0);
+        o.outputRowCol(rowcolR.data());
+        int nnzL = static_cast<int>(nbTrue());
+        std::vector<int> rowcolL(nnzL * 2, 0);
+        outputRowCol(rowcolL.data());
+        //set all values to %t
+        ret->setTrue(false);
+        //set %f in each pL values
+        for (int i = 0; i < nnzL; ++i)
+        {
+            ret->set(rowcolL[i] - 1, rowcolL[i + nnzL] - 1, false, false);
+        }
+        ret->finalize();
+
+        //set _pR[i] == _pL[i] for each _pR values
+        for (int i = 0; i < nnzR; ++i)
+        {
+            //get l and r following non zeros value of R
+            bool l = get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+            bool r = o.get(rowcolR[i] - 1, rowcolR[i + nnzR] - 1);
+            //set value following non zeros value of R
+            ret->set(rowcolR[i] - 1, rowcolR[i + nnzR] - 1, l == r, false);
+        }
+    }
+
+    ret->finalize();
+    return ret;
 }
 
 SparseBool* SparseBool::newLogicalOr(SparseBool const&o) const