ast types::subtraction used to call overload on eye() - sparse([1 2; 3 4]) operations 00/17600/3
Pierre-Aime Agnel [Mon, 28 Dec 2015 14:55:01 +0000 (15:55 +0100)]
Corrected dia.ref to take into account empty operations with operation-
Changed set(x, y, value) to set(x, y, value, false) and finalize on
sparse matrices (from commit https://codereview.scilab.org/#/c/17282/11)

Change-Id: Ie103b6f010868cb437d0d4e00fc8b5e68f8fab4b

13 files changed:
scilab/modules/ast/src/cpp/operations/types_addition.cpp
scilab/modules/ast/src/cpp/operations/types_comparison_eq.cpp
scilab/modules/ast/src/cpp/operations/types_comparison_ne.cpp
scilab/modules/ast/src/cpp/operations/types_divide.cpp
scilab/modules/ast/src/cpp/operations/types_dotdivide.cpp
scilab/modules/ast/src/cpp/operations/types_dotmultiplication.cpp
scilab/modules/ast/src/cpp/operations/types_ldivide.cpp
scilab/modules/ast/src/cpp/operations/types_or.cpp
scilab/modules/ast/src/cpp/operations/types_power.cpp
scilab/modules/ast/src/cpp/operations/types_subtraction.cpp
scilab/modules/ast/tests/unit_tests/return.dia.ref
scilab/modules/ast/tests/unit_tests/return.tst
scilab/modules/ast/tests/unit_tests/subtraction.dia.ref

index 5bdcbbe..ae57b6a 100644 (file)
@@ -891,17 +891,18 @@ int AddSparseToDouble(Sparse* sp, Double* d, GenericType** pDRes)
         {
             for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
             {
-                pS->set(i, i, std::complex<double>(d->get(0), d->getImg(0)));
+                pS->set(i, i, std::complex<double>(d->get(0), d->getImg(0)), false);
             }
         }
         else
         {
             for (int i = 0 ; i < std::min(sp->getRows(), sp->getCols()) ; i++)
             {
-                pS->set(i, i, d->get(0));
+                pS->set(i, i, d->get(0), false);
             }
         }
 
+        pS->finalize();
         AddSparseToSparse(sp, pS, (Sparse**)pDRes);
         delete pS;
         return 0;
index 5dfd19f..addcb0f 100644 (file)
@@ -2728,7 +2728,7 @@ InternalType* compequal_M_SP(T* _pL, U* _pR)
             std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2736,7 +2736,7 @@ InternalType* compequal_M_SP(T* _pL, U* _pR)
             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pL->get(0));
+                pspConvert->set(i, (double)_pL->get(0), false);
             }
         }
     }
@@ -2756,7 +2756,7 @@ InternalType* compequal_M_SP(T* _pL, U* _pR)
             for (int i = 0; i < iSizeOut; i++)
             {
                 std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2764,11 +2764,12 @@ InternalType* compequal_M_SP(T* _pL, U* _pR)
             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pL->get(i));
+                pspConvert->set(i, (double)_pL->get(i), false);
             }
         }
     }
 
+    pspConvert->finalize();
     pOut = _pR->newEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2791,7 +2792,7 @@ InternalType* compequal_SP_M(T* _pL, U* _pR)
             std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2799,7 +2800,7 @@ InternalType* compequal_SP_M(T* _pL, U* _pR)
             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pR->get(0));
+                pspConvert->set(i, (double)_pR->get(0), false);
             }
         }
     }
@@ -2827,12 +2828,13 @@ InternalType* compequal_SP_M(T* _pL, U* _pR)
             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pR->get(i));
+                pspConvert->set(i, (double)_pR->get(i), false);
 
             }
         }
     }
 
+    pspConvert->finalize();
     pOut = _pL->newEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2857,7 +2859,7 @@ InternalType* compequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool*
         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pL->get(0) == 1);
+            pspConvert->set(i, _pL->get(0) == 1, false);
         }
 
     }
@@ -2874,10 +2876,11 @@ InternalType* compequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBool*
         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pL->get(i) == 1);
+            pspConvert->set(i, _pL->get(i) == 1, false);
         }
     }
 
+    pspConvert->finalize();
     pOut = _pR->newEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2898,7 +2901,7 @@ InternalType* compequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool*
         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pR->get(0) == 1);
+            pspConvert->set(i, _pR->get(0) == 1, false);
         }
 
     }
@@ -2915,10 +2918,11 @@ InternalType* compequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Bool*
         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pR->get(i) == 1);
+            pspConvert->set(i, _pR->get(i) == 1, false);
         }
     }
 
+    pspConvert->finalize();
     pOut = _pL->newEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
index 41902a5..1755ec6 100644 (file)
@@ -2734,7 +2734,7 @@ InternalType* compnoequal_M_SP(T* _pL, U* _pR)
             std::complex<double> stComplex((double)_pL->get(0), (double)_pL->getImg(0));
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2742,7 +2742,7 @@ InternalType* compnoequal_M_SP(T* _pL, U* _pR)
             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pL->get(0));
+                pspConvert->set(i, (double)_pL->get(0), false);
             }
         }
     }
@@ -2762,7 +2762,7 @@ InternalType* compnoequal_M_SP(T* _pL, U* _pR)
             for (int i = 0; i < iSizeOut; i++)
             {
                 std::complex<double> stComplex((double)_pL->get(i), (double)_pL->getImg(i));
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2770,11 +2770,12 @@ InternalType* compnoequal_M_SP(T* _pL, U* _pR)
             pspConvert = new Sparse(_pR->getRows(), _pR->getCols(), _pR->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pL->get(i));
+                pspConvert->set(i, (double)_pL->get(i), false);
             }
         }
     }
 
+    pspConvert->finalize();
     pOut = _pR->newNotEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2798,7 +2799,7 @@ InternalType* compnoequal_SP_M(T* _pL, U* _pR)
             std::complex<double> stComplex((double)_pR->get(0), (double)_pR->getImg(0));
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2806,7 +2807,7 @@ InternalType* compnoequal_SP_M(T* _pL, U* _pR)
             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pR->get(0));
+                pspConvert->set(i, (double)_pR->get(0), false);
             }
         }
     }
@@ -2826,7 +2827,7 @@ InternalType* compnoequal_SP_M(T* _pL, U* _pR)
             for (int i = 0; i < iSizeOut; i++)
             {
                 std::complex<double> stComplex((double)_pR->get(i), (double)_pR->getImg(i));
-                pspConvert->set(i, stComplex);
+                pspConvert->set(i, stComplex, false);
             }
         }
         else
@@ -2834,11 +2835,12 @@ InternalType* compnoequal_SP_M(T* _pL, U* _pR)
             pspConvert = new Sparse(_pL->getRows(), _pL->getCols(), _pL->isComplex());
             for (int i = 0; i < iSizeOut; i++)
             {
-                pspConvert->set(i, (double)_pR->get(i));
+                pspConvert->set(i, (double)_pR->get(i), false);
             }
         }
     }
 
+    pspConvert->finalize();
     pOut = _pL->newNotEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2863,7 +2865,7 @@ InternalType* compnoequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBoo
         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pL->get(0) == 1);
+            pspConvert->set(i, _pL->get(0) == 1, false);
         }
 
     }
@@ -2880,10 +2882,11 @@ InternalType* compnoequal_M_M<Bool, SparseBool, SparseBool>(Bool* _pL, SparseBoo
         pspConvert = new SparseBool(_pR->getRows(), _pR->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pL->get(i) == 1);
+            pspConvert->set(i, _pL->get(i) == 1, false);
         }
     }
 
+    pspConvert->finalize();
     pOut = _pR->newNotEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
@@ -2904,7 +2907,7 @@ InternalType* compnoequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Boo
         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pR->get(0) == 1);
+            pspConvert->set(i, _pR->get(0) == 1, false);
         }
     }
     else
@@ -2920,10 +2923,11 @@ InternalType* compnoequal_M_M<SparseBool, Bool, SparseBool>(SparseBool* _pL, Boo
         pspConvert = new SparseBool(_pL->getRows(), _pL->getCols());
         for (int i = 0; i < iSizeOut; i++)
         {
-            pspConvert->set(i, _pR->get(i) == 1);
+            pspConvert->set(i, _pR->get(i) == 1, false);
         }
     }
 
+    pspConvert->finalize();
     pOut = _pL->newNotEqualTo(*pspConvert);
     delete pspConvert;
     return pOut;
index 20d3d94..8627029 100644 (file)
@@ -466,7 +466,7 @@ int RDivideSparseByDouble(types::Sparse* _pSp, types::Double* _pDouble, Internal
 
     if (_pDouble->isIdentity())
     {
-        *_pSpOut    = new Sparse(*_pSp);
+        *_pSpOut = new Sparse(*_pSp);
         return 0;
     }
 
@@ -558,11 +558,13 @@ int RDivideSparseByDouble(types::Sparse* _pSp, types::Double* _pDouble, Internal
                 return iResultat;
             }
             std::complex<double> cplx(ppDblGet->get(0), ppDblGet->getImg(0));
-            pSpTemp->set(iPositVal[i], cplx, true);
+            pSpTemp->set(iPositVal[i], cplx, false);
             delete ppDblGet;
         }
     }
 
+    pSpTemp->finalize();
+
     delete[] iPositVal;
 
     for (int i = 0; i < iSize; ++i)
index b669dbf..2b6aa67 100644 (file)
@@ -664,8 +664,8 @@ void fillDotDivFunction()
     scilab_fill_dotdiv(Identity, PolynomComplex, M_M, Double, Polynom, Polynom);
     scilab_fill_dotdiv(Identity, ScalarPolynom, M_M, Double, Polynom, Polynom);
     scilab_fill_dotdiv(Identity, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
-    //scilab_fill_dotdiv(Identity, Sparse, M_M, Double, Sparse, Sparse);
-    //scilab_fill_dotdiv(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
+    scilab_fill_dotdiv(Identity, Sparse, M_M, Double, Sparse, Sparse);
+    scilab_fill_dotdiv(Identity, SparseComplex, M_M, Double, Sparse, Sparse);
 
     scilab_fill_dotdiv(IdentityComplex, Double, IC_M, Double, Double, Double);
     scilab_fill_dotdiv(IdentityComplex, DoubleComplex, IC_MC, Double, Double, Double);
@@ -679,8 +679,8 @@ void fillDotDivFunction()
     scilab_fill_dotdiv(IdentityComplex, PolynomComplex, M_M, Double, Polynom, Polynom);
     scilab_fill_dotdiv(IdentityComplex, ScalarPolynom, M_M, Double, Polynom, Polynom);
     scilab_fill_dotdiv(IdentityComplex, ScalarPolynomComplex, M_M, Double, Polynom, Polynom);
-    //scilab_fill_dotdiv(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
-    //scilab_fill_dotdiv(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
+    scilab_fill_dotdiv(IdentityComplex, Sparse, M_M, Double, Sparse, Sparse);
+    scilab_fill_dotdiv(IdentityComplex, SparseComplex, M_M, Double, Sparse, Sparse);
 
     //Polynom
 
@@ -761,8 +761,8 @@ void fillDotDivFunction()
     scilab_fill_dotdiv(Sparse, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
 
     scilab_fill_dotdiv(Sparse, Empty, M_E, Sparse, Double, Double);
-    //scilab_fill_dotdiv(Sparse, Identity, M_M, Sparse, Double, Sparse);
-    //scilab_fill_dotdiv(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(Sparse, Identity, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(Sparse, IdentityComplex, M_M, Sparse, Double, Sparse);
 
     scilab_fill_dotdiv(SparseComplex, Sparse, M_M, Sparse, Sparse, Sparse);
     scilab_fill_dotdiv(SparseComplex, SparseComplex, M_M, Sparse, Sparse, Sparse);
@@ -772,8 +772,8 @@ void fillDotDivFunction()
     scilab_fill_dotdiv(SparseComplex, ScalarDoubleComplex, M_M, Sparse, Double, Sparse);
 
     scilab_fill_dotdiv(SparseComplex, Empty, M_E, Sparse, Double, Double);
-    //scilab_fill_dotdiv(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
-    //scilab_fill_dotdiv(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(SparseComplex, Identity, M_M, Sparse, Double, Sparse);
+    scilab_fill_dotdiv(SparseComplex, IdentityComplex, M_M, Sparse, Double, Sparse);
 
 #undef scilab_fill_dotdiv
 
@@ -1310,11 +1310,12 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
             {
                 if (_pR->get(i) != 0)
                 {
-                    pTemp->set(i, _pL->get(0));
+                    pTemp->set(i, _pL->get(0), false);
                 }
             }
         }
 
+        pTemp->finalize();
         Sparse* pOut = pTemp->dotDivide(*_pR);
         delete pTemp;
         return pOut;
@@ -1340,6 +1341,32 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
         return pIT;
     }
 
+    if (_pL->isIdentity())
+    {
+        Sparse* pSPTemp = new Sparse(_pR->getRows(), _pR->getCols(), _pL->isComplex());
+        int size = std::min(_pR->getRows(), _pR->getCols());
+        double dblLeftR = _pL->get(0);
+        if (_pL->isComplex())
+        {
+            std::complex<double> complexLeft(dblLeftR, _pL->getImg(0));
+            for (int i = 0; i < size; i++)
+            {
+                pSPTemp->set(i, i, complexLeft, false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < size; i++)
+            {
+                pSPTemp->set(i, i, dblLeftR, false);
+            }
+        }
+        pSPTemp->finalize();
+        InternalType* pIT = GenericDotRDivide(pSPTemp, _pR);
+        delete pSPTemp;
+        return pIT;
+    }
+
 
     //check dimensions
     if (_pL->getDims() != 2 || _pL->getRows() != _pR->getRows() || _pL->getCols() != _pR->getCols())
@@ -1370,7 +1397,7 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 int iCol = static_cast<int>(pCols[i]) - 1;
                 int index = iCol * iRows + iRow;
 
-                pOut->set(iRow, iCol,  pdblR[index] / pValR[i]);
+                pOut->set(iRow, iCol,  pdblR[index] / pValR[i], false);
             }
         }
         else
@@ -1386,7 +1413,7 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
                 c.real((pdblR[index] * pValR[i]) / dDenum);
                 c.imag(-(pdblR[index] * pValI[i]) / dDenum);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
     }
@@ -1404,7 +1431,7 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 std::complex<double> c;
                 c.real(pdblR[index] / pValR[i]);
                 c.imag(pdblI[index] / pValR[i]);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
         else
@@ -1420,7 +1447,7 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 dDenum = ( pValR[index] * pValR[index] + pValI[index] * pValI[index]);
                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
                 c.imag((pdblI[index] * pValR[i] - pdblR[index] * pValI[i]) / dDenum);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
     }
@@ -1429,6 +1456,7 @@ InternalType* dotdiv_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
     delete[] pValR;
     delete[] pValI;
 
+    pOut->finalize();
     return pOut;
 }
 
@@ -1449,7 +1477,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
             {
                 if (_pL->get(i) != 0)
                 {
-                    pTemp->set(i, stComplex);
+                    pTemp->set(i, stComplex, false);
                 }
             }
         }
@@ -1461,11 +1489,12 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
             {
                 if (_pL->get(i) != 0)
                 {
-                    pTemp->set(i, _pR->get(0));
+                    pTemp->set(i, _pR->get(0), false);
                 }
             }
         }
 
+        pTemp->finalize();
         Sparse* pOut = _pL->dotDivide(*pTemp);
         delete pTemp;
         return pOut;
@@ -1491,6 +1520,31 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
         return pIT;
     }
 
+    if (_pR->isIdentity())
+    {
+        Sparse* pSPTemp = new Sparse(_pL->getRows(), _pL->getCols(), _pR->isComplex());
+        int size = std::min(_pL->getRows(), _pL->getCols());
+        double dblRightR = _pR->get(0);
+        if (_pR->isComplex())
+        {
+            std::complex<double> complexRight(dblRightR, _pR->getImg(0));
+            for (int i = 0; i < size; i++)
+            {
+                pSPTemp->set(i, i, complexRight, false);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < size; i++)
+            {
+                pSPTemp->set(i, i, dblRightR, false);
+            }
+        }
+        pSPTemp->finalize();
+        InternalType* pIT = GenericDotRDivide(_pL, pSPTemp);
+        delete pSPTemp;
+        return pIT;
+    }
 
     //check dimensions
     if (_pR->getDims() != 2 || _pR->getRows() != _pL->getRows() || _pR->getCols() != _pL->getCols())
@@ -1521,7 +1575,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
                 int iCol = static_cast<int>(pCols[i]) - 1;
                 int index = iCol * iRows + iRow;
 
-                pOut->set(iRow, iCol, pValR[i] / pdblR[index]  );
+                pOut->set(iRow, iCol, pValR[i] / pdblR[index], false);
             }
         }
         else
@@ -1535,7 +1589,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
                 std::complex<double> c;
                 c.real(pValR[i] / pdblR[index]);
                 c.imag(pValR[i] / pdblR[index]);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol, c, false);
             }
         }
     }
@@ -1555,7 +1609,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
                 c.real((pValR[i]*pdblR[index]) / dDenum );
                 c.imag(-(pdblI[index]*pValR[i]) / dDenum );
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
         else
@@ -1570,7 +1624,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
                 dDenum = ( pdblR[index] * pdblR[index] + pdblI[index] * pdblI[index]);
                 c.real((pdblR[index] * pValR[i] + pdblI[index] * pValI[i]) / dDenum);
                 c.imag((pdblR[index] * pValI[i] - pdblI[index] * pValR[i]) / dDenum);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
     }
@@ -1579,6 +1633,7 @@ InternalType* dotdiv_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
     delete[] pValR;
     delete[] pValI;
 
+    pOut->finalize();
     return pOut;
 }
 
index 867b859..4bfc18a 100644 (file)
@@ -1290,7 +1290,7 @@ InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 int iCol = static_cast<int>(pCols[i]) - 1;
                 int index = iCol * iRows + iRow;
 
-                pOut->set(iRow, iCol,  pdblR[index] * pValR[i]);
+                pOut->set(iRow, iCol,  pdblR[index] * pValR[i], false);
             }
         }
         else
@@ -1304,7 +1304,7 @@ InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 std::complex<double> c;
                 c.real(pdblR[index] * pValR[i]);
                 c.imag(pdblR[index] * pValI[i]);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
     }
@@ -1322,7 +1322,7 @@ InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 std::complex<double> c;
                 c.real(pdblR[index] * pValR[i]);
                 c.imag(pdblI[index] * pValR[i]);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
         else
@@ -1336,7 +1336,7 @@ InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
                 std::complex<double> c;
                 c.real(pdblR[index] * pValR[i] - pdblI[index] * pValI[i]);
                 c.imag(pdblR[index] * pValI[i] + pdblI[index] * pValR[i]);
-                pOut->set(iRow, iCol,  c);
+                pOut->set(iRow, iCol,  c, false);
             }
         }
     }
@@ -1345,6 +1345,7 @@ InternalType* dotmul_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
     delete[] pValR;
     delete[] pValI;
 
+    pOut->finalize();
     return pOut;
 }
 
index 48dfa30..2349529 100644 (file)
@@ -104,14 +104,14 @@ int LDivideDoubleByDouble(Double *_pDouble1, Double *_pDouble2, Double **_pDoubl
 
     if (_pDouble1->isScalar())
     {
-        //Y \ x => x / Y
+        //x \ Y => Y / x
         return RDivideDoubleByDouble(_pDouble2, _pDouble1, _pDoubleOut);
     }
 
     if (_pDouble2->isScalar())
     {
-        // managed in %s_l_s, call overload
-        return 0;
+        //X \ y => y / X
+        return RDivideDoubleByDouble(_pDouble2, _pDouble1, _pDoubleOut);
     }
 
     if (_pDouble1->getDims() > 2 || _pDouble2->getDims() > 2 || _pDouble1->getRows() != _pDouble2->getRows())
index 4e4a516..8aafa39 100644 (file)
@@ -717,9 +717,11 @@ InternalType* or_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, Sparse
             {
                 for (int j = 0 ; j < iCols ; j++)
                 {
-                    pOut->set(i, j, true);
+                    pOut->set(i, j, true, false);
                 }
             }
+
+            pOut->finalize();
         }
         else
         {
@@ -740,9 +742,11 @@ InternalType* or_M_M<SparseBool, SparseBool, SparseBool>(SparseBool* _pL, Sparse
             {
                 for (int j = 0 ; j < iCols ; j++)
                 {
-                    pOut->set(i, j, true);
+                    pOut->set(i, j, true, false);
                 }
             }
+
+            pOut->finalize();
         }
         else
         {
index 3c63912..c30f872 100644 (file)
@@ -502,7 +502,7 @@ int DotPowerSpaseByDouble(Sparse* _pSp, Double* _pDouble, InternalType** _pOut)
         {
             DotPowerDoubleByDouble(pDblSp[i], pDbl[i], &ppDblGet);
             std::complex<double> cplx(ppDblGet->get(0), ppDblGet->getImg(0));
-            pSpTemp->set(iPositVal[i], cplx, true);
+            pSpTemp->set(iPositVal[i], cplx, false);
         }
     }
 
@@ -510,6 +510,7 @@ int DotPowerSpaseByDouble(Sparse* _pSp, Double* _pDouble, InternalType** _pOut)
     delete Row;
     delete iPositVal;
 
+    pSpTemp->finalize();
     *_pOut = pSpTemp;
     return 0;
 
index 75dc487..b2dc06f 100644 (file)
@@ -182,7 +182,7 @@ void fillSubtractFunction()
     scilab_fill_sub(Empty, ScalarDoubleComplex, E_MC, Double, Double, Double);
     scilab_fill_sub(Empty, ScalarPolynomComplex, E_MC, Double, Polynom, Polynom);
     //Empty - Empty
-    scilab_fill_sub(Empty, Empty, E_M, Double, Double, Double);
+    scilab_fill_sub(Empty, Empty, E_E, Double, Double, Double);
     //Empty - eye
     scilab_fill_sub(Empty, Identity, E_I, Double, Double, Double);
     scilab_fill_sub(Empty, IdentityComplex, E_IC, Double, Double, Double);
@@ -896,7 +896,7 @@ InternalType* sub_M_SC(T *_pL, U *_pR)
 template<class T, class U, class O>
 InternalType* sub_M_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -978,7 +978,7 @@ InternalType* sub_MC_SC(T *_pL, U *_pR)
 template<class T, class U, class O>
 InternalType* sub_MC_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1020,7 +1020,7 @@ InternalType* sub_S_SC(T *_pL, U *_pR)
 template<class T, class U, class O>
 InternalType* sub_S_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1062,7 +1062,7 @@ InternalType* sub_SC_SC(T *_pL, U *_pR)
 template<class T, class U, class O>
 InternalType* sub_SC_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1072,7 +1072,7 @@ InternalType* sub_SC_E(T *_pL, U * /*_pR*/)
 template<class T, class U, class O>
 InternalType* sub_E_M(T * /*_pL*/, U *_pR)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1081,7 +1081,7 @@ InternalType* sub_E_M(T * /*_pL*/, U *_pR)
 template<class T, class U, class O>
 InternalType* sub_E_MC(T * /*_pL*/, U *_pR)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1464,7 +1464,7 @@ template<class T, class U, class O> InternalType* sub_IC_IC(T *_pL, U *_pR)
 
 template<class T, class U, class O> types::InternalType* sub_I_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1472,7 +1472,7 @@ template<class T, class U, class O> types::InternalType* sub_I_E(T *_pL, U * /*_
 
 template<class T, class U, class O> types::InternalType* sub_IC_E(T *_pL, U * /*_pR*/)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1480,7 +1480,7 @@ template<class T, class U, class O> types::InternalType* sub_IC_E(T *_pL, U * /*
 
 template<class T, class U, class O> types::InternalType* sub_E_I(T * /*_pL*/, U *_pR)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -1488,7 +1488,7 @@ template<class T, class U, class O> types::InternalType* sub_E_I(T * /*_pL*/, U
 
 template<class T, class U, class O> types::InternalType* sub_E_IC(T * /*_pL*/, U *_pR)
 {
-    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n")); 
+    Sciwarning(_("operation -: Warning adding a matrix with the empty matrix will give an empty matrix result.\n"));
     Double* pOut = Double::Empty();
     sub();
     return pOut;
@@ -2667,13 +2667,48 @@ template<> InternalType* sub_M_M<Sparse, Double, Double>(Sparse* _pL, Double* _p
     return pOut;
 }
 
-//[] - sp
+//Identity - sp
 template<> InternalType* sub_M_M<Double, Sparse, Sparse>(Double* _pL, Sparse* _pR)
 {
-    return sub_M_M<Sparse, Double, Sparse>(_pR, _pL);
+    Sparse* pOut = NULL;
+    if (_pL->isIdentity())
+    {
+        //convert to _pL
+        Sparse* pS = new Sparse(_pR->getRows(), _pR->getCols(), _pL->isComplex());
+        int size = std::min(_pR->getRows(), _pR->getCols());
+        double dblLeftR = _pL->get(0);
+
+
+        if (_pL->isComplex())
+        {
+            std::complex<double> complexLeft(dblLeftR, _pL->getImg(0));
+            for (int i = 0 ; i < size ; i++)
+            {
+                pS->set(i, i, complexLeft);
+            }
+        }
+        else
+        {
+            for (int i = 0 ; i < size ; i++)
+            {
+                pS->set(i, i, dblLeftR);
+            }
+        }
+        pS->finalize();
+
+
+        pOut = pS->substract(*_pR);
+        delete pS;
+        return pOut;
+    }
+    else
+    {
+        // Call overload if the matrix is not identity
+        return NULL;
+    }
 }
 
-//sp - []
+//sp - Identity
 template<> InternalType* sub_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _pR)
 {
     Sparse* pOut = NULL;
@@ -2681,30 +2716,34 @@ template<> InternalType* sub_M_M<Sparse, Double, Sparse>(Sparse* _pL, Double* _p
     {
         //convert to _pL
         Sparse* pS = new Sparse(_pL->getRows(), _pL->getCols(), _pR->isComplex());
-        if (pS->isComplex())
+        int size = std::min(_pL->getRows(), _pL->getCols());
+        double dblRightR = _pR->get(0);
+
+        if (_pR->isComplex())
         {
-            int size = std::min(_pL->getRows(), _pL->getCols());
+            std::complex<double> complexRight(dblRightR, _pR->getImg(0));
             for (int i = 0 ; i < size ; i++)
             {
-                pS->set(i, i, std::complex<double>(_pR->get(0), _pR->getImg(0)));
+                pS->set(i, i, complexRight, false);
             }
         }
         else
         {
-            int size = std::min(_pL->getRows(), _pL->getCols());
             for (int i = 0 ; i < size ; i++)
             {
-                pS->set(i, i, _pR->get(0));
+                pS->set(i, i, dblRightR, false);
             }
         }
+        pS->finalize();
 
-        //AddSparseToSparse(_pL, pS, (Sparse**)pOut);
+
+        pOut = _pL->substract(*pS);
         delete pS;
         return pOut;
     }
     else
     {
-        //is []
-        return _pL;
+        // Call overload if the matrix is not identity
+        return NULL;
     }
 }
index f9103da..038cca7 100644 (file)
@@ -57,4 +57,4 @@ assert_checkequal(while_return(), 1);
 assert_checkequal(while_if_return(), 1);
 assert_checkequal(for_return(), 1);
 assert_checkequal(for_if_return(), 1);
-assert_checkerror("foo()", _("With input arguments, return / resume expect output arguments."));
+assert_checkerror("foo()", _("With input arguments, return / resume expects output arguments."));
index 5a11264..2789776 100644 (file)
@@ -64,4 +64,4 @@ assert_checkequal(while_return(), 1);
 assert_checkequal(while_if_return(), 1);
 assert_checkequal(for_return(), 1);
 assert_checkequal(for_if_return(), 1);
-assert_checkerror("foo()", _("With input arguments, return / resume expect output arguments."));
+assert_checkerror("foo()", _("With input arguments, return / resume expects output arguments."));
index e7816db..a44f5c1 100644 (file)
@@ -35,6 +35,7 @@ i32 = int32(-32);
 ui32 = uint32(32);
 I32 = int32([-32 -64 ; -96 -128]);
 UI32 = uint32([32 64 ; 96 128]);
+warning("off"); // WARNING_EMPTY_OPS
 assert_checkequal(empty - empty, []);
 assert_checkequal(empty - r, []);
 assert_checkequal(empty - c, []);