Leak memory in elementary_functions tests 99/15999/6
Antoine ELIAS [Sun, 22 Feb 2015 14:33:08 +0000 (15:33 +0100)]
Change-Id: I59703ea4bf8d1f9722c73948cb798d2f23bf4c90

57 files changed:
scilab/modules/ast/ast.vcxproj
scilab/modules/ast/includes/ast/dummyvisitor.hxx
scilab/modules/ast/includes/ast/scilabexception.hxx
scilab/modules/ast/includes/ast/serializervisitor.hxx
scilab/modules/ast/includes/exps/arraylistvar.hxx
scilab/modules/ast/includes/exps/exp.hxx
scilab/modules/ast/includes/exps/matrixexp.hxx
scilab/modules/ast/includes/exps/matrixlineexp.hxx
scilab/modules/ast/includes/symbol/libraries.hxx
scilab/modules/ast/includes/symbol/variables.hxx
scilab/modules/ast/includes/types/cell.hxx
scilab/modules/ast/includes/types/sparse.hxx
scilab/modules/ast/src/cpp/ast/debugvisitor.cpp
scilab/modules/ast/src/cpp/ast/expHistory.cpp
scilab/modules/ast/src/cpp/ast/macrovarvisitor.cpp
scilab/modules/ast/src/cpp/ast/printvisitor.cpp
scilab/modules/ast/src/cpp/ast/run_MatrixExp.hpp
scilab/modules/ast/src/cpp/ast/runvisitor.cpp
scilab/modules/ast/src/cpp/ast/treevisitor.cpp
scilab/modules/ast/src/cpp/ast/visitor_common.cpp
scilab/modules/ast/src/cpp/operations/types_multiplication.cpp
scilab/modules/ast/src/cpp/operations/types_power.cpp
scilab/modules/ast/src/cpp/operations/types_subtraction.cpp
scilab/modules/ast/src/cpp/symbol/context.cpp
scilab/modules/ast/src/cpp/system_env/configvariable.cpp
scilab/modules/ast/src/cpp/types/arrayof.cpp
scilab/modules/ast/src/cpp/types/bool.cpp
scilab/modules/ast/src/cpp/types/cell.cpp
scilab/modules/ast/src/cpp/types/double.cpp
scilab/modules/ast/src/cpp/types/inspector.cpp
scilab/modules/ast/src/cpp/types/library.cpp
scilab/modules/ast/src/cpp/types/list.cpp
scilab/modules/ast/src/cpp/types/macrofile.cpp
scilab/modules/ast/src/cpp/types/overload.cpp
scilab/modules/ast/src/cpp/types/polynom.cpp
scilab/modules/ast/src/cpp/types/singlestruct.cpp
scilab/modules/ast/src/cpp/types/sparse.cpp
scilab/modules/ast/src/cpp/types/string.cpp
scilab/modules/ast/src/cpp/types/struct.cpp
scilab/modules/ast/src/cpp/types/tlist.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_eye.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_matrix.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_max.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_prod.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sum.cpp
scilab/modules/elementary_functions/src/cpp/gsort.cpp
scilab/modules/elementary_functions/src/cpp/prod.cpp
scilab/modules/elementary_functions/src/cpp/sum.cpp
scilab/modules/elementary_functions/tests/unit_tests/gsort.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/gsort.tst
scilab/modules/elementary_functions/tests/unit_tests/max.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/max.tst
scilab/modules/linear_algebra/sci_gateway/cpp/sci_bdiag.cpp
scilab/modules/linear_algebra/sci_gateway/cpp/sci_schur.cpp
scilab/modules/linear_algebra/sci_gateway/cpp/sci_spec.cpp
scilab/modules/sparse/sci_gateway/cpp/sci_spget.cpp
scilab/modules/windows_tools/.gitignore

index 14e221e..ccb4e61 100644 (file)
     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
     <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</LinkIncremental>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <IncludePath>C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Visual Leak Detector\lib\Win64;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <IncludePath>C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <IncludePath>C:\Program Files %28x86%29\Visual Leak Detector\include</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Visual Leak Detector\lib\Win32;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <IncludePath>C:\Program Files %28x86%29\Visual Leak Detector\include;$(IncludePath)</IncludePath>
+    <LibraryPath>C:\Program Files %28x86%29\Visual Leak Detector\lib\Win64;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
index 4b77834..2d94ffb 100644 (file)
@@ -205,9 +205,9 @@ protected:
         e.getSelect()->accept(*this);
 
         exps_t* cases = e.getCases();
-        for (exps_t::iterator it = cases->begin(), itEnd = cases->end(); it !=  itEnd ; ++it)
+        for (auto exp : *cases)
         {
-            (*it)->accept(*this);
+            exp->accept(*this);
         }
         delete cases;
 
index 289ac99..7aa36d4 100644 (file)
@@ -37,20 +37,20 @@ class ScilabException : public std::exception
 public :
     ScilabException()
     {
-        createScilabException();
+        createScilabException(L"", 0, Location());
     }
 
     ScilabException(std::wstring _wstErrorMesssage)
     {
         setLastError(999, _wstErrorMesssage.c_str(), 0, NULL);
-        createScilabException(_wstErrorMesssage);
+        createScilabException(_wstErrorMesssage, 0, Location());
     }
 
     ScilabException(std::string _stErrorMesssage)
     {
         wchar_t* pwst = to_wide_string(_stErrorMesssage.c_str());
         setLastError(999, pwst, 0, NULL);
-        createScilabException(pwst);
+        createScilabException(pwst, 0, Location());
         FREE(pwst);
     }
     ScilabException(const Location& _ErrorLocation)
@@ -102,7 +102,7 @@ protected :
     Location m_ErrorLocation;
 
 protected :
-    void createScilabException(std::wstring _wstErrorMessage = L"", int _iErrorNumber = 0, const Location& _ErrorLocation = *new Location())
+    void createScilabException(std::wstring _wstErrorMessage, int _iErrorNumber, const Location& _ErrorLocation)
     {
         m_wstErrorMessage = _wstErrorMessage;
         m_iErrorNumber = _iErrorNumber;
@@ -132,22 +132,20 @@ public :
     ScilabMessage() : ScilabException() {}
     ScilabMessage(std::wstring _wstErrorMesssage)
     {
-        createScilabException(_wstErrorMesssage);
+        createScilabException(_wstErrorMesssage, 0, Location());
     }
 
     ScilabMessage(std::string _stErrorMesssage)
     {
 
         wchar_t* pwst = to_wide_string(_stErrorMesssage.c_str());
-        //setLastError(999, pwst, 0, NULL);
-        createScilabException(pwst);
+        createScilabException(pwst, 0, Location());
         FREE(pwst);
     }
 
     ScilabMessage(const Location& _ErrorLocation) : ScilabException(_ErrorLocation) {}
     ScilabMessage(std::wstring _wstErrorMesssage, int _iErrorNumber, const Location& _ErrorLocation)
     {
-        //setLastError(_iErrorNumber, _wstErrorMesssage.c_str(), 0, NULL);
         createScilabException(_wstErrorMesssage, _iErrorNumber, _ErrorLocation);
     }
 };
index cc8aa79..09a85f6 100644 (file)
@@ -189,9 +189,12 @@ private :
     void add_exps(const exps_t& exps)
     {
         add_uint32((unsigned int)exps.size());
-        for (exps_t::const_iterator it = exps.begin(), itEnd = exps.end(); it != itEnd ; ++it)
+        if (exps.size() != 0)
         {
-            (*it)->getOriginal()->accept(*this);
+            for (auto exp : exps)
+            {
+                exp->getOriginal()->accept(*this);
+            }
         }
     }
 
@@ -471,9 +474,9 @@ private :
         exps_t* cases = e.getCases();
         add_uint32((unsigned int)cases->size());
 
-        for (exps_t::iterator it = cases->begin(), itEnd = cases->end(); it !=  itEnd ; ++it)
+        for (auto exp : *cases)
         {
-            const CaseExp *ce = (*it)->getAs<CaseExp>();
+            const CaseExp *ce = exp->getAs<CaseExp>();
             add_location(ce->getLocation());
             add_location(ce->getBody()->getLocation());
             add_exp(ce->getTest());
index d0e3871..aff6458 100644 (file)
@@ -39,10 +39,10 @@ public:
                   exps_t& vars)
         : Var (location)
     {
-        for (exps_t::iterator it = vars.begin(), itEnd = vars.end(); it != itEnd ; ++it)
+        for (auto var : vars)
         {
-            (*it)->setParent(this);
-            _exps.push_back(*it);
+            var->setParent(this);
+            _exps.push_back(var);
         }
 
         delete &vars;
index a1d1ac4..5114353 100644 (file)
@@ -464,7 +464,9 @@ public:
     {
         if (_old && _new)
         {
-            for (exps_t::iterator it = _exps.begin(), itEnd = _exps.end(); it != itEnd ; ++it)
+            exps_t::iterator it = _exps.begin();
+            exps_t::iterator itEnd = _exps.end();
+            for (; it != itEnd; ++it)
             {
                 if (*it == _old)
                 {
index ccfc2eb..679452c 100644 (file)
@@ -54,13 +54,15 @@ public:
 
     virtual MatrixExp* clone()
     {
-        exps_t* lines = new exps_t;
-        for (exps_t::const_iterator it = getLines().begin(), itEnd = getLines().end(); it != itEnd; ++it)
+        exps_t* newlines = new exps_t;
+        exps_t& lines = getLines();
+
+        for (auto line : lines)
         {
-            lines->push_back((*it)->clone());
+            newlines->push_back(line->clone());
         }
 
-        MatrixExp* cloned = new MatrixExp(getLocation(), *lines);
+        MatrixExp* cloned = new MatrixExp(getLocation(), *newlines);
         cloned->setVerbose(isVerbose());
         return cloned;
     }
index 2c6e7ff..9b86d05 100644 (file)
@@ -39,10 +39,10 @@ public:
                    exps_t& columns)
         : MathExp (location)
     {
-        for (exps_t::const_iterator it = columns.begin(), itEnd = columns.end(); it != itEnd ; ++it)
+        for (auto exp : columns)
         {
-            (*it)->setParent(this);
-            _exps.push_back(*it);
+            exp->setParent(this);
+            _exps.push_back(exp);
         }
 
         delete &columns;
index 6072995..94bcea9 100644 (file)
@@ -218,19 +218,19 @@ struct Libraries
 
     void clearAll()
     {
-        for (MapLibs::iterator it = libs.begin(); it != libs.end() ; ++it)
+        for (auto lib : libs)
         {
-            while (!it->second->empty())
+            while (!lib.second->empty())
             {
-                ScopedLibrary * pSL = it->second->top();
+                ScopedLibrary * pSL = lib.second->top();
                 types::InternalType * pIT = pSL->m_pLib;
                 pIT->DecreaseRef();
                 pIT->killMe();
-                it->second->pop();
+                lib.second->pop();
                 delete pSL;
             }
 
-            delete it->second;
+            delete lib.second;
         }
     }
 
index dba06bb..7119d74 100644 (file)
@@ -397,20 +397,19 @@ struct Variables
     {
         std::list<Symbol>* symb = new std::list<Symbol>();
 
-        MapVars::iterator it = vars.begin();
-        for (; it != vars.end() ; ++it)
+        for (auto var : vars)
         {
-            if (it->second->empty())
+            if (var.second->empty())
             {
                 continue;
             }
 
-            if ((it->second->top()->m_iLevel == _iLevel || _iLevel == 1) && it->second->top()->m_pIT->isCallable())
+            if ((var.second->top()->m_iLevel == _iLevel || _iLevel == 1) && var.second->top()->m_pIT->isCallable())
             {
-                types::Callable* pCall = it->second->top()->m_pIT->getAs<types::Callable>();
+                types::Callable* pCall = var.second->top()->m_pIT->getAs<types::Callable>();
                 if (_stModuleName == L"" || _stModuleName == pCall->getModule())
                 {
-                    symb->push_back(it->first);
+                    symb->push_back(var.first);
                 }
             }
         }
@@ -486,9 +485,9 @@ struct Variables
 
     void clearAll()
     {
-        for (MapVars::iterator it = vars.begin(); it != vars.end() ; ++it)
+        for (auto var : vars)
         {
-            delete it->second;
+            delete var.second;
         }
     }
 
index 90d9885..3ada6f7 100644 (file)
@@ -115,7 +115,7 @@ private :
     virtual void            deleteAll();
     virtual void            deleteImg();
     virtual InternalType**  allocData(int _iSize);
-
+    virtual void            deleteData(InternalType* _pData);
 };
 }
 
index 5922bb4..8255d93 100644 (file)
@@ -537,7 +537,7 @@ private :
  */
 struct EXTERN_AST SparseBool : GenericType
 {
-
+    virtual ~SparseBool();
     /* @param src: Bool matrix to copy into a new sparse matrix
     **/
     SparseBool(Bool SPARSE_CONST& src);
index 05e6005..7db80f9 100644 (file)
@@ -307,9 +307,9 @@ void DebugVisitor::visit (const SelectExp &e)
     e.getSelect()->accept(*this);
 
     exps_t* cases = e.getCases();
-    for (exps_t::iterator it = cases->begin(), itEnd = cases->end(); it !=  itEnd ; ++it)
+    for (auto exp : *cases)
     {
-        (*it)->accept(*this);
+        exp->accept(*this);
     }
     delete cases;
 
index 9ce0e82..5eb1930 100644 (file)
@@ -63,10 +63,9 @@ ExpHistory::~ExpHistory()
 
     if (m_pArgs && m_pArgsOwner)
     {
-        types::typed_list::iterator iter = m_pArgs->begin();
-        for (; iter != m_pArgs->end(); ++iter)
+        for (auto arg : *m_pArgs)
         {
-            (*iter)->killMe();
+            arg->killMe();
         }
 
         delete m_pArgs;
index 6b92003..63d3ca0 100644 (file)
@@ -116,10 +116,9 @@ void MacrovarVisitor::add()
 
 bool MacrovarVisitor::isAlreadyIn(std::list<std::wstring>& lst)
 {
-    std::list<std::wstring>::iterator it;
-    for (it = lst.begin(); it != lst.end() ; it++)
+    for (auto l : lst)
     {
-        if (*it == m_current)
+        if (l == m_current)
         {
             return true;
         }
index b3ce117..a8881d4 100644 (file)
@@ -490,9 +490,9 @@ void PrintVisitor::visit (const SelectExp &e)
     *ostr << SCI_CLOSE_TEST << std::endl;
     ++indent;
     exps_t* cases = e.getCases();
-    for (exps_t::iterator it = cases->begin(), itEnd = cases->end(); it !=  itEnd ; ++it)
+    for (auto exp : *cases)
     {
-        (*it)->getOriginal()->accept(*this);
+        exp->getOriginal()->accept(*this);
     }
     delete cases;
 
index af4c895..39613ef 100644 (file)
@@ -185,11 +185,13 @@ void RunVisitorT<T>::visitprivate(const MatrixExp &e)
 
                 InternalType *pNewSize = AddElementToVariable(NULL, poRow, pGTResult->getRows(), pGTResult->getCols() + pGT->getCols());
                 InternalType* p = AddElementToVariable(pNewSize, pGT, 0, pGTResult->getCols());
-
+                if (p != pNewSize)
+                {
+                    pNewSize->killMe();
+                }
                 // call overload
                 if (p == NULL)
                 {
-                    pNewSize->killMe();
                     poRow = callOverloadMatrixExp(L"c", pGTResult, pGT);
                     continue;
                 }
index 354674b..955ad79 100644 (file)
@@ -364,7 +364,8 @@ void RunVisitorT<T>::visitprivate(const WhileExp  &e)
 
     //condition
     e.getTest().accept(*this);
-    while (getResult()->isTrue())
+    InternalType* pIT = getResult();
+    while (pIT->isTrue())
     {
         e.getBody().accept(*this);
         if (e.getBody().isBreak())
@@ -394,9 +395,13 @@ void RunVisitorT<T>::visitprivate(const WhileExp  &e)
             getResult()->killMe();
         }
 
+        std::wcout << L"ref : " << pIT->getRef();
+        pIT->killMe();
         e.getTest().accept(*this);
+        pIT = getResult();
     }
 
+    //pIT->killMe();
     //clear result of condition or result of body
     clearResult();
 }
@@ -623,17 +628,15 @@ void RunVisitorT<T>::visitprivate(const SelectExp &e)
     e.getSelect()->accept(*this);
     bool bCase = false;
 
-
     InternalType* pIT = getResult();
     setResult(NULL);
     if (pIT)
     {
         //find good case
-        exps_t::iterator it;
         exps_t* cases = e.getCases();
-        for (it = cases->begin(); it != cases->end() ; it++)
+        for (auto exp : *cases)
         {
-            CaseExp* pCase = (*it)->getAs<CaseExp>();
+            CaseExp* pCase = exp->getAs<CaseExp>();
             pCase->getTest()->accept(*this);
             InternalType *pITCase = getResult();
             setResult(NULL);
@@ -663,8 +666,17 @@ void RunVisitorT<T>::visitprivate(const SelectExp &e)
                         pCase->getBody()->setReturnable();
                     }
 
-                    //the good one
-                    pCase->getBody()->accept(*this);
+                    try
+                    {
+                        //the good one
+                        pCase->getBody()->accept(*this);
+                    }
+                    catch (ScilabMessage& sm)
+                    {
+                        pIT->killMe();
+                        delete cases;
+                        throw sm;
+                    }
 
                     if (e.isBreakable() && pCase->getBody()->isBreak())
                     {
@@ -684,9 +696,12 @@ void RunVisitorT<T>::visitprivate(const SelectExp &e)
                         pCase->getBody()->resetReturn();
                     }
 
+                    pITCase->killMe();
                     bCase = true;
                     break;
                 }
+
+                pITCase->killMe();
             }
         }
 
@@ -804,7 +819,7 @@ void RunVisitorT<T>::visitprivate(const SeqExp  &e)
 
                         bImplicitCall = true;
                     }
-                    catch (ScilabMessage sm)
+                    catch (ScilabMessage& sm)
                     {
                         wostringstream os;
                         PrintVisitor printMe(os);
@@ -942,7 +957,7 @@ void RunVisitorT<T>::visitprivate(const SeqExp  &e)
                         throw ScilabMessage(os.str(), 999, (*itExp)->getLocation());
                     }
                 }
-                catch (ScilabError se2)
+                catch (ScilabError& se2)
                 {
                     //just to catch exception, do nothing
                 }
index 060ce14..232f4cf 100644 (file)
@@ -720,14 +720,16 @@ void TreeVisitor::visit(const SelectExp &e)
 
 
     //cases
-    types::List* cases = new types::List();
-    for (auto c : *e.getCases())
+    types::List* lcases = new types::List();
+    ast::exps_t* cases = e.getCases();
+    for (auto c : *cases)
     {
         c->accept(*this);
-        cases->append(getList());
+        lcases->append(getList());
     }
+    delete cases;
 
-    select->append(cases);
+    select->append(lcases);
 
     //default
     if (e.hasDefault())
index adf96f7..92a99ef 100644 (file)
@@ -32,54 +32,54 @@ size_t ast::Ast::globalNodeNumber = 0;
 /*
  * Generate destination variable from _poSource type and size parameters
  */
-types::InternalType* allocDest(types::InternalType* _poSource, int _iRows, int _iCols)
+InternalType* allocDest(InternalType* _poSource, int _iRows, int _iCols)
 {
-    types::InternalType* poResult = NULL;
+    InternalType* poResult = NULL;
     switch (_poSource->getType())
     {
-        case types::GenericType::ScilabDouble :
-            poResult = new types::Double(_iRows, _iCols, false);
+        case GenericType::ScilabDouble :
+            poResult = new Double(_iRows, _iCols, false);
             break;
-        case types::GenericType::ScilabBool :
-            poResult = new types::Bool(_iRows, _iCols);
+        case GenericType::ScilabBool :
+            poResult = new Bool(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabInt8 :
-            poResult = new types::Int8(_iRows, _iCols);
+        case GenericType::ScilabInt8 :
+            poResult = new Int8(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabUInt8 :
-            poResult = new types::UInt8(_iRows, _iCols);
+        case GenericType::ScilabUInt8 :
+            poResult = new UInt8(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabInt16 :
-            poResult = new types::Int16(_iRows, _iCols);
+        case GenericType::ScilabInt16 :
+            poResult = new Int16(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabUInt16 :
-            poResult = new types::UInt16(_iRows, _iCols);
+        case GenericType::ScilabUInt16 :
+            poResult = new UInt16(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabInt32 :
-            poResult = new types::Int32(_iRows, _iCols);
+        case GenericType::ScilabInt32 :
+            poResult = new Int32(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabUInt32 :
-            poResult = new types::UInt32(_iRows, _iCols);
+        case GenericType::ScilabUInt32 :
+            poResult = new UInt32(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabInt64 :
-            poResult = new types::Int64(_iRows, _iCols);
+        case GenericType::ScilabInt64 :
+            poResult = new Int64(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabUInt64 :
-            poResult = new types::UInt64(_iRows, _iCols);
+        case GenericType::ScilabUInt64 :
+            poResult = new UInt64(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabString :
-            poResult = new types::String(_iRows, _iCols);
+        case GenericType::ScilabString :
+            poResult = new String(_iRows, _iCols);
             break;
-        case types::GenericType::ScilabPolynom :
+        case GenericType::ScilabPolynom :
         {
             int* piRank = new int[_iRows * _iCols];
             memset(piRank, 0x00, _iRows * _iCols * sizeof(int));
-            poResult = new types::Polynom(_poSource->getAs<types::Polynom>()->getVariableName(), _iRows, _iCols, piRank);
+            poResult = new Polynom(_poSource->getAs<Polynom>()->getVariableName(), _iRows, _iCols, piRank);
             delete[] piRank;
             break;
         }
-        case types::InternalType::ScilabImplicitList :
-            poResult = new types::ImplicitList();
+        case InternalType::ScilabImplicitList :
+            poResult = new ImplicitList();
             break;
         default :
             // FIXME : What should we do here ??
@@ -88,11 +88,11 @@ types::InternalType* allocDest(types::InternalType* _poSource, int _iRows, int _
     return poResult;
 }
 
-types::InternalType* AddElementToVariableFromCol(types::InternalType* _poDest, types::InternalType* _poSource, int _iRows, int _iCols, int *_piCols)
+InternalType* AddElementToVariableFromCol(InternalType* _poDest, InternalType* _poSource, int _iRows, int _iCols, int *_piCols)
 {
-    types::InternalType *poResult               = NULL;
-    types::InternalType::ScilabType TypeSource  = _poSource->getType();
-    types::InternalType::ScilabType TypeDest    = types::InternalType::ScilabInternal;
+    InternalType *poResult = NULL;
+    InternalType::ScilabType TypeSource = _poSource->getType();
+    InternalType::ScilabType TypeDest = InternalType::ScilabInternal;
 
     if (_poDest == NULL)
     {
@@ -114,14 +114,14 @@ types::InternalType* AddElementToVariableFromCol(types::InternalType* _poDest, t
     {
         switch (TypeDest)
         {
-            case types::GenericType::ScilabDouble :
-                if (poResult->getAs<types::Double>()->isComplex() == false && _poSource->getAs<types::Double>()->isComplex() == true)
+            case GenericType::ScilabDouble :
+                if (poResult->getAs<Double>()->isComplex() == false && _poSource->getAs<Double>()->isComplex() == true)
                 {
-                    poResult->getAs<types::Double>()->setComplex(true);
+                    poResult->getAs<Double>()->setComplex(true);
                 }
 
-                poResult->getAs<types::Double>()->fillFromCol(*_piCols, _poSource->getAs<types::Double>());
-                *_piCols += _poSource->getAs<types::Double>()->getCols();
+                poResult->getAs<Double>()->fillFromCol(*_piCols, _poSource->getAs<Double>());
+                *_piCols += _poSource->getAs<Double>()->getCols();
 
                 break;
             default:
@@ -132,11 +132,11 @@ types::InternalType* AddElementToVariableFromCol(types::InternalType* _poDest, t
     return NULL;
 }
 
-types::InternalType* AddElementToVariableFromRow(types::InternalType* _poDest, types::InternalType* _poSource, int _iRows, int _iCols, int *_piRows)
+InternalType* AddElementToVariableFromRow(InternalType* _poDest, InternalType* _poSource, int _iRows, int _iCols, int *_piRows)
 {
-    types::InternalType *poResult               = NULL;
-    types::InternalType::ScilabType TypeSource  = _poSource->getType();
-    types::InternalType::ScilabType TypeDest    = types::InternalType::ScilabInternal;
+    InternalType *poResult = NULL;
+    InternalType::ScilabType TypeSource = _poSource->getType();
+    InternalType::ScilabType TypeDest = InternalType::ScilabInternal;
 
     if (_poDest == NULL)
     {
@@ -159,14 +159,14 @@ types::InternalType* AddElementToVariableFromRow(types::InternalType* _poDest, t
     {
         switch (TypeDest)
         {
-            case types::GenericType::ScilabDouble :
-                if (poResult->getAs<types::Double>()->isComplex() == false && _poSource->getAs<types::Double>()->isComplex() == true)
+            case GenericType::ScilabDouble :
+                if (poResult->getAs<Double>()->isComplex() == false && _poSource->getAs<Double>()->isComplex() == true)
                 {
-                    poResult->getAs<types::Double>()->setComplex(true);
+                    poResult->getAs<Double>()->setComplex(true);
                 }
 
-                poResult->getAs<types::Double>()->fillFromRow(*_piRows, _poSource->getAs<types::Double>());
-                *_piRows += _poSource->getAs<types::Double>()->getRows();
+                poResult->getAs<Double>()->fillFromRow(*_piRows, _poSource->getAs<Double>());
+                *_piRows += _poSource->getAs<Double>()->getRows();
 
                 break;
             default:
@@ -182,11 +182,12 @@ types::InternalType* AddElementToVariableFromRow(types::InternalType* _poDest, t
 _iRows : Position if _poDest allready initialized else size of the matrix
 _iCols : Position if _poDest allready initialized else size of the matrix
 */
-types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::InternalType* _poSource, int _iRows, int _iCols)
+InternalType* AddElementToVariable(InternalType* _poDest, InternalType* _poSource, int _iRows, int _iCols)
 {
-    types::InternalType *poResult = NULL;
-    types::InternalType::ScilabType TypeSource = _poSource->getType();
-    types::InternalType::ScilabType TypeDest = types::InternalType::ScilabInternal;
+    InternalType *poResult = NULL;
+    bool isNew = true;
+    InternalType::ScilabType TypeSource = _poSource->getType();
+    InternalType::ScilabType TypeDest = InternalType::ScilabInternal;
     int iCurRow = _iRows;
     int iCurCol = _iCols;
 
@@ -194,64 +195,64 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
     {
         switch (TypeSource)
         {
-            case types::GenericType::ScilabDouble :
-                poResult = new types::Double(_iRows, _iCols, false);
+            case GenericType::ScilabDouble :
+                poResult = new Double(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabBool :
-                poResult = new types::Bool(_iRows, _iCols);
+            case GenericType::ScilabBool :
+                poResult = new Bool(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabInt8 :
-                poResult = new types::Int8(_iRows, _iCols);
+            case GenericType::ScilabInt8 :
+                poResult = new Int8(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabUInt8 :
-                poResult = new types::UInt8(_iRows, _iCols);
+            case GenericType::ScilabUInt8 :
+                poResult = new UInt8(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabInt16 :
-                poResult = new types::Int16(_iRows, _iCols);
+            case GenericType::ScilabInt16 :
+                poResult = new Int16(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabUInt16 :
-                poResult = new types::UInt16(_iRows, _iCols);
+            case GenericType::ScilabUInt16 :
+                poResult = new UInt16(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabInt32 :
-                poResult = new types::Int32(_iRows, _iCols);
+            case GenericType::ScilabInt32 :
+                poResult = new Int32(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabUInt32 :
-                poResult = new types::UInt32(_iRows, _iCols);
+            case GenericType::ScilabUInt32 :
+                poResult = new UInt32(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabInt64 :
-                poResult = new types::Int64(_iRows, _iCols);
+            case GenericType::ScilabInt64 :
+                poResult = new Int64(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabUInt64 :
-                poResult = new types::UInt64(_iRows, _iCols);
+            case GenericType::ScilabUInt64 :
+                poResult = new UInt64(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabString :
-                poResult = new types::String(_iRows, _iCols);
+            case GenericType::ScilabString :
+                poResult = new String(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabSparse :
-                poResult = new types::Sparse(_iRows, _iCols);
+            case GenericType::ScilabSparse :
+                poResult = new Sparse(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabSparseBool :
-                poResult = new types::SparseBool(_iRows, _iCols);
+            case GenericType::ScilabSparseBool :
+                poResult = new SparseBool(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabPolynom :
+            case GenericType::ScilabPolynom :
             {
                 int* piRank = new int[_iRows * _iCols];
                 memset(piRank, 0x00, _iRows * _iCols * sizeof(int));
-                poResult = new types::Polynom(_poSource->getAs<types::Polynom>()->getVariableName(), _iRows, _iCols, piRank);
+                poResult = new Polynom(_poSource->getAs<Polynom>()->getVariableName(), _iRows, _iCols, piRank);
                 delete[] piRank;
                 break;
             }
-            case types::InternalType::ScilabImplicitList :
-                poResult = new types::ImplicitList();
+            case InternalType::ScilabImplicitList :
+                poResult = new ImplicitList();
                 break;
-            case types::GenericType::ScilabHandle :
-                poResult = new types::GraphicHandle(_iRows, _iCols);
+            case GenericType::ScilabHandle :
+                poResult = new GraphicHandle(_iRows, _iCols);
                 break;
-            case types::GenericType::ScilabDollar :
+            case GenericType::ScilabDollar :
             {
                 int* piRank = new int[_iRows * _iCols];
                 memset(piRank, 0x00, _iRows * _iCols * sizeof(int));
-                poResult = new types::Polynom(_poSource->getAs<types::Polynom>()->getVariableName(), _iRows, _iCols, piRank);
+                poResult = new Polynom(_poSource->getAs<Polynom>()->getVariableName(), _iRows, _iCols, piRank);
                 delete[] piRank;
                 break;
             }
@@ -267,6 +268,7 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
     {
         TypeDest = _poDest->getType();
         poResult = _poDest;
+        isNew = false;
     }
 
 
@@ -275,20 +277,24 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
         //check if source type is compatible with dest type
         switch (TypeDest)
         {
-            case types::GenericType::ScilabDouble :
-                if (TypeSource == types::GenericType::ScilabPolynom)
+            case GenericType::ScilabDouble :
+                if (TypeSource == GenericType::ScilabPolynom)
                 {
-                    types::Double *poDest = _poDest->getAs<types::Double>();
-                    Polynom* pPSource = _poSource->getAs<types::Polynom>();
+                    Double *poDest = _poDest->getAs<Double>();
+                    Polynom* pPSource = _poSource->getAs<Polynom>();
 
                     //Convert Dest to ScilabPolynom
                     int iSize = poDest->getSize();
                     int *piRank = new int[iSize];
                     memset(piRank, 0x00, iSize * sizeof(int));
-                    poResult = new types::Polynom(pPSource->getVariableName(), poDest->getRows(), poDest->getCols(), piRank);
+                    if (isNew && poResult)
+                    {
+                        poResult->killMe();
+                    }
+                    poResult = new Polynom(pPSource->getVariableName(), poDest->getRows(), poDest->getCols(), piRank);
                     delete[] piRank;
 
-                    Polynom* pPResult = poResult->getAs<types::Polynom>();
+                    Polynom* pPResult = poResult->getAs<Polynom>();
                     pPResult->setComplex(poDest->isComplex());
 
                     double *pR = poDest->getReal();
@@ -322,12 +328,12 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
                     return poResult;
                 }
                 break;
-            case types::GenericType::ScilabPolynom :
-                if (TypeSource == types::GenericType::ScilabDouble)
+            case GenericType::ScilabPolynom :
+                if (TypeSource == GenericType::ScilabDouble)
                 {
                     //Add Source like coef of the new element
                     Double* pD = _poSource->getAs<Double>();
-                    types::Polynom* pPolyOut = poResult->getAs<types::Polynom>();
+                    Polynom* pPolyOut = poResult->getAs<Polynom>();
 
                     if (pD->isComplex())
                     {
@@ -336,7 +342,7 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
                         {
                             for (int j = 0 ; j < pD->getCols() ; j++)
                             {
-                                types::SinglePoly* pSPOut = pPolyOut->get(iCurRow + i, iCurCol + j);
+                                SinglePoly* pSPOut = pPolyOut->get(iCurRow + i, iCurCol + j);
 
                                 pSPOut->setRank(0);
                                 double pDblR = pD->get(i, j);
@@ -351,7 +357,7 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
                         {
                             for (int j = 0 ; j < pD->getCols() ; j++)
                             {
-                                types::SinglePoly* pSPOut = pPolyOut->get(iCurRow + i, iCurCol + j);
+                                SinglePoly* pSPOut = pPolyOut->get(iCurRow + i, iCurCol + j);
 
                                 pSPOut->setRank(0);
                                 double pDbl = pD->get(i, j);
@@ -362,17 +368,17 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
 
                     return poResult;
                 }
-                else if (TypeSource == types::GenericType::ScilabDollar)
+                else if (TypeSource == GenericType::ScilabDollar)
                 {
-                    poResult->getAs<types::Polynom>()->append(iCurRow, iCurCol, _poSource->getAs<types::Dollar>());
+                    poResult->getAs<Polynom>()->append(iCurRow, iCurCol, _poSource->getAs<Dollar>());
                     return poResult;
                 }
                 break;
-            case types::GenericType::ScilabSparse :
-                if (TypeSource == types::GenericType::ScilabDouble)
+            case GenericType::ScilabSparse :
+                if (TypeSource == GenericType::ScilabDouble)
                 {
-                    types::Double* poSource = _poSource->getAs<types::Double>();
-                    types::Sparse* spResult = poResult->getAs<types::Sparse>();
+                    Double* poSource = _poSource->getAs<Double>();
+                    Sparse* spResult = poResult->getAs<Sparse>();
 
                     // Set complex the result if one of inputs is complex
                     if (poSource->isComplex())
@@ -434,11 +440,11 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
                     return poResult;
                 }
                 break;
-            case types::GenericType::ScilabSparseBool :
-                if (TypeSource == types::GenericType::ScilabBool)
+            case GenericType::ScilabSparseBool :
+                if (TypeSource == GenericType::ScilabBool)
                 {
-                    types::Bool* poSource = _poSource->getAs<types::Bool>();
-                    types::SparseBool* spResult = poResult->getAs<types::SparseBool>();
+                    Bool* poSource = _poSource->getAs<Bool>();
+                    SparseBool* spResult = poResult->getAs<SparseBool>();
 
                     // Add poSource at the end of spResult
                     for (int i = 0; i < poSource->getRows(); i++)
@@ -467,87 +473,65 @@ types::InternalType* AddElementToVariable(types::InternalType* _poDest, types::I
         //Just add the new value in the current item
         switch (TypeDest)
         {
-            case types::GenericType::ScilabDouble :
-                ((Double*)poResult)->append(iCurRow, iCurCol, (Double*)_poSource);
+            case GenericType::ScilabDouble :
+                poResult->getAs<Double>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabPolynom :
-                poResult->getAs<types::Polynom>()->append(iCurRow, iCurCol, _poSource->getAs<types::Polynom>());
+            case GenericType::ScilabPolynom :
+                poResult->getAs<Polynom>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabBool:
-                poResult->getAs<types::Bool>()->append(iCurRow, iCurCol, _poSource->getAs<types::Bool>());
+            case GenericType::ScilabBool:
+                poResult->getAs<Bool>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabInt8 :
-                poResult->getAs<types::Int8>()->append(iCurRow, iCurCol, _poSource->getAs<types::Int8>());
+            case GenericType::ScilabInt8 :
+                poResult->getAs<Int8>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabUInt8 :
-                poResult->getAs<types::UInt8>()->append(iCurRow, iCurCol, _poSource->getAs<types::UInt8>());
+            case GenericType::ScilabUInt8 :
+                poResult->getAs<UInt8>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabInt16 :
-                poResult->getAs<types::Int16>()->append(iCurRow, iCurCol, _poSource->getAs<types::Int16>());
+            case GenericType::ScilabInt16 :
+                poResult->getAs<Int16>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabUInt16 :
-                poResult->getAs<types::UInt16>()->append(iCurRow, iCurCol, _poSource->getAs<types::UInt16>());
+            case GenericType::ScilabUInt16 :
+                poResult->getAs<UInt16>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabInt32 :
-                poResult->getAs<types::Int32>()->append(iCurRow, iCurCol, _poSource->getAs<types::Int32>());
+            case GenericType::ScilabInt32 :
+                poResult->getAs<Int32>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabUInt32 :
-                poResult->getAs<types::UInt32>()->append(iCurRow, iCurCol, _poSource->getAs<types::UInt32>());
+            case GenericType::ScilabUInt32 :
+                poResult->getAs<UInt32>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabInt64 :
-                poResult->getAs<types::Int64>()->append(iCurRow, iCurCol, _poSource->getAs<types::Int64>());
+            case GenericType::ScilabInt64 :
+                poResult->getAs<Int64>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabUInt64 :
-                poResult->getAs<types::UInt64>()->append(iCurRow, iCurCol, _poSource->getAs<types::UInt64>());
+            case GenericType::ScilabUInt64 :
+                poResult->getAs<UInt64>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabSparse :
-                poResult->getAs<types::Sparse>()->append(iCurRow, iCurCol, _poSource->getAs<types::Sparse>());
+            case GenericType::ScilabSparse :
+                poResult->getAs<Sparse>()->append(iCurRow, iCurCol, _poSource->getAs<Sparse>());
                 break;
-            case types::GenericType::ScilabSparseBool :
-                poResult->getAs<types::SparseBool>()->append(iCurRow, iCurCol, _poSource->getAs<types::SparseBool>());
+            case GenericType::ScilabSparseBool :
+                poResult->getAs<SparseBool>()->append(iCurRow, iCurCol, _poSource->getAs<SparseBool>());
                 break;
-            case types::GenericType::ScilabString :
+            case GenericType::ScilabString :
             {
-                types::String* pSource = _poSource->getAs<types::String>();
-                poResult->getAs<types::String>()->append(iCurRow, iCurCol, pSource);
+                poResult->getAs<String>()->append(iCurRow, iCurCol, _poSource);
             }
             break;
-            case types::GenericType::ScilabImplicitList :
+            case GenericType::ScilabImplicitList :
             {
-                if (_poSource->getAs<ImplicitList>()->getStartType() == types::InternalType::ScilabPolynom)
-                {
-                    poResult->getAs<ImplicitList>()->setStart(_poSource->getAs<ImplicitList>()->getStart());
-                }
-                else
-                {
-                    poResult->getAs<ImplicitList>()->setStart(_poSource->getAs<ImplicitList>()->getStart());
-                }
-
-                if (_poSource->getAs<ImplicitList>()->getStepType() == types::InternalType::ScilabPolynom)
-                {
-                    poResult->getAs<ImplicitList>()->setStep(_poSource->getAs<ImplicitList>()->getStep());
-                }
-                else
-                {
-                    poResult->getAs<ImplicitList>()->setStep(_poSource->getAs<ImplicitList>()->getStep());
-                }
-
-                if (_poSource->getAs<ImplicitList>()->getEndType() == types::InternalType::ScilabPolynom)
-                {
-                    poResult->getAs<ImplicitList>()->setEnd(_poSource->getAs<ImplicitList>()->getEnd());
-                }
-                else
-                {
-                    poResult->getAs<ImplicitList>()->setEnd(_poSource->getAs<ImplicitList>()->getEnd());
-                }
+                ImplicitList* pIL = _poSource->getAs<ImplicitList>();
+                ImplicitList* pOL = poResult->getAs<ImplicitList>();
+                pOL->setStart(pIL->getStart());
+                pOL->setStep(pIL->getStep());
+                pOL->setEnd(pIL->getEnd());
                 break;
             }
-            case types::GenericType::ScilabHandle :
-                poResult->getAs<types::GraphicHandle>()->append(iCurRow, iCurCol, _poSource->getAs<types::GraphicHandle>());
+            case GenericType::ScilabHandle :
+                poResult->getAs<GraphicHandle>()->append(iCurRow, iCurCol, _poSource);
                 break;
-            case types::GenericType::ScilabDollar:
+            case GenericType::ScilabDollar:
             {
-                poResult->getAs<types::Polynom>()->append(iCurRow, iCurCol, _poSource->getAs<types::Dollar>());
+                poResult->getAs<Polynom>()->append(iCurRow, iCurCol, _poSource);
                 break;
             }
             default:
@@ -591,12 +575,12 @@ const std::wstring* getStructNameFromExp(const ast::Exp* _pExp)
 //i1, ..., in : indexes
 //dest : variable where insert data     || NULL
 //source : data to insert               || extract indexes from source
-types::InternalType* callOverload(const ast::Exp& e, std::wstring _strType, types::typed_list* _pArgs, types::InternalType* _source, types::InternalType* _dest)
+InternalType* callOverload(const ast::Exp& e, std::wstring _strType, typed_list* _pArgs, InternalType* _source, InternalType* _dest)
 {
-    types::Function::ReturnValue ret = types::Function::Error;
-    types::InternalType* pITOut = NULL;
-    types::typed_list in;
-    types::typed_list out;
+    Function::ReturnValue ret = Function::Error;
+    InternalType* pITOut = NULL;
+    typed_list in;
+    typed_list out;
 
     std::wstring function_name;
     function_name = L"%" + _source->getShortTypeStr() + L"_" + _strType;
@@ -654,7 +638,7 @@ types::InternalType* callOverload(const ast::Exp& e, std::wstring _strType, type
             _dest->DecreaseRef();
         }
 
-        if (ret == types::Function::Error)
+        if (ret == Function::Error)
         {
             if (bThrow)
             {
@@ -722,7 +706,7 @@ bool getFieldsFromExp(ast::Exp* _pExp, std::list<ExpHistory*>& fields)
     else if (pCall)
     {
         bool bArgList = false;
-        types::List* pList = NULL;
+        List* pList = NULL;
         int iListIncr = 0;
         int iListSize = 0;
 
@@ -744,7 +728,7 @@ bool getFieldsFromExp(ast::Exp* _pExp, std::list<ExpHistory*>& fields)
                 (*pCurrentArgs)[0]->isMList() == false)
         {
             bArgList = true;
-            pList = (*pCurrentArgs)[0]->getAs<types::List>();
+            pList = (*pCurrentArgs)[0]->getAs<List>();
             //pList->IncreaseRef();
             pCurrentArgs->clear();
             pCurrentArgs->push_back(pList->get(iListIncr));
@@ -793,7 +777,7 @@ bool getFieldsFromExp(ast::Exp* _pExp, std::list<ExpHistory*>& fields)
                 if (iListIncr < iListSize)
                 {
                     // create new args for next loop.
-                    pCurrentArgs = new types::typed_list();
+                    pCurrentArgs = new typed_list();
                     pCurrentArgs->push_back(pList->get(iListIncr));
                 }
             }
@@ -814,7 +798,7 @@ bool getFieldsFromExp(ast::Exp* _pExp, std::list<ExpHistory*>& fields)
     }
 }
 
-types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*>& fields, InternalType* _pAssignValue)
+InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*>& fields, InternalType* _pAssignValue)
 {
     std::list<ExpHistory*> evalFields;
     std::list<ExpHistory*> workFields;
@@ -884,7 +868,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
             evalFields.push_back(pEH);
             workFields.pop_front();
 
-            types::InternalType* pITCurrent = pEH->getCurrent();
+            InternalType* pITCurrent = pEH->getCurrent();
 
             if (pEH->isCellExp() && pITCurrent->isCell() == false)
             {
@@ -1370,7 +1354,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                 if (pEH->getArgs())
                 {
                     // a(x)
-                    InternalType* pExtract = pITCurrent->getAs<types::UserType>()->extract(pEH->getArgs());
+                    InternalType* pExtract = pITCurrent->getAs<UserType>()->extract(pEH->getArgs());
                     if (pExtract == NULL)
                     {
                         // call overload
@@ -1419,7 +1403,7 @@ types::InternalType* evaluateFields(const ast::Exp* _pExp, std::list<ExpHistory*
                     }
                     else
                     {
-                        InternalType* pExtract = pITCurrent->getAs<types::UserType>()->extract(args);
+                        InternalType* pExtract = pITCurrent->getAs<UserType>()->extract(args);
                         if (pExtract == NULL)
                         {
                             // call overload
@@ -1776,8 +1760,8 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
             }
             case InternalType::ScilabHandle :
             {
-                types::GraphicHandle* pH = _pVar->getAs<GraphicHandle>();
-                types::String *pS = (*_pArgs)[0]->getAs<types::String>();
+                GraphicHandle* pH = _pVar->getAs<GraphicHandle>();
+                String *pS = (*_pArgs)[0]->getAs<String>();
 
                 typed_list in;
                 typed_list out;
@@ -1811,7 +1795,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
         //if _pVar == NULL and pArg is single string, it's a struct creation
         if ((*_pArgs)[0]->isString())
         {
-            String *pS = (*_pArgs)[0]->getAs<types::String>();
+            String *pS = (*_pArgs)[0]->getAs<String>();
             Struct* pStr = new Struct(1, 1);
 
             if (_pArgs->size() != 1 || pS->isScalar() == false)
@@ -1885,7 +1869,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
                 default :
                 {
                     // overload
-                    types::Double* pEmpty = types::Double::Empty();
+                    Double* pEmpty = Double::Empty();
                     pOut = callOverload(e, L"i", _pArgs, _pInsert, pEmpty);
                     pEmpty->killMe();
                     break;
@@ -1909,7 +1893,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
             Double* pD = new Double(pSp->getRows(), pSp->getCols(), pSp->isComplex());
             pSp->fill(*pD);
             pRet = _pVar->getAs<Double>()->insert(_pArgs, pD);
-            free(pD);
+            delete pD;
         }
         else if (_pVar->isString() && _pInsert->isString())
         {
@@ -2053,7 +2037,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
             if (_pArgs->size() == 1 && (*_pArgs)[0]->isString())
             {
                 //s("x") = y
-                String *pS = (*_pArgs)[0]->getAs<types::String>();
+                String *pS = (*_pArgs)[0]->getAs<String>();
                 if (pS->isScalar() == false)
                 {
                     if (pIL)
@@ -2159,7 +2143,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
                 if ((*_pArgs)[0]->isString())
                 {
                     //s("x") = y
-                    String *pS = (*_pArgs)[0]->getAs<types::String>();
+                    String *pS = (*_pArgs)[0]->getAs<String>();
                     if (pS->isScalar() == false)
                     {
                         if (pIL)
@@ -2188,8 +2172,8 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
                         return callOverload(e, L"i", _pArgs, _pInsert, _pVar);
 
                         //ExecVisitor exec;
-                        //types::typed_list in;
-                        //types::typed_list out;
+                        //typed_list in;
+                        //typed_list out;
                         //std::wstring function_name = L"%l_e";
 
                         //_pInsert->IncreaseRef();
@@ -2226,7 +2210,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
                         // in the first element, the TList have to be a List.
                         if (pTL->get(0)->isString() == false)
                         {
-                            types::List* pL = new List();
+                            List* pL = new List();
                             for (int i = 0; i < pTL->getSize(); i++)
                             {
                                 pL->append(pTL->get(i));
@@ -2258,7 +2242,7 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
         }
         else if (_pVar->isList())
         {
-            types::List* pL = NULL;
+            List* pL = NULL;
             // In case where pL is in several scilab variable,
             // we have to clone it for keep the other variables unchanged.
             if (_pVar->getRef() > 1)
@@ -2288,8 +2272,8 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
             if (_pArgs->size() == 1 && (*_pArgs)[0]->isString())
             {
                 //s(["x"])
-                types::GraphicHandle* pH = _pVar->getAs<types::GraphicHandle>();
-                types::String *pS = (*_pArgs)[0]->getAs<types::String>();
+                GraphicHandle* pH = _pVar->getAs<GraphicHandle>();
+                String *pS = (*_pArgs)[0]->getAs<String>();
                 typed_list in;
                 typed_list out;
                 optional_list opt;
@@ -2311,12 +2295,12 @@ InternalType* insertionCall(const ast::Exp& e, typed_list* _pArgs, InternalType*
             }
             else
             {
-                pRet = _pVar->getAs<types::GraphicHandle>()->insert(_pArgs, _pInsert);
+                pRet = _pVar->getAs<GraphicHandle>()->insert(_pArgs, _pInsert);
             }
         }
         else if (_pVar->isUserType())
         {
-            pRet = _pVar->getAs<types::UserType>()->insert(_pArgs, _pInsert);
+            pRet = _pVar->getAs<UserType>()->insert(_pArgs, _pInsert);
             if (pRet == NULL)
             {
                 pRet = callOverload(e, L"i", _pArgs, _pInsert, _pVar);
@@ -2348,15 +2332,15 @@ void callOnPrompt(void)
         onPrompt = symbol::Context::getInstance()->getOrCreate(symbol::Symbol(L"%onprompt"));
     }
 
-    types::InternalType* pOnPrompt = NULL;
+    InternalType* pOnPrompt = NULL;
     pOnPrompt = onPrompt->get();
     if (pOnPrompt != NULL && pOnPrompt->isCallable())
     {
-        types::typed_list in;
-        types::typed_list out;
-        types::optional_list opt;
+        typed_list in;
+        typed_list out;
+        optional_list opt;
         ast::ExecVisitor execCall;
-        pOnPrompt->getAs<types::Callable>()->call(in, opt, 1, out, &execCall);
+        pOnPrompt->getAs<Callable>()->call(in, opt, 1, out, &execCall);
     }
 }
 
index 8d496c5..ff9cbd0 100644 (file)
@@ -519,6 +519,7 @@ int MultiplyDoubleByPoly(Double* _pDouble, Polynom* _pPoly, Polynom** _pPolyOut)
                                            pTemp->get(), pTemp->getImg());
     }
 
+    pCoef->killMe();
     (*_pPolyOut)->setCoef(pTemp);
     (*_pPolyOut)->updateRank();
     delete pTemp;
@@ -994,6 +995,8 @@ int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
                 }
             }
         }
+
+        pTemp->killMe();
     }
     else if (bComplex1 == false && bComplex2 == true)
     {
@@ -1027,6 +1030,8 @@ int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
                 }
             }
         }
+
+        pTemp->killMe();
     }
     else if (bComplex1 == true && bComplex2 == false)
     {
@@ -1060,6 +1065,8 @@ int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
                 }
             }
         }
+
+        pTemp->killMe();
     }
     else if (bComplex1 == true && bComplex2 == true)
     {
@@ -1093,6 +1100,8 @@ int MultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOut)
                 }
             }
         }
+
+        pTemp->killMe();
     }
     (*_pPolyOut)->updateRank();
 
@@ -1569,6 +1578,7 @@ int DotMultiplyPolyByPoly(Polynom* _pPoly1, Polynom* _pPoly2, Polynom** _pPolyOu
         }
 
         (*_pPolyOut) = new Polynom(_pPoly1->getVariableName(), _pPoly1->getDims(), _pPoly1->getDimsArray(), piRank);
+        delete[] piRank;
 
         if (_pPoly1->isComplex() && _pPoly2->isComplex())
         {
index 73f5aa5..9e8707d 100644 (file)
@@ -362,6 +362,7 @@ int PowerPolyByDouble(Polynom* _pPoly, Double* _pDouble, InternalType** _pOut)
         }
 
         Polynom* pOut = new Polynom(_pPoly->getVariableName(), _pDouble->getRows(), _pDouble->getCols(), piRank);
+        delete[] piRank;
         pOut->setComplex(bComplex1);
 
         for (int i = 0 ; i < _pDouble->getSize() ; i++)
@@ -379,16 +380,17 @@ int PowerPolyByDouble(Polynom* _pPoly, Double* _pDouble, InternalType** _pOut)
 
             while (iLoop)
             {
+                SinglePoly* ps = pP->get()[0];
                 if (iLoop % 2)
                 {
                     int iRank = pP->getMaxRank();
                     if (bComplex1)
                     {
-                        C2F(wpmul1)(pCoeffOut->get(), pCoeffOut->getImg(), &iCurrentRank, pP->getCoef()->get(), pP->getCoef()->getImg(), &iRank, pCoeffOut->get(), pCoeffOut->getImg());
+                        C2F(wpmul1)(pCoeffOut->get(), pCoeffOut->getImg(), &iCurrentRank, ps->get(), ps->getImg(), &iRank, pCoeffOut->get(), pCoeffOut->getImg());
                     }
                     else
                     {
-                        C2F(dpmul1)(pCoeffOut->get(), &iCurrentRank, pP->getCoef()->get(), &iRank, pCoeffOut->get());
+                        C2F(dpmul1)(pCoeffOut->get(), &iCurrentRank, ps->get(), &iRank, pCoeffOut->get());
                     }
                     iCurrentRank += iRank;
                 }
@@ -399,10 +401,12 @@ int PowerPolyByDouble(Polynom* _pPoly, Double* _pDouble, InternalType** _pOut)
                     //p = p * p
                     Polynom* pTemp = NULL;
                     MultiplyPolyByPoly(pP, pP, &pTemp);
-                    delete pP;
+                    pP->killMe();
                     pP = pTemp;
                 }
             }
+
+            pP->killMe();
         }
         *_pOut = pOut;
     }
index a7dcd2d..6b477f8 100644 (file)
@@ -2127,6 +2127,7 @@ template<> InternalType* sub_M_M<Double, Polynom, Polynom>(Double* _pL, Polynom*
         }
 
         pOut = new Polynom(_pR->getVariableName(), _pL->getDims(), _pL->getDimsArray(), piRank);
+        delete[] piRank;
         if (bComplex1 || bComplex2)
         {
             pOut->setComplex(true);
index 73446bb..004390e 100644 (file)
@@ -100,16 +100,15 @@ bool Context::clearCurrentScope(bool _bClose)
     }
 
     VarList* varList = varStack.top();
-    std::map<Symbol, Variable*>::iterator it = varList->begin();
-    for (; it != varList->end() ; ++it)
+    for (auto var : *varList)
     {
-        if (it->second->empty() == false && it->second->top()->m_iLevel == m_iLevel)
+        if (var.second->empty() == false && var.second->top()->m_iLevel == m_iLevel)
         {
-            ScopedVariable * pSV = it->second->top();
+            ScopedVariable * pSV = var.second->top();
             types::InternalType * pIT = pSV->m_pIT;
             pIT->DecreaseRef();
             pIT->killMe();
-            it->second->pop();
+            var.second->pop();
             delete pSV;
         }
     }
index d47e9e8..f476c33 100644 (file)
@@ -307,8 +307,7 @@ std::wstring ConfigVariable::m_wstError;
 
 void ConfigVariable::setLastErrorMessage(std::wstring _wstError)
 {
-    wchar_t* pwstTemp1 = os_wcsdup(_wstError.c_str());
-    m_wstError = pwstTemp1;
+    m_wstError = _wstError;
 }
 
 std::wstring ConfigVariable::getLastErrorMessage()
@@ -522,9 +521,9 @@ types::Cell* ConfigVariable::getAllThreads(void)
     types::Cell *pcResult = new types::Cell(iSize, 1);
     std::list<types::ThreadId *>::iterator it;
 
-    for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it, ++i)
+    for (auto thread : ConfigVariable::m_threadList)
     {
-        pcResult->set(i, *it);
+        pcResult->set(i++, *it);
     }
 
     return pcResult;
@@ -555,19 +554,6 @@ types::ThreadId* ConfigVariable::getThread(__threadKey _key)
 
 void ConfigVariable::deleteThread(__threadKey _key)
 {
-    //for(int i = 0 ; i < m_threadList.size() ; i++)
-    //{
-    //    types::ThreadId* pThread = m_threadList[i];
-    //    if(pThread->getKey() == _key)
-    //    {
-    //        pThread->DecreaseRef();
-    //        if(pThread->isDeletable())
-    //        {
-    //            delete pThread;
-    //            m_threadList.erase(.begin() + i - 1);
-    //        }
-    //    }
-    //}
     std::list<types::ThreadId *>::iterator it;
     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
     {
@@ -1154,10 +1140,9 @@ std::list<std::wstring> ConfigVariable::m_ReferenceModules;
 
 bool ConfigVariable::checkReferenceModule(std::wstring _module)
 {
-    std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
-    for ( ; it != m_ReferenceModules.end() ; ++it)
+    for (auto ref : m_ReferenceModules)
     {
-        if (*it == _module)
+        if (ref == _module)
         {
             return true;
         }
index 50460ec..2230bb1 100644 (file)
@@ -583,14 +583,17 @@ InternalType* ArrayOf<T>::insertNew(typed_list* _pArgs, InternalType* _pSource)
         T* pImgData = pArrayOut->getImg();
         for (int i = 0 ; i < pArrayOut->getSize() ; i++)
         {
+            pArrayOut->deleteData(pRealData[i]);
             pRealData[i] = pSource->getNullValue();
-            pImgData[i]  = pSource->getNullValue();
+            pArrayOut->deleteData(pImgData[i]);
+            pImgData[i] = pSource->getNullValue();
         }
     }
     else
     {
         for (int i = 0 ; i < pArrayOut->getSize() ; i++)
         {
+            pArrayOut->deleteData(pRealData[i]);
             pRealData[i] = pSource->getNullValue();
         }
     }
index f5d6930..5b8e5da 100644 (file)
@@ -29,6 +29,8 @@ Bool::~Bool()
     {
         deleteAll();
     }
+
+    delete m_pRealData;
 #ifndef NDEBUG
     Inspector::removeItem(this);
 #endif
index b003e12..6c1e354 100644 (file)
@@ -51,7 +51,6 @@ void Cell::createCell(int _iDims, int* _piDims)
     create(_piDims, _iDims, &pIT, NULL);
     for (int i = 0; i < getSize(); i++)
     {
-        double* pReal = NULL;
         m_pRealData[i] = Double::Empty();
         m_pRealData[i]->IncreaseRef();
     }
@@ -64,12 +63,14 @@ Cell::~Cell()
 {
     if (isDeletable() == true)
     {
-        for (int i = 0 ; i < getSize() ; i++)
+        for (int i = 0; i < m_iSizeMax; i++)
         {
             m_pRealData[i]->DecreaseRef();
             m_pRealData[i]->killMe();
         }
     }
+
+    delete[] m_pRealData;
 #ifndef NDEBUG
     Inspector::removeItem(this);
 #endif
@@ -445,4 +446,13 @@ InternalType** Cell::allocData(int _iSize)
     }
     return pData;
 }
+
+void Cell::deleteData(InternalType* _pData)
+{
+    if (_pData)
+    {
+        _pData->DecreaseRef();
+        _pData->killMe();
+    }
+}
 }
index 9d7cb72..531c77c 100644 (file)
@@ -66,9 +66,9 @@ Double* Double::Identity(int _iDims, int* _piDims)
         }
     }
 
-    for (int i = 0 ; i < iMinDim ; i++)
+    int* piIndex = new int[_iDims];
+    for (int i = 0; i < iMinDim; i++)
     {
-        int* piIndex = new int[_iDims];
         for (int j = 0 ; j < _iDims ; j++)
         {
             piIndex[j] = i;
@@ -77,6 +77,8 @@ Double* Double::Identity(int _iDims, int* _piDims)
         int index = getIndexWithDims(piIndex, _piDims, _iDims);
         pI->set(index, 1);
     }
+
+    delete[] piIndex;
     return pI;
 }
 
@@ -93,9 +95,9 @@ Double* Double::Identity(int _iDims, int* _piDims, double _dblReal)
         }
     }
 
+    int* piIndex = new int[_iDims];
     for (int i = 0; i < iMinDim; i++)
     {
-        int* piIndex = new int[_iDims];
         for (int j = 0; j < _iDims; j++)
         {
             piIndex[j] = i;
@@ -104,6 +106,8 @@ Double* Double::Identity(int _iDims, int* _piDims, double _dblReal)
         int index = getIndexWithDims(piIndex, _piDims, _iDims);
         pI->set(index, _dblReal);
     }
+
+    delete[] piIndex;
     return pI;
 }
 
index 4861c2a..35060be 100644 (file)
@@ -44,36 +44,17 @@ size_t Inspector::getUnreferencedItemCount()
 void Inspector::addItem(InternalType* _pIT)
 {
     types::GenericType* pGT = _pIT->getAs<types::GenericType>();
-
-    if (pGT)
-    {
-        //std::wcout << L"addItem " << pGT->getTypeStr() << L"[" << pGT->getSize() << L"] : " << pGT << std::endl;
-    }
-    else
-    {
-        //std::wcout << L"addItem " << _pIT->getTypeStr() << L" : " << _pIT << std::endl;
-    }
     m_vIT.push_back(_pIT);
 }
 
 void Inspector::removeItem(InternalType* _pIT)
 {
     std::vector<InternalType*>::iterator it;
-
     for (it = m_vIT.begin() ; it != m_vIT.end() ; it++)
     {
         if ((*it) == _pIT)
         {
             types::GenericType* pGT = _pIT->getAs<types::GenericType>();
-
-            if (pGT)
-            {
-                //std::wcout << L"removeItem " << pGT->getTypeStr() << L"[" << pGT->getSize() << L"] : " << pGT << std::endl;
-            }
-            else
-            {
-                //std::wcout << L"removeItem " << _pIT->getTypeStr() << L" : " << _pIT << std::endl;
-            }
             m_vIT.erase(it);
             break;
         }
index 5465bbf..4addf76 100644 (file)
@@ -33,9 +33,9 @@ Library::Library(const std::wstring& _wstPath) :
 Library::~Library()
 {
     //delete all macrofile*
-    for (MacroMap::iterator it = m_macros.begin(); it != m_macros.end() ; ++it)
+    for (auto macro : m_macros)
     {
-        MacroFile* pMacro = it->second;
+        MacroFile* pMacro = macro.second;
         pMacro->DecreaseRef();
         if (pMacro->isDeletable())
         {
@@ -56,16 +56,15 @@ bool Library::toString(std::wostringstream& ostr)
     size_t iLineLen = (size_t)ConfigVariable::getConsoleWidth();
 
     size_t iCurrentLen = 0;
-    MacroMap::iterator it = m_macros.begin();
-    for (int i = 0; it != m_macros.end() ; ++it, ++i)
+    for (auto macro : m_macros)
     {
-        if (iCurrentLen + it->first.length() + 2 > iLineLen)
+        if (iCurrentLen + macro.first.length() + 2 > iLineLen)
         {
             ostr << std::endl;
             iCurrentLen = 0;
         }
-        ostr << it->first << "  ";
-        iCurrentLen += it->first.length() + 2;
+        ostr << macro.first << "  ";
+        iCurrentLen += macro.first.length() + 2;
     }
 
     ostr << std::endl;
@@ -112,10 +111,9 @@ MacroFile* Library::get(const std::wstring& _wstName)
 std::list<std::wstring>* Library::getMacrosName()
 {
     std::list<std::wstring>* pOut = new std::list<std::wstring>;
-    MacroMap::iterator it = m_macros.begin();
-    for (; it != m_macros.end() ; ++it)
+    for (auto macro : m_macros)
     {
-        pOut->push_back(it->first);
+        pOut->push_back(macro.first);
     }
 
     return pOut;
index 794e807..db3adf0 100644 (file)
@@ -48,11 +48,10 @@ List::~List()
 {
     if (isDeletable() == true)
     {
-        std::vector<InternalType *>::iterator itValues;
-        for (itValues = m_plData->begin() ; itValues != m_plData->end() ; ++itValues)
+        for (auto data : *m_plData)
         {
-            (*itValues)->DecreaseRef();
-            (*itValues)->killMe();
+            data->DecreaseRef();
+            data->killMe();
         }
         delete m_plData;
     }
@@ -66,7 +65,6 @@ List::~List()
 */
 List::List(List *_oListCopyMe)
 {
-    std::vector<InternalType *>::iterator itValues;
     m_plData = new std::vector<InternalType *>;
 
     for (int i = 0 ; i < (int)_oListCopyMe->getData()->size() ; i++)
@@ -128,15 +126,14 @@ bool List::toString(std::wostringstream& ostr)
     {
         wchar_t* wcsVarName = os_wcsdup(ostr.str().c_str());
         int iPosition = 1;
-        std::vector<InternalType *>::iterator itValues;
-        for (itValues = m_plData->begin() ; itValues != m_plData->end() ; ++itValues, ++iPosition)
+        for (auto val : *m_plData)
         {
             std::wostringstream nextVarName;
             ostr.str(L"");
-            nextVarName << " " << SPACES_LIST << wcsVarName << L"(" << iPosition << L")";
+            nextVarName << " " << SPACES_LIST << wcsVarName << L"(" << iPosition++ << L")";
             ostr << std::endl << nextVarName.str() << std::endl << std::endl;
             scilabForcedWriteW(ostr.str().c_str());
-            if (VariableToString(*itValues, nextVarName.str().c_str()) == types::Function::Error)
+            if (VariableToString(val, nextVarName.str().c_str()) == types::Function::Error)
             {
                 free(wcsVarName);
                 ostr.str(L"");
@@ -205,6 +202,8 @@ InternalType* List::insert(typed_list* _pArgs, InternalType* _pSource)
     int* piCountDim     = new int[iDims];
 
     int iSeqCount = checkIndexesArguments(this, _pArgs, &pArg, piMaxDim, piCountDim);
+    delete[] piMaxDim;
+    delete[] piCountDim;
     if (iSeqCount == 0)
     {
         //free pArg content
index ff06a22..4b214b4 100644 (file)
@@ -101,35 +101,34 @@ bool MacroFile::parse(void)
         //find FunctionDec
         ast::FunctionDec* pFD = NULL;
 
-        ast::exps_t::iterator j;
         ast::exps_t LExp = tree->getAs<ast::SeqExp>()->getExps();
         std::map<symbol::Symbol, Macro*> sub;
 
-        for (j = LExp.begin() ; j != LExp.end() ; j++)
+        for (auto exp : LExp)
         {
-            if ((*j)->isFunctionDec() == false)
+            if (exp->isFunctionDec() == false)
             {
                 continue;
             }
 
-            pFD = (*j)->getAs<ast::FunctionDec>();
+            pFD = exp->getAs<ast::FunctionDec>();
 
             //get input parameters list
             std::list<symbol::Variable*> *pVarList = new std::list<symbol::Variable*>();
             ast::ArrayListVar *pListVar = pFD->getArgs().getAs<ast::ArrayListVar>();
             ast::exps_t & vars = pListVar->getVars();
-            for (ast::exps_t::const_iterator it = vars.begin(), itEnd = vars.end(); it != itEnd; ++it)
+            for (auto var : vars)
             {
-                pVarList->push_back((*it)->getAs<ast::SimpleVar>()->getStack());
+                pVarList->push_back(var->getAs<ast::SimpleVar>()->getStack());
             }
 
             //get output parameters list
             std::list<symbol::Variable*> *pRetList = new std::list<symbol::Variable*>();
             ast::ArrayListVar *pListRet = pFD->getReturns().getAs<ast::ArrayListVar>();
             ast::exps_t & recs = pListRet->getVars();
-            for (ast::exps_t::const_iterator it = recs.begin(), itEnd = recs.end(); it != itEnd; ++it)
+            for (auto rec : recs)
             {
-                pRetList->push_back((*it)->getAs<ast::SimpleVar>()->getStack());
+                pRetList->push_back(rec->getAs<ast::SimpleVar>()->getStack());
             }
 
             const symbol::Symbol & sym = pFD->getSymbol();
index 9fb1005..203e6ae 100644 (file)
@@ -91,7 +91,7 @@ types::Function::ReturnValue Overload::call(std::wstring _stOverloadingFunctionN
             std::wstring wstError(pwstError);
             FREE(pwstError);
             FREE(pstFuncName);
-            throw ast::ScilabError(wstError, 999, *new Location());
+            throw ast::ScilabError(wstError, 999, Location());
         }
         else
         {
@@ -101,7 +101,7 @@ types::Function::ReturnValue Overload::call(std::wstring _stOverloadingFunctionN
             std::wstring wstError(pwstError);
             FREE(pwstError);
             FREE(pstFuncName);
-            throw ast::ScilabError(wstError, 999, *new Location());
+            throw ast::ScilabError(wstError, 999, Location());
         }
     }
     types::Callable *pCall = pIT->getAs<types::Callable>();
index 2f2f1b3..0b07007 100644 (file)
@@ -948,7 +948,7 @@ SinglePoly* Polynom::copyValue(SinglePoly* _pData)
 
 void Polynom::deleteAll()
 {
-    for (int i = 0 ; i < getSize() ; i++)
+    for (int i = 0 ; i < m_iSizeMax ; i++)
     {
         m_pRealData[i]->killMe();
     }
index da2d0a5..33a914c 100644 (file)
@@ -32,11 +32,10 @@ SingleStruct::~SingleStruct()
 {
     if (isDeletable() == true)
     {
-        std::list<InternalType*>::iterator iterFieldData;
-        for (iterFieldData = m_Data.begin(); iterFieldData != m_Data.end() ; iterFieldData++)
+        for (auto data : m_Data)
         {
-            (*iterFieldData)->DecreaseRef();
-            (*iterFieldData)->killMe();
+            data->DecreaseRef();
+            data->killMe();
         }
     }
 #ifndef NDEBUG
@@ -49,13 +48,13 @@ SingleStruct::SingleStruct(SingleStruct *_oSingleStructCopyMe)
     std::list<std::wstring> wstFields = _oSingleStructCopyMe->getFields();
     std::list<InternalType *> Data = _oSingleStructCopyMe->getData();
 
-    std::list<InternalType*>::iterator iterFieldData;
     std::list<std::wstring>::iterator iterFieldName = wstFields.begin();
-    for (iterFieldData = Data.begin(); iterFieldData != Data.end() ; iterFieldData++, iterFieldName++)
+    for (auto data : Data)
     {
         m_wstFields.push_back(*iterFieldName);
-        m_Data.push_back(*iterFieldData);
+        m_Data.push_back(data);
         m_Data.back()->IncreaseRef();
+        iterFieldName++;
     }
 #ifndef NDEBUG
     Inspector::addItem(this);
@@ -74,13 +73,15 @@ std::list<std::wstring> SingleStruct::getFields()
 
 int SingleStruct::getFieldIndex(const std::wstring& _field)
 {
+    int idx = 0;
     std::list<std::wstring>::iterator iterFieldNames = m_wstFields.begin();
-    for (int idx = 0; iterFieldNames != m_wstFields.end() ; iterFieldNames++, idx++)
+    for (auto name : m_wstFields)
     {
-        if (*iterFieldNames == _field)
+        if (name == _field)
         {
             return idx;
         }
+        idx++;
     }
 
     return -1;
@@ -196,11 +197,10 @@ std::vector<InternalType*> SingleStruct::extract(std::list<std::wstring> _stFiel
 String* SingleStruct::getFieldNames()
 {
     String* pOut = new String((int)m_wstFields.size(), 1);
-    std::list<std::wstring>::iterator iterFieldNames = m_wstFields.begin();
-
-    for (int i = 0 ; iterFieldNames != m_wstFields.end() ; iterFieldNames++, i++)
+    int i = 0;
+    for (auto name : m_wstFields)
     {
-        pOut->set(i, (*iterFieldNames).c_str());
+        pOut->set(i++, name.c_str());
     }
     return pOut;
 }
index 0799e76..0b732aa 100644 (file)
@@ -310,7 +310,7 @@ Sparse::Sparse(Double SPARSE_CONST& src)
         p[i + size] = (double)(i / row) + 1;
     }
     create2(src.getRows(), src.getCols(), src, *idx);
-    delete idx;
+    idx->killMe();
 }
 
 Sparse::Sparse(Double SPARSE_CONST& src, Double SPARSE_CONST& idx)
@@ -1568,6 +1568,8 @@ InternalType* Sparse::extract(typed_list* _pArgs)
         }
         else
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //free pArg content
             cleanIndexesArguments(_pArgs, &pArg);
             return NULL;
@@ -1620,6 +1622,8 @@ InternalType* Sparse::extract(typed_list* _pArgs)
         }
         else
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //free pArg content
             cleanIndexesArguments(_pArgs, &pArg);
             return NULL;
@@ -1628,6 +1632,8 @@ InternalType* Sparse::extract(typed_list* _pArgs)
 
     pOut->finalize();
 
+    delete[] piMaxDim;
+    delete[] piCountDim;
     //free pArg content
     cleanIndexesArguments(_pArgs, &pArg);
 
@@ -2194,6 +2200,7 @@ SparseBool::SparseBool(Bool SPARSE_CONST& src)
         p[i + size] = (double)(i / row) + 1;
     }
     create2(src.getRows(), src.getCols(), src, *idx);
+    idx->killMe();
 }
 /* @param src : Bool matrix to copy into a new sparse matrix
 @param idx : Double matrix to use as indexes to get values from the src
@@ -2273,6 +2280,11 @@ void SparseBool::create2(int rows, int cols, Bool SPARSE_CONST& src, Double SPAR
     finalize();
 }
 
+SparseBool::~SparseBool()
+{
+    delete matrixBool;
+}
+
 bool SparseBool::toString(std::wostringstream& ostr) const
 {
     ostr << ::toString(*matrixBool, 0);
@@ -3007,11 +3019,15 @@ InternalType* SparseBool::extract(typed_list* _pArgs)
         cleanIndexesArguments(_pArgs, &pArg);
         if (_pArgs->size() == 0)
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //a()
             return this;
         }
         else
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //a([])
             return Double::Empty();
         }
@@ -3064,6 +3080,8 @@ InternalType* SparseBool::extract(typed_list* _pArgs)
         }
         else
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //free pArg content
             cleanIndexesArguments(_pArgs, &pArg);
             return NULL;
@@ -3106,6 +3124,8 @@ InternalType* SparseBool::extract(typed_list* _pArgs)
         }
         else
         {
+            delete[] piMaxDim;
+            delete[] piCountDim;
             //free pArg content
             cleanIndexesArguments(_pArgs, &pArg);
             return NULL;
@@ -3114,6 +3134,8 @@ InternalType* SparseBool::extract(typed_list* _pArgs)
 
     finalize();
 
+    delete[] piMaxDim;
+    delete[] piCountDim;
     //free pArg content
     cleanIndexesArguments(_pArgs, &pArg);
 
index e2f3188..af2a68b 100644 (file)
@@ -92,7 +92,7 @@ String::String(int _iRows, int _iCols, wchar_t const* const* _pstData)
     create(piDims, 2, &pwsData, NULL);
     for (int i = 0 ; i < m_iSize ; i++)
     {
-        set(i, os_wcsdup(_pstData[i]));
+        set(i, _pstData[i]);
     }
 #ifndef NDEBUG
     Inspector::addItem(this);
index 5780eae..f26678e 100644 (file)
@@ -69,7 +69,7 @@ Struct::~Struct()
 {
     if (isDeletable() == true)
     {
-        for (int i = 0 ; i < getSize() ; i++)
+        for (int i = 0 ; i < m_iSizeMax ; i++)
         {
             SingleStruct *pStr = m_pRealData[i];
             if (pStr)
index 5a9f1ab..024a699 100644 (file)
@@ -315,15 +315,15 @@ bool TList::toString(std::wostringstream& ostr)
         wchar_t* wcsVarName = os_wcsdup(ostr.str().c_str());
         int iPosition = 1;
         const wchar_t * wcsDesc[7] = {L"  (state-space system:)", L"= A matrix =", L"= B matrix =", L"= C matrix =", L"= D matrix =", L"= X0 (initial state) =", L"= Time domain ="};
-        std::vector<InternalType *>::iterator itValues;
-        for (itValues = m_plData->begin() ; itValues != m_plData->end() ; ++itValues, ++iPosition)
+        for (auto val : *m_plData)
         {
             std::wostringstream nextVarName;
             ostr.str(L"");
             nextVarName << " " << wcsVarName << L"(" << iPosition << L")";
             ostr << std::endl << nextVarName.str() << wcsDesc[iPosition - 1] << std::endl << std::endl;
             scilabWriteW(ostr.str().c_str());
-            VariableToString(*itValues, nextVarName.str().c_str());
+            VariableToString(val, nextVarName.str().c_str());
+            iPosition++;
         }
         ostr.str(L"");
         free(wcsVarName);
index 262f9d6..008ba63 100644 (file)
@@ -23,21 +23,6 @@ extern "C"
 #include "localization.h"
 #include "charEncoding.h"
 }
-
-
-int mint(int *tab, int length)
-{
-    int ret  = *tab;
-    for (int i = 1; i < length ; i++)
-    {
-        if (ret > tab[i])
-        {
-            ret = tab[i];
-        }
-    }
-    return ret;
-}
-
 /*--------------------------------------------------------------------------*/
 Function::ReturnValue sci_eye(types::typed_list &in, int _iRetCount, types::typed_list &out)
 {
index 798e823..24537ff 100644 (file)
@@ -70,6 +70,7 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
     {
         if (in[1]->isDouble() == false)
         {
+            pGTOut->killMe();
             Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "matrix", 2);
             return types::Function::Error;
         }
@@ -78,6 +79,7 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
 
         if (pDblNewSize->isComplex())
         {
+            pGTOut->killMe();
             Scierror(999, _("%s: Wrong type for input argument #%d : A real matrix expected.\n"), "matrix", 2);
             return types::Function::Error;
         }
@@ -96,12 +98,14 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
                 }
                 else
                 {
+                    pGTOut->killMe();
                     Scierror(999, _("%s: Wrong value for input argument #%d : Only one value can be equal to %d.\n"), "matrix", 2, -1);
                     return types::Function::Error;
                 }
             }
             else if (piSizes[i] < -1)
             {
+                pGTOut->killMe();
                 Scierror(999, _("%s: Wrong value for input argument #%d : At most %d expected.\n"), "matrix", 2, -1);
                 return types::Function::Error;
             }
@@ -113,12 +117,13 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
     }
     else
     {
-        iDims = in.size() - 1;
+        iDims = static_cast<int>(in.size()) - 1;
         piSizes = new int[iDims];
         for (int i = 1; i < in.size(); i++)
         {
             if (in[i]->isDouble() == false)
             {
+                pGTOut->killMe();
                 Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "matrix", i + 1);
                 return types::Function::Error;
             }
@@ -127,6 +132,7 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
 
             if (pDblNewSize->isComplex() || pDblNewSize->isScalar() == false)
             {
+                pGTOut->killMe();
                 Scierror(999, _("%s: Wrong type for input argument #%d : A real scalar expected.\n"), "matrix", i + 1);
                 return types::Function::Error;
             }
@@ -140,12 +146,14 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
                 }
                 else
                 {
+                    pGTOut->killMe();
                     Scierror(999, _("%s: Wrong value for input argument #%d : Only one value can be equal to %d.\n"), "matrix", i + 1, -1);
                     return types::Function::Error;
                 }
             }
             else if (piSizes[i - 1] < -1)
             {
+                pGTOut->killMe();
                 Scierror(999, _("%s: Wrong value for input argument #%d : At most %d expected.\n"), "matrix", i + 1, -1);
                 return types::Function::Error;
             }
@@ -163,6 +171,7 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
 
     if (pGTOut->isSparse() && iDims > 2)
     {
+        pGTOut->killMe();
         Scierror(999, _("%s: Wrong value for input argument(s) : Sparse matrix cannot be reshaped beyond %d dimensions.\n"), "matrix", 2);
         return types::Function::Error;
     }
@@ -171,6 +180,7 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
 
     if (bOk == false)
     {
+        pGTOut->killMe();
         Scierror(999, _("%s: Input and output matrices must have the same number of elements.\n"), "matrix");
         return types::Function::Error;
     }
index 7e44bba..637cafb 100644 (file)
@@ -28,7 +28,7 @@ extern "C"
 /*--------------------------------------------------------------------------*/
 types::Function::ReturnValue sci_MinMax(types::typed_list &in, int _iRetCount, types::typed_list &out, const char* fname)
 {
-    int iCountElem   = in.size();
+    int iCountElem   = static_cast<int>(in.size());
     int iDims        = 0;
     int* piDimsArray = NULL;
     int iOrientation = 0;
index 7204b61..ebe81d4 100644 (file)
@@ -50,10 +50,12 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
         return types::Function::Error;
     }
 
+    bool isNotDouble = true;
     /***** get data *****/
     if (in[0]->isDouble()) // double
     {
         pDblIn = in[0]->getAs<types::Double>();
+        isNotDouble = false;
     }
     else if (in[0]->isBool()) // bool
     {
@@ -156,6 +158,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
 
             if (pDbl->isScalar() == false)
             {
+                if (isNotDouble && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "prod", 2);
                 return types::Function::Error;
             }
@@ -164,6 +171,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
 
             if (iOrientation <= 0)
             {
+                if (isNotDouble && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "prod", 2);
                 return types::Function::Error;
             }
@@ -174,6 +186,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
 
             if (pStr->isScalar() == false)
             {
+                if (isNotDouble && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 2);
                 return types::Function::Error;
             }
@@ -238,12 +255,22 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
                     pstrExpected = "\"*\",\"r\",\"c\",\"m\"";
                 }
 
+                if (isNotDouble && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "prod", 2, pstrExpected);
                 return types::Function::Error;
             }
         }
         else
         {
+            if (isNotDouble && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix or a string expected.\n"), "prod", 2);
             return types::Function::Error;
         }
@@ -253,6 +280,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
     {
         if (in[2]->isString() == false)
         {
+            if (isNotDouble && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "prod", 3);
             return types::Function::Error;
         }
@@ -261,6 +293,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
 
         if (pStr->isScalar() == false)
         {
+            if (isNotDouble && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "prod", 3);
             return types::Function::Error;
         }
@@ -277,6 +314,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
+            if (isNotDouble && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong value for input argument #%d: %s or %s expected.\n"), "prod", 3, "\"native\"", "\"double\"");
             return types::Function::Error;
         }
@@ -297,7 +339,7 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
                 out.push_back(types::Double::Empty());
             }
 
-            if (in[0]->isDouble() == false)
+            if (isNotDouble)
             {
                 delete pDblIn;
                 pDblIn = NULL;
@@ -308,19 +350,19 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
 
         if (iOrientation > pDblIn->getDims())
         {
-            if (in[0]->isDouble())
+            if (isNotDouble)
             {
-                pDblOut = pDblIn->clone()->getAs<types::Double>();
+                pDblOut = pDblIn;
             }
             else
             {
-                pDblOut = pDblIn;
+                pDblOut = pDblIn->clone()->getAs<types::Double>();
             }
         }
         else
         {
             pDblOut = prod(pDblIn, iOrientation);
-            if (in[0]->isDouble() == false)
+            if (isNotDouble)
             {
                 delete pDblIn;
                 pDblIn = NULL;
@@ -341,7 +383,7 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
     }
 
     /***** set result *****/
-    if ((iOuttype == 1) && (in[0]->isDouble() == false))
+    if ((iOuttype == 1) && isNotDouble)
     {
         if (in[0]->isBool())
         {
@@ -428,6 +470,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
             }
             out.push_back(pIOut);
         }
+
+        if (pDblOut)
+        {
+            pDblOut->killMe();
+        }
     }
     else
     {
index d826a0e..59258ce 100644 (file)
@@ -51,10 +51,12 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
         return types::Function::Error;
     }
 
+    bool isCopy = true;
     /***** get data *****/
     if (in[0]->isDouble()) // double
     {
         pDblIn = in[0]->getAs<types::Double>();
+        isCopy = false;
     }
     else if (in[0]->isBool()) // bool
     {
@@ -146,7 +148,14 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
     {
         ast::ExecVisitor exec;
         std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sum";
-        return Overload::call(wstFuncName, in, _iRetCount, out, &exec);
+        types::Function::ReturnValue ret = Overload::call(wstFuncName, in, _iRetCount, out, &exec);
+
+        if (isCopy && pDblIn)
+        {
+            pDblIn->killMe();
+        }
+
+        return ret;
     }
 
     if (in.size() >= 2)
@@ -157,6 +166,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
 
             if (pDbl->isScalar() == false)
             {
+                if (isCopy && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "sum", 2);
                 return types::Function::Error;
             }
@@ -165,6 +179,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
 
             if (iOrientation <= 0)
             {
+                if (isCopy && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: A positive scalar expected.\n"), "sum", 2);
                 return types::Function::Error;
             }
@@ -175,6 +194,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
 
             if (pStr->isScalar() == false)
             {
+                if (isCopy && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "sum", 2);
                 return types::Function::Error;
             }
@@ -239,12 +263,22 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
                     pstrExpected = "\"*\",\"r\",\"c\",\"m\"";
                 }
 
+                if (isCopy && pDblIn)
+                {
+                    pDblIn->killMe();
+                }
+
                 Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"), "sum", 2, pstrExpected);
                 return types::Function::Error;
             }
         }
         else
         {
+            if (isCopy && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong type for input argument #%d: A real matrix or a string expected.\n"), "sum", 2);
             return types::Function::Error;
         }
@@ -254,6 +288,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
     {
         if (in[2]->isString() == false)
         {
+            if (isCopy && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), "sum", 3);
             return types::Function::Error;
         }
@@ -262,6 +301,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
 
         if (pStr->isScalar() == false)
         {
+            if (isCopy && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong size for input argument #%d: A scalar string expected.\n"), "sum", 3);
             return types::Function::Error;
         }
@@ -278,6 +322,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
         }
         else
         {
+            if (isCopy && pDblIn)
+            {
+                pDblIn->killMe();
+            }
+
             Scierror(999, _("%s: Wrong value for input argument #%d: %s or %s expected.\n"), "sum", 3, "\"native\"", "\"double\"");
             return types::Function::Error;
         }
@@ -297,24 +346,17 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
                 out.push_back(Double::Empty());
             }
 
-            if (in[0]->isDouble() == false)
+            if (isCopy)
             {
-                delete pDblIn;
-                pDblIn = NULL;
+                pDblIn->killMe();
             }
 
+
             return types::Function::OK;
         }
         else if (iOrientation > pDblIn->getDims())
         {
-            if (in[0]->isDouble())
-            {
-                pDblOut = pDblIn->clone()->getAs<types::Double>();
-            }
-            else
-            {
-                pDblOut = pDblIn;
-            }
+            pDblOut = pDblIn;
 
             if (in[0]->isBool() == false)
             {
@@ -324,10 +366,9 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
         else
         {
             pDblOut = sum(pDblIn, iOrientation);
-            if (in[0]->isDouble() == false)
+            if (isCopy)
             {
-                delete pDblIn;
-                pDblIn = NULL;
+                pDblIn->killMe();
             }
         }
     }
@@ -336,7 +377,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
         iOuttype = 1;
         if (iOrientation > pPolyIn->getDims())
         {
-            pPolyOut = pPolyIn->clone()->getAs<types::Polynom>();
+            pPolyOut = pPolyIn->getAs<types::Polynom>();
         }
         else
         {
@@ -345,7 +386,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
     }
 
     /***** set result *****/
-    if ((iOuttype == 1) && (in[0]->isDouble() == false))
+    if ((iOuttype == 1) && isCopy)
     {
         if (in[0]->isBool())
         {
@@ -354,6 +395,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pDblOut->get(i) ? pBOut->set(i, 1) : pBOut->set(i, 0);
             }
+
             out.push_back(pBOut);
         }
         else if (in[0]->isPoly())
@@ -367,6 +409,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<char>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isInt16())
@@ -376,6 +419,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<short int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isInt32())
@@ -385,6 +429,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isInt64())
@@ -394,6 +439,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<long long int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isUInt8())
@@ -403,6 +449,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<unsigned char>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isUInt16())
@@ -412,6 +459,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<unsigned short int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isUInt32())
@@ -421,6 +469,7 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<unsigned int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
         else if (in[0]->isUInt64())
@@ -430,8 +479,14 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             {
                 pIOut->set(i, static_cast<unsigned long long int>(pDblOut->get(i)));
             }
+
             out.push_back(pIOut);
         }
+
+        if (pDblOut)
+        {
+            pDblOut->killMe();
+        }
     }
     else
     {
index f4e7e6f..77c1982 100644 (file)
@@ -354,14 +354,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, std::wstring ws
                 {
                     pOut = pIn->clone()->getAs<types::Double>();
                     double* pdblOutR = pOut->get();
-                    if (wstrWay == L"i")
-                    {
-                        std::sort(pdblOutR, pdblOutR + pOut->getSize(), (*pFuncWayBasic));
-                    }
-                    else // strWay == L"d"
-                    {
-                        std::sort(pdblOutR, pdblOutR + pOut->getSize(), (*pFuncWayBasic));
-                    }
+                    std::sort(pdblOutR, pdblOutR + pOut->getSize(), (*pFuncWayBasic));
                 }
                 else if (wstrProcess == L"c")
                 {
@@ -371,20 +364,9 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, std::wstring ws
                     // transpose input in output
                     vTransposeRealMatrix(pdblInR, pIn->getRows(), pIn->getCols(), pdblOutR);
 
-                    // sort output
-                    if (wstrWay == L"i")
-                    {
-                        for (int i = 0; i < iTimes; i++)
-                        {
-                            std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
-                        }
-                    }
-                    else // strWay == L"d"
+                    for (int i = 0; i < iTimes; i++)
                     {
-                        for (int i = 0; i < iTimes; i++)
-                        {
-                            std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
-                        }
+                        std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
                     }
 
                     // transpose output
@@ -399,19 +381,9 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, std::wstring ws
                     pOut = pIn->clone()->getAs<types::Double>();
                     double* pdblOutR = pOut->get();
 
-                    if (wstrWay == L"i")
-                    {
-                        for (int i = 0; i < iTimes; i++)
-                        {
-                            std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
-                        }
-                    }
-                    else // strWay == L"d"
+                    for (int i = 0; i < iTimes; i++)
                     {
-                        for (int i = 0; i < iTimes; i++)
-                        {
-                            std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
-                        }
+                        std::sort(pdblOutR + (iItem * i), pdblOutR + (iItem * (i + 1)), (*pFuncWayBasic));
                     }
                 }
             }
@@ -469,7 +441,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, std::wstring ws
 /*--------------------------- String ---------------------------------------*/
 types::String* gsort(types::String* pIn, types::Double* pDblInd, std::wstring wstrWay, std::wstring wstrProcess)
 {
-    types::String* pOut = new types::String(pIn->getDims(), pIn->getDimsArray());
+    types::String* pOut = nullptr;
 
     int iTimes      = 1;
     int iItem       = 0;
@@ -529,6 +501,8 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, std::wstring ws
     {
         if (pDblInd)
         {
+            pOut = new types::String(pIn->getDims(), pIn->getDimsArray());
+
             std::vector<std::pair<int, wchar_t*> > V;
             std::vector<std::pair<int, wchar_t*> >::iterator it;
 
@@ -634,6 +608,7 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, std::wstring ws
     }
     else// wstrProcess == L"lr" and wstrProcess == L"lc"
     {
+        pOut = new types::String(pIn->getDims(), pIn->getDimsArray());
         std::vector<std::pair<int, std::pair<wchar_t**, wchar_t**> > > V;
         std::vector<std::pair<int, std::pair<wchar_t**, wchar_t**> > >::iterator it;
 
index 363653f..80b9aea 100644 (file)
@@ -256,6 +256,7 @@ types::Polynom* prod(types::Polynom* pIn, int iOrientation)
             int iIndex = pDblRanksOut->getIndex(piIndex);
             pdblOut[iIndex] += pdblIn[i];
         }
+        pDblRanks->killMe();
 
         // move output ranks from types::Double to int*
         int* piRankMax = new int[pDblRanksOut->getSize()];
@@ -266,6 +267,7 @@ types::Polynom* prod(types::Polynom* pIn, int iOrientation)
             iMaxOutputRank = std::max(iMaxOutputRank, piRankMax[i]);
         }
 
+        pDblRanksOut->killMe();
         // create the outpout polynom
         pOut = new types::Polynom(pIn->getVariableName(), iDims, piDims, piRankMax);
         pOut->setComplex(pIn->isComplex());
index 5077f50..9bd1df4 100644 (file)
@@ -151,6 +151,8 @@ types::Polynom* sum(types::Polynom* pIn, int iOrientation)
                 }
             }
         }
+
+        delete[] piRanks;
     }
     else // sum on one dimension
     {
@@ -194,6 +196,8 @@ types::Polynom* sum(types::Polynom* pIn, int iOrientation)
             int iIndex = pDblRanksOut->getIndex(piIndex);
             pdblOut[iIndex] = std::max(pdblOut[iIndex], pdblIn[i]);
         }
+        
+        pDblRanks->killMe();
 
         // move output ranks from types::Double to int*
         int* piRankMax = new int[pDblRanksOut->getSize()];
@@ -202,8 +206,11 @@ types::Polynom* sum(types::Polynom* pIn, int iOrientation)
             piRankMax[i] = static_cast<int>(pdblOut[i]);
         }
 
+        pDblRanksOut->killMe();
+
         // create the outpout polynom
         pOut = new types::Polynom(pIn->getVariableName(), iDims, piDims, piRankMax);
+        delete[] piRankMax;
         pOut->setComplex(pIn->isComplex());
         pOut->setZeros();
 
index 68b351d..617f761 100644 (file)
@@ -51,22 +51,22 @@ assert_checkerror("A = gsort(sp)", refMsg);
 //================================ Matrix of string case ===========================================
 N = 4;
 P = 20;
-a = int(10*rand(N,P,'u'));
+a = int(10*rand(N,P,"u"));
 //-----Global sort
-[a1,ind] = gsort(string(a),'g');
-[a2,ind2] = gsort(a,'g');
+[a1,ind] = gsort(string(a),"g");
+[a2,ind2] = gsort(a,"g");
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind),N,P)), %eps, [], %eps);
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //-- rows
-[a1,ind1]=gsort(string(a),'r');
-[a2,ind2]=gsort(a,'r');
+[a1,ind1]=gsort(string(a),"r");
+[a2,ind2]=gsort(a,"r");
 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //--columns
-[a1,ind1] = gsort(string(a),'c');
-[a2,ind2] = gsort(a,'c');
+[a1,ind1] = gsort(string(a),"c");
+[a2,ind2] = gsort(a,"c");
 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
@@ -77,10 +77,10 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = alr(perm,:);
-[a1,ind] = gsort(string(a),'lr');
-[a2,ind] = gsort(a,'lr') ;
+[a1,ind] = gsort(string(a),"lr");
+[a2,ind] = gsort(a,"lr") ;
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind,:),N1,P1)), %eps, [], %eps);
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
@@ -88,39 +88,39 @@ assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = alr(:,perm);
-[a1,ind] = gsort(string(a),'lc');
-[a2,ind] = gsort(a,'lc') ;
+[a1,ind] = gsort(string(a),"lc");
+[a2,ind] = gsort(a,"lc") ;
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //================================ Matrix of double case ===========================================
 N = 4;P = 20;Nrand = 100;
-a = matrix(grand(1,'prm',(1:N*P)'),N,P);
+a = matrix(grand(1,"prm",(1:N*P)'),N,P);
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
+[a1,ind]=gsort(a,"g");
 assert_checkalmostequal(norm(a1- matrix(N*P:-1:1,N,P)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 for i=1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
     assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkalmostequal(norm(a1- matrix(1:N*P,N,P)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 for i=1:100
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
     assert_checktrue(or(b1(1:$-1)-b1(2:$) <= 0));
 end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -128,12 +128,12 @@ end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 test = [];
 for i = 1:nc;
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -142,8 +142,8 @@ for i = 1:Nrand
     assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
 end
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -151,12 +151,12 @@ end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -164,12 +164,12 @@ end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
     test = [];
     for j = 1:nr
@@ -178,8 +178,8 @@ for i = 1:Nrand
     assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
 end
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -187,7 +187,7 @@ end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 //----sort the rows of a in lexicographic order
@@ -201,29 +201,29 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1, N1, 'u'));
+[ax,perm] = gsort(rand(1, N1, "u"));
 a = alr(perm,:);
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
     v = b1 * ((vmax + 1) ^ [P - 1 : -1 : 0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkalmostequal(norm(a1 - alr(N1:-1:1,:)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
-[a2,ind2] = gsort(a * [100;10;1],'g','i');
+[a2,ind2] = gsort(a * [100;10;1],"g","i");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
     v= b1*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -232,29 +232,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = alr(:,perm);
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
     v = ((vmax+1)^[N1-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkalmostequal(norm(a1 - alr(:,P1:-1:1)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(:,ind),N1,P1)), %eps, [], %eps);
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -264,27 +264,27 @@ a = [1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
     assert_checkequal(a(p(ind),:), b);
 end
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -292,42 +292,42 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 //================================ Matrix of int32 or uint32 case =======================================
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = int32(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int32(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int32(matrix(N * P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = int32(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int32(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, int32(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:100
-    b = int32(10*rand(N,P,'u'));
-    [b1,ind]=gsort(b,'g','i');
+    b = int32(10*rand(N,P,"u"));
+    [b1,ind]=gsort(b,"g","i");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -335,12 +335,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i =1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int32(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int32(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -349,8 +349,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -358,12 +358,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -371,12 +371,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int32(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int32(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
     test = [];
     for j = 1:nr
@@ -385,8 +385,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -394,7 +394,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -407,30 +407,30 @@ alr=[1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int32(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, int32(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int32(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int32(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int32(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -439,29 +439,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int32(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int32(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, int32(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -471,27 +471,27 @@ a = int32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
     assert_checkequal(a(p(ind),:), b);
 end
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -499,12 +499,12 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -513,30 +513,30 @@ assert_checkequal(a(ind,:), b);
 // Copyright Inria
 // test of gsort for int16 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = int16(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int16(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int16(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind]=gsort(b,'g');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind]=gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, int16(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:100
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkequal(b1, int16(matrix(b(ind),N,P)));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -544,12 +544,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checktrue(or( b1(2:$,:) - b1(1:$-1,:) <= 0));
     test = [];
     for j = 1:nc
@@ -558,8 +558,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -567,12 +567,12 @@ end
 assert_checkequal(a1, test);
 test =[];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c')   ;
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c")   ;
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -580,12 +580,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
     test = [];
     for j = 1:nr
@@ -594,8 +594,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -603,7 +603,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -616,30 +616,30 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int16(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, int16(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2]=gsort(a*[100;10;1],'g');
+[a2,ind2]=gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int16(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int16(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int16(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -648,29 +648,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int16(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int16(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, int16(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -680,27 +680,27 @@ a = int16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
     assert_checkequal(a(p(ind),:), b);
 end
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -708,12 +708,12 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -723,27 +723,27 @@ a = uint16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:), b);
 end
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -751,12 +751,12 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -764,30 +764,30 @@ assert_checkequal(a(ind,:), b);
 //================================ Matrix of int8 or uint8 case =======================================
 // test of gsort for int8 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = int8(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int8(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int8(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, int8(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -795,12 +795,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -809,8 +809,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -818,12 +818,12 @@ end
 assert_checkequal(a1, test);
 test =[];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, int8(test));
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -831,12 +831,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
     test = [];
     for j = 1:nr
@@ -845,8 +845,8 @@ for i = 1:Nrand
     assert_checkequal(b1, test);
 end
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -854,7 +854,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -867,30 +867,30 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int8(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, int8(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int8(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int8(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int8(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
+[a2,ind2]=gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -899,29 +899,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int8(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int8(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2]=gsort([100,10,1]*a,'g');
+[a2,ind2]=gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, int8(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
+[a2,ind2]=gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -931,27 +931,27 @@ a = int8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) <= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
     assert_checkequal(a(p(ind),:), b);
 end
-[b,ind]=gsort(a,'lr','d');
+[b,ind]=gsort(a,"lr","d");
 t=b(1:$-1,:)-b(2:$,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) <= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -959,35 +959,35 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = uint32(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint32(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint32(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = uint32(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint32(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint32(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc ;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -995,12 +995,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc ;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1008,12 +1008,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1021,12 +1021,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1034,7 +1034,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -1047,30 +1047,30 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint32(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint32(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2]=gsort(a*[100;10;1],'g');
+[a2,ind2]=gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint32(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint32(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint32(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
+[a2,ind2]=gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1079,29 +1079,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint32(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint32(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, uint32(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1111,27 +1111,27 @@ a = uint32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:),b);
 end
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -1139,36 +1139,36 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 // test of gsort for uuint16 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = uint16(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint16(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint16(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = uint16(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint16(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint16(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1176,12 +1176,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1189,12 +1189,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1202,12 +1202,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1215,7 +1215,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -1228,30 +1228,30 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint16(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint16(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a * [100;10;1],'g');
+[a2,ind2] = gsort(a * [100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint16(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint16(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint16(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a * [100;10;1],'g','i');
+[a2,ind2] = gsort(a * [100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1) * ((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1260,30 +1260,30 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint16(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint16(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1] * a,'g');
+[a2,ind2] = gsort([100,10,1] * a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N1-1:-1:0]) * double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, uint16(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 vmax = 4;
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1291,24 +1291,24 @@ end
 ////////////////////////////////////////////////////////////////////////
 // test of gsort for uint8 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
-a = uint8(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint8(matrix(grand(1,"prm",(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint8(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 for i = 1:Nrand
-    b = uint8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
 end
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint8(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1316,12 +1316,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1329,12 +1329,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr;
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1342,12 +1342,12 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1355,7 +1355,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order
@@ -1368,30 +1368,30 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint8(alr(perm,:));
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint8(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint8(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint8(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint8(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1400,29 +1400,29 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint8(alr(:,perm));
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint8(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, uint8(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1432,27 +1432,27 @@ a = uint8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:),b);
 end
-[b,ind]=gsort(a,'lr','d');
+[b,ind]=gsort(a,"lr","d");
 t=b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -1460,68 +1460,68 @@ for k = 1:30
 end
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 //testing gsort with Nan's
-b = gsort([1 2 %nan 3 4],'g','i');
+b = gsort([1 2 %nan 3 4],"g","i");
 assert_checkequal(b(1:4), (1:4));
 assert_checkequal(find(isnan(b)), 5);
-b = gsort([1 2 %nan 1 3 ],'g','i');
+b = gsort([1 2 %nan 1 3 ],"g","i");
 assert_checkequal(b(1:4), [1 1 2 3]);
 assert_checkequal(find(isnan(b)), 5);
-b = gsort([1 2 %nan 1 3 ],'g','d');
+b = gsort([1 2 %nan 1 3 ],"g","d");
 assert_checkequal(b(2:$), [3 2 1 1]);
 assert_checkequal(find(isnan(b)), 1);
-b = gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
+b = gsort([1 2 %nan 1 3 %nan 2 3],"g","d");
 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
 assert_checkequal(find(isnan(b)), [1 2]);
-b = gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
+b = gsort([1 2 %nan 1 3 %nan 2 3],"g","i");
 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
 assert_checkequal(find(isnan(b)), [7 8]);
 m = [1 2 %nan;1 3 %nan;1 2 3];
-b = gsort(m,'lr','i');
-assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%nan;1,3,%nan]');
-b = gsort(m,'lr','d');
-assert_checkequal(sci2exp(b,0), '[1,3,%nan;1,2,%nan;1,2,3]');
+b = gsort(m,"lr","i");
+assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%nan;1,3,%nan]");
+b = gsort(m,"lr","d");
+assert_checkequal(sci2exp(b,0), "[1,3,%nan;1,2,%nan;1,2,3]");
 m = m(:,[3 1 2]);
-b = gsort(m,'lc','i');
-assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,3,%nan;1,2,3]');
-b = gsort(m,'lc','d');
-assert_checkequal(sci2exp(b,0), '[%nan,2,1;%nan,3,1;3,2,1]');
+b = gsort(m,"lc","i");
+assert_checkequal(sci2exp(b,0), "[1,2,%nan;1,3,%nan;1,2,3]");
+b = gsort(m,"lc","d");
+assert_checkequal(sci2exp(b,0), "[%nan,2,1;%nan,3,1;3,2,1]");
 //testing gsort with Inf's
-b = gsort([1 2 %inf 3 4],'g','i');
+b = gsort([1 2 %inf 3 4],"g","i");
 assert_checkequal(b(1:4), (1:4));
 assert_checkequal(find(isinf(b)), 5);
-b=gsort([1 2 %inf 1 3 ],'g','i');
+b=gsort([1 2 %inf 1 3 ],"g","i");
 assert_checkequal(b(1:4), [1 1 2 3]);
 assert_checkequal(find(isinf(b)), 5);
-b=gsort([1 2 %inf 1 3 ],'g','d');
+b=gsort([1 2 %inf 1 3 ],"g","d");
 assert_checkequal(b(2:$), [3 2 1 1]);
 assert_checkequal(find(isinf(b)), 1);
-b=gsort([1 2 %inf 1 3 %inf 2 3],'g','d');
+b=gsort([1 2 %inf 1 3 %inf 2 3],"g","d");
 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
 assert_checkequal(find(isinf(b)), [1 2]);
-b=gsort([1 2 %inf 1 3 %inf 2 3],'g','i');
+b=gsort([1 2 %inf 1 3 %inf 2 3],"g","i");
 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
 assert_checkequal(find(isinf(b)), [7 8]);
 m = [1 2 %inf;1 3 %inf;1 2 3];
-b = gsort(m,'lr','i');
-assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%inf;1,3,%inf]');
-b = gsort(m,'lr','d');
-assert_checkequal(sci2exp(b,0), '[1,3,%inf;1,2,%inf;1,2,3]');
+b = gsort(m,"lr","i");
+assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%inf;1,3,%inf]");
+b = gsort(m,"lr","d");
+assert_checkequal(sci2exp(b,0), "[1,3,%inf;1,2,%inf;1,2,3]");
 m = m(:,[3 1 2]);
-b = gsort(m,'lc','i');
-assert_checkequal(sci2exp(b,0), '[1,2,%inf;1,3,%inf;1,2,3]');
-b = gsort(m,'lc','d');
-assert_checkequal(sci2exp(b,0), '[%inf,2,1;%inf,3,1;3,2,1]');
+b = gsort(m,"lc","i");
+assert_checkequal(sci2exp(b,0), "[1,2,%inf;1,3,%inf;1,2,3]");
+b = gsort(m,"lc","d");
+assert_checkequal(sci2exp(b,0), "[%inf,2,1;%inf,3,1;3,2,1]");
 //gsort
 a = [5 1 3 2 4];
 assert_checkequal(gsort(a), [5 4 3 2 1]);
@@ -1533,8 +1533,8 @@ assert_checkequal(s, [5 4 3 2 1]);
 assert_checkequal(k, [1 5 3 4 2]);
 assert_checkequal(s, [5 4 3 2 1]);
 a = string([5 1 3 2 4]);
-assert_checkequal(gsort(a,'g','i'), string(1:5));
-[s,k]=gsort(a,'g','i');
+assert_checkequal(gsort(a,"g","i"), string(1:5));
+[s,k]=gsort(a,"g","i");
 assert_checkequal(k, [2 4 3 5 1]);
 assert_checkequal(s, string(1:5));
 a = [];
@@ -1546,155 +1546,155 @@ assert_checkequal(k, []);
 b = [5 1 3 2 4;6 1 2 4 1];
 B = sparse(b);
 // opts = 'r' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'r','d');
-[s1,k1] = gsort(B(:),'r','d');
+[s,k] = gsort(b(:),"r","d");
+[s1,k1] = gsort(B(:),"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:),'r','i');
-[s1,k1] = gsort(B(:),'r','i');
+[s,k] = gsort(b(:),"r","i");
+[s1,k1] = gsort(B(:),"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','r','d');
-[s1,k1] = gsort(B(:)','r','d');
+[s,k] = gsort(b(:)',"r","d");
+[s1,k1] = gsort(B(:)',"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','r','i');
-[s1,k1] = gsort(B(:)','r','i');
+[s,k] = gsort(b(:)',"r","i");
+[s1,k1] = gsort(B(:)',"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 // opts = 'c' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'c','d');
-[s1,k1] = gsort(B(:),'c','d');
+[s,k] = gsort(b(:),"c","d");
+[s1,k1] = gsort(B(:),"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:),'c','i');
-[s1,k1] = gsort(B(:),'c','i');
+[s,k] = gsort(b(:),"c","i");
+[s1,k1] = gsort(B(:),"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','c','d');
-[s1,k1] = gsort(B(:)','c','d');
+[s,k] = gsort(b(:)',"c","d");
+[s1,k1] = gsort(B(:)',"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','c','i');
-[s1,k1] = gsort(B(:)','c','i');
+[s,k] = gsort(b(:)',"c","i");
+[s1,k1] = gsort(B(:)',"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 // opts = 'g' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'g','d');
-[s1,k1] = gsort(B(:),'g','d');
+[s,k] = gsort(b(:),"g","d");
+[s1,k1] = gsort(B(:),"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:),'g','i');
-[s1,k1] = gsort(B(:),'g','i');
+[s,k] = gsort(b(:),"g","i");
+[s1,k1] = gsort(B(:),"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','g','d');
-[s1,k1] = gsort(B(:)','g','d');
+[s,k] = gsort(b(:)',"g","d");
+[s1,k1] = gsort(B(:)',"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','g','i');
-[s1,k1] = gsort(B(:)','g','i');
+[s,k] = gsort(b(:)',"g","i");
+[s1,k1] = gsort(B(:)',"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 // opts = 'lr' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'lr','d');
-[s1,k1] = gsort(B(:),'lr','d');
+[s,k] = gsort(b(:),"lr","d");
+[s1,k1] = gsort(B(:),"lr","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:),'lr','i');
-[s1,k1] = gsort(B(:),'lr','i');
+[s,k] = gsort(b(:),"lr","i");
+[s1,k1] = gsort(B(:),"lr","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','lr','d');
-[s1,k1] = gsort(B(:)','lr','d');
+[s,k] = gsort(b(:)',"lr","d");
+[s1,k1] = gsort(B(:)',"lr","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','lr','i');
-[s1,k1] = gsort(B(:)','lr','i');
+[s,k] = gsort(b(:)',"lr","i");
+[s1,k1] = gsort(B(:)',"lr","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 // opts = 'lc' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'lc','d');
-[s1,k1] = gsort(B(:),'lc','d');
+[s,k] = gsort(b(:),"lc","d");
+[s1,k1] = gsort(B(:),"lc","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:),'lc','i');
-[s1,k1] = gsort(B(:),'lc','i');
+[s,k] = gsort(b(:),"lc","i");
+[s1,k1] = gsort(B(:),"lc","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','lc','d');
-[s1,k1] = gsort(B(:)','lc','d');
+[s,k] = gsort(b(:)',"lc","d");
+[s1,k1] = gsort(B(:)',"lc","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(b(:)','lc','i');
-[s1,k1] = gsort(B(:)','lc','i');
+[s,k] = gsort(b(:)',"lc","i");
+[s1,k1] = gsort(B(:)',"lc","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 // gsort with complex sparses :
 A = [1 -%i;%i 0];
 A1 = sparse(A);
-c = gsort(A(:),'g','d');
-d = full(gsort(A1(:),'g','d'));
+c = gsort(A(:),"g","d");
+d = full(gsort(A1(:),"g","d"));
 assert_checkequal(c,d);
-c = gsort(A(:),'g','i');
-d = full(gsort(A1(:),'g','i'));
+c = gsort(A(:),"g","i");
+d = full(gsort(A1(:),"g","i"));
 assert_checkequal(c,d);
-c = gsort(A(:),'r','d');
-d = full(gsort(A1(:),'r','d'));
+c = gsort(A(:),"r","d");
+d = full(gsort(A1(:),"r","d"));
 assert_checkequal(c,d);
-c = gsort(A(:),'r','i');
-d = full(gsort(A1(:),'r','i'));
+c = gsort(A(:),"r","i");
+d = full(gsort(A1(:),"r","i"));
 assert_checkequal(c,d);
-c = gsort(A(:),'c','d');
-d = full(gsort(A1(:),'c','d'));
+c = gsort(A(:),"c","d");
+d = full(gsort(A1(:),"c","d"));
 assert_checkequal(c,d);
-c = gsort(A(:),'c','i');
-d = full(gsort(A1(:),'c','i'));
+c = gsort(A(:),"c","i");
+d = full(gsort(A1(:),"c","i"));
 assert_checkequal(c,d);
 B = [1 1+%i 4; -2*%i 3 3-%i];
 B1 = sparse(B);
-c = gsort(B(:),'g','d');
-d = full(gsort(B1(:),'g','d'));
+c = gsort(B(:),"g","d");
+d = full(gsort(B1(:),"g","d"));
 assert_checkequal(c,d);
-c = gsort(B(:),'g','i');
-d = full(gsort(B1(:),'g','i'));
+c = gsort(B(:),"g","i");
+d = full(gsort(B1(:),"g","i"));
 assert_checkequal(c,d);
-c = gsort(B(:),'r','d');
-d = full(gsort(B1(:),'r','d'));
+c = gsort(B(:),"r","d");
+d = full(gsort(B1(:),"r","d"));
 assert_checkequal(c,d);
-c = gsort(B(:),'r','i');
-d = full(gsort(B1(:),'r','i'));
+c = gsort(B(:),"r","i");
+d = full(gsort(B1(:),"r","i"));
 assert_checkequal(c,d);
-c = gsort(B(:),'c','d');
-d = full(gsort(B1(:),'c','d'));
+c = gsort(B(:),"c","d");
+d = full(gsort(B1(:),"c","d"));
 assert_checkequal(c,d);
-c = gsort(B(:),'c','i');
-d = full(gsort(B1(:),'c','i'));
+c = gsort(B(:),"c","i");
+d = full(gsort(B1(:),"c","i"));
 assert_checkequal(c,d);
 C = [-%i 3*%i;4 9;-2*%i 7];
 C1 = sparse(C);
-[s,k] = gsort(C(:),'g','d');
-[s1,k1] = gsort(C1(:),'g','d');
+[s,k] = gsort(C(:),"g","d");
+[s1,k1] = gsort(C1(:),"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(C(:),'g','i');
-[s1,k1] = gsort(C1(:),'g','i');
+[s,k] = gsort(C(:),"g","i");
+[s1,k1] = gsort(C1(:),"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(C(:),'r','d');
-[s1,k1] = gsort(C1(:),'r','d');
+[s,k] = gsort(C(:),"r","d");
+[s1,k1] = gsort(C1(:),"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(C(:),'r','i');
-[s1,k1] = gsort(C1(:),'r','i');
+[s,k] = gsort(C(:),"r","i");
+[s1,k1] = gsort(C1(:),"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(C(:),'c','d');
-[s1,k1] = gsort(C1(:),'c','d');
+[s,k] = gsort(C(:),"c","d");
+[s1,k1] = gsort(C1(:),"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
-[s,k] = gsort(C(:),'c','i');
-[s1,k1] = gsort(C1(:),'c','i');
+[s,k] = gsort(C(:),"c","i");
+[s1,k1] = gsort(C1(:),"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 //================================ hypermatrix ================================================
@@ -1708,10 +1708,10 @@ assert_checkequal(hind(:), ind);
 hs = gsort(A);
 assert_checkequal(hs(:), s);
 // 'c' 'r' 'lc' 'lr'
-[hsc hindc]   = gsort(A, 'c');
-[hsr hindr]   = gsort(A, 'r');
-[hslc hindlc] = gsort(A, 'lc');
-[hslr hindlr] = gsort(A, 'lr');
+[hsc hindc]   = gsort(A, "c");
+[hsr hindr]   = gsort(A, "r");
+[hslc hindlc] = gsort(A, "lc");
+[hslr hindlr] = gsort(A, "lr");
 a       = matrix(A, 6, 4, 16); // 2 * 8 = 16
 sc      = zeros(a);
 indc    = zeros(a);
@@ -1722,10 +1722,10 @@ indlc   = zeros(1, 4, 16);
 slr     = zeros(a);
 indlr   = zeros(6, 1, 16);
 for i = 1:16
-    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),'c');
-    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),'r');
-    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),'lc');
-    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),'lr');
+    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),"c");
+    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),"r");
+    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),"lc");
+    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),"lr");
 end
 sc      = matrix(sc, 6, 4, 2, 8);
 indc    = matrix(indc, 6, 4, 2, 8);
@@ -1744,27 +1744,27 @@ assert_checkequal(hindlc, indlc);
 assert_checkequal(hslr, slr);
 assert_checkequal(hindlr, indlr);
 // whitout indices
-hsc  = gsort(A, 'c');
-hsr  = gsort(A, 'r');
-hslc = gsort(A, 'lc');
-hslr = gsort(A, 'lr');
+hsc  = gsort(A, "c");
+hsr  = gsort(A, "r");
+hslc = gsort(A, "lc");
+hslr = gsort(A, "lr");
 assert_checkequal(hsc, sc);
 assert_checkequal(hsr, sr);
 assert_checkequal(hslc, slc);
 assert_checkequal(hslr, slr);
 // ----- increasing -----
 // 'g'
-[hs hind]   = gsort(A, 'g', 'i');
-[s ind]     = gsort(A(:), 'g', 'i');
+[hs hind]   = gsort(A, "g", "i");
+[s ind]     = gsort(A(:), "g", "i");
 assert_checkequal(hs(:), s);
 assert_checkequal(hind(:), ind);
-hs = gsort(A, 'g', 'i');
+hs = gsort(A, "g", "i");
 assert_checkequal(hs(:), s);
 // 'c' 'r' 'lc' 'lr'
-[hsc hindc]   = gsort(A, 'c', 'i');
-[hsr hindr]   = gsort(A, 'r', 'i');
-[hslc hindlc] = gsort(A, 'lc', 'i');
-[hslr hindlr] = gsort(A, 'lr', 'i');
+[hsc hindc]   = gsort(A, "c", "i");
+[hsr hindr]   = gsort(A, "r", "i");
+[hslc hindlc] = gsort(A, "lc", "i");
+[hslr hindlr] = gsort(A, "lr", "i");
 a       = matrix(A, 6, 4, 16); // 2 * 8 = 16
 sc      = zeros(a);
 indc    = zeros(a);
@@ -1775,10 +1775,10 @@ indlc   = zeros(1, 4, 16);
 slr     = zeros(a);
 indlr   = zeros(6, 1, 16);
 for i = 1:16
-    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),'c', 'i');
-    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),'r', 'i');
-    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),'lc', 'i');
-    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),'lr', 'i');
+    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),"c", "i");
+    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),"r", "i");
+    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),"lc", "i");
+    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),"lr", "i");
 end
 sc      = matrix(sc, 6, 4, 2, 8);
 indc    = matrix(indc, 6, 4, 2, 8);
@@ -1797,10 +1797,10 @@ assert_checkequal(hindlc, indlc);
 assert_checkequal(hslr, slr);
 assert_checkequal(hindlr, indlr);
 // whitout indices
-hsc  = gsort(A, 'c', 'i');
-hsr  = gsort(A, 'r', 'i');
-hslc = gsort(A, 'lc', 'i');
-hslr = gsort(A, 'lr', 'i');
+hsc  = gsort(A, "c", "i");
+hsr  = gsort(A, "r", "i");
+hslc = gsort(A, "lc", "i");
+hslr = gsort(A, "lr", "i");
 assert_checkequal(hsc, sc);
 assert_checkequal(hsr, sr);
 assert_checkequal(hslc, slc);
index a2eae92..fc32e57 100644 (file)
@@ -63,20 +63,20 @@ assert_checkerror("A = gsort(sp)", refMsg);
 //================================ Matrix of string case ===========================================
 N = 4;
 P = 20;
-a = int(10*rand(N,P,'u'));
+a = int(10*rand(N,P,"u"));
 
 //-----Global sort
 
-[a1,ind] = gsort(string(a),'g');
-[a2,ind2] = gsort(a,'g');
+[a1,ind] = gsort(string(a),"g");
+[a2,ind2] = gsort(a,"g");
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind),N,P)), %eps, [], %eps);
 
 // a or string(a) are in the same order in the previous example
 assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 
 //-- rows
-[a1,ind1]=gsort(string(a),'r');
-[a2,ind2]=gsort(a,'r');
+[a1,ind1]=gsort(string(a),"r");
+[a2,ind2]=gsort(a,"r");
 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
 
 // a or string(a) are in the same order in the previous example
@@ -84,8 +84,8 @@ assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 
 
 //--columns
-[a1,ind1] = gsort(string(a),'c');
-[a2,ind2] = gsort(a,'c');
+[a1,ind1] = gsort(string(a),"c");
+[a2,ind2] = gsort(a,"c");
 assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
 
 // a or string(a) are in the same order in the previous example
@@ -99,10 +99,10 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = alr(perm,:);
-[a1,ind] = gsort(string(a),'lr');
-[a2,ind] = gsort(a,'lr') ;
+[a1,ind] = gsort(string(a),"lr");
+[a2,ind] = gsort(a,"lr") ;
 
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind,:),N1,P1)), %eps, [], %eps);
 
@@ -114,11 +114,11 @@ assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = alr(:,perm);
 
-[a1,ind] = gsort(string(a),'lc');
-[a2,ind] = gsort(a,'lc') ;
+[a1,ind] = gsort(string(a),"lc");
+[a2,ind] = gsort(a,"lc") ;
 
 assert_checkalmostequal(norm(evstr(a1)- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 
@@ -128,38 +128,38 @@ assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //================================ Matrix of double case ===========================================
 N = 4;P = 20;Nrand = 100;
 
-a = matrix(grand(1,'prm',(1:N*P)'),N,P);
+a = matrix(grand(1,"prm",(1:N*P)'),N,P);
 
 //-----Global sort --------------------------------
 
-[a1,ind]=gsort(a,'g');
+[a1,ind]=gsort(a,"g");
 assert_checkalmostequal(norm(a1- matrix(N*P:-1:1,N,P)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 
 for i=1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
     assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
 end
 
 //increasing values
 
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkalmostequal(norm(a1- matrix(1:N*P,N,P)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 
 for i=1:100
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
     assert_checktrue(or(b1(1:$-1)-b1(2:$) <= 0));
 end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
 
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -168,13 +168,13 @@ assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 test = [];
 for i = 1:nc;
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -185,8 +185,8 @@ end
 
 //increasing values
 
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -195,13 +195,13 @@ assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -210,13 +210,13 @@ assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
     test = [];
     for j = 1:nr
@@ -226,8 +226,8 @@ for i = 1:Nrand
 end
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -236,7 +236,7 @@ assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
@@ -252,35 +252,35 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1, N1, 'u'));
+[ax,perm] = gsort(rand(1, N1, "u"));
 a = alr(perm,:);
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
 
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
     v = b1 * ((vmax + 1) ^ [P - 1 : -1 : 0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkalmostequal(norm(a1 - alr(N1:-1:1,:)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
 
-[a2,ind2] = gsort(a * [100;10;1],'g','i');
+[a2,ind2] = gsort(a * [100;10;1],"g","i");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
     v= b1*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -290,36 +290,36 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = alr(:,perm);
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
 assert_checkalmostequal(norm(a1- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
     v = ((vmax+1)^[N1-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 
 assert_checkalmostequal(norm(a1 - alr(:,P1:-1:1)), %eps, [], %eps);
 assert_checkalmostequal(norm(a1 - matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -330,30 +330,30 @@ a = [1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
     assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -362,13 +362,13 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -376,35 +376,35 @@ assert_checkequal(a(ind,:), b);
 //================================ Matrix of int32 or uint32 case =======================================
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = int32(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int32(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int32(matrix(N * P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = int32(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int32(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, int32(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:100
-    b = int32(10*rand(N,P,'u'));
-    [b1,ind]=gsort(b,'g','i');
+    b = int32(10*rand(N,P,"u"));
+    [b1,ind]=gsort(b,"g","i");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -413,13 +413,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i =1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int32(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int32(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -429,8 +429,8 @@ for i = 1:Nrand
 end
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -439,13 +439,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -454,13 +454,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int32(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int32(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
     test = [];
     for j = 1:nr
@@ -470,8 +470,8 @@ for i = 1:Nrand
 end
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -479,7 +479,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -493,36 +493,36 @@ alr=[1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int32(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 
 assert_checkequal(a1, int32(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int32(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int32(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int32(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -532,35 +532,35 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int32(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int32(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, int32(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -571,30 +571,30 @@ a = int32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
     assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -603,13 +603,13 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -620,35 +620,35 @@ assert_checkequal(a(ind,:), b);
 // test of gsort for int16 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = int16(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int16(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int16(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind]=gsort(b,'g');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind]=gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, int16(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:100
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkequal(b1, int16(matrix(b(ind),N,P)));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -657,13 +657,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checktrue(or( b1(2:$,:) - b1(1:$-1,:) <= 0));
     test = [];
     for j = 1:nc
@@ -673,8 +673,8 @@ for i = 1:Nrand
 end
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -683,13 +683,13 @@ assert_checkequal(a1, test);
 
 test =[];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c')   ;
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c")   ;
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -698,13 +698,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int16(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int16(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
     test = [];
     for j = 1:nr
@@ -714,8 +714,8 @@ for i = 1:Nrand
 end
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -724,7 +724,7 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -738,36 +738,36 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int16(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 
 assert_checkequal(a1, int16(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g');
+[a2,ind2]=gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int16(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int16(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int16(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -777,36 +777,36 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int16(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int16(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 
 assert_checkequal(a1, int16(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -817,30 +817,30 @@ a = int16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
     assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) >= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -849,13 +849,13 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
 assert_checkequal(a(ind,:), b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) >= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
@@ -866,30 +866,30 @@ a = uint16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -898,13 +898,13 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:), b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -914,36 +914,36 @@ assert_checkequal(a(ind,:), b);
 // test of gsort for int8 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = int8(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = int8(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, int8(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 
 assert_checkequal(a1, int8(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g','i');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g","i");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
 end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -951,13 +951,13 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'r');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"r");
     assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
     test = [];
     for j = 1:nc
@@ -967,8 +967,8 @@ for i = 1:Nrand
 end
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -977,13 +977,13 @@ assert_checkequal(a1, test);
 
 test =[];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, int8(test));
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -992,13 +992,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 for i = 1:Nrand
-    b = int8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'c');
+    b = int8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"c");
     assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
     test = [];
     for j = 1:nr
@@ -1008,8 +1008,8 @@ for i = 1:Nrand
 end
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1017,7 +1017,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr ;
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -1031,35 +1031,35 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = int8(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, int8(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = int8(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = int8(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, int8(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
+[a2,ind2]=gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -1069,36 +1069,36 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = int8(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, int8(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2]=gsort([100,10,1]*a,'g');
+[a2,ind2]=gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax*rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 
 assert_checkequal(a1, int8(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
+[a2,ind2]=gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
@@ -1109,30 +1109,30 @@ a = int8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19])';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) - b(1:$-1,:);
     assert_checktrue(or(t(:,1) <= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
     assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind]=gsort(a,'lr','d');
+[b,ind]=gsort(a,"lr","d");
 t=b(1:$-1,:)-b(2:$,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
 assert_checkequal(a(ind,:), b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(1:$-1,:) - b(2:$,:);
     assert_checktrue(or(t(:,1) <= 0));
     assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -1141,13 +1141,15 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) - b(1:$-1,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+
+
 assert_checkequal(a(ind,:), b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(1:$-1,:) - b(2:$,:);
 assert_checktrue(or(t(:,1) <= 0));
 assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
@@ -1155,29 +1157,29 @@ assert_checkequal(a(ind,:), b);
 
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = uint32(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint32(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint32(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = uint32(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint32(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint32(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc ;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1185,13 +1187,13 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc ;
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1200,13 +1202,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1215,13 +1217,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1229,7 +1231,7 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -1243,35 +1245,35 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint32(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint32(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g');
+[a2,ind2]=gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint32(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint32(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint32(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
+[a2,ind2]=gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1281,35 +1283,35 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint32(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint32(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, uint32(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1320,30 +1322,30 @@ a = uint32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:),b);
 end
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -1352,13 +1354,13 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -1367,29 +1369,29 @@ assert_checkequal(a(ind,:),b);
 // test of gsort for uuint16 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = uint16(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint16(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint16(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = uint16(10 * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint16(10 * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint16(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1397,13 +1399,13 @@ end
 assert_checkequal(a1, test);
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1412,13 +1414,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1427,13 +1429,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1442,7 +1444,7 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -1456,35 +1458,35 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint16(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint16(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a * [100;10;1],'g');
+[a2,ind2] = gsort(a * [100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint16(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint16(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint16(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a * [100;10;1],'g','i');
+[a2,ind2] = gsort(a * [100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v = double(b1) * ((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1494,37 +1496,37 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint16(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint16(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1] * a,'g');
+[a2,ind2] = gsort([100,10,1] * a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N1-1:-1:0]) * double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 
 assert_checkequal(a1, uint16(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1] * a,'g','i');
+[a2,ind2] = gsort([100,10,1] * a,"g","i");
 assert_checkequal(ind2, ind);
 
 vmax = 4;
 for i = 1:Nrand
-    b = int(vmax * rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax * rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1534,29 +1536,29 @@ end
 // test of gsort for uint8 matrices:
 N = 4;P = 20;Nrand = 100; vmax = 4;
 
-a = uint8(matrix(grand(1,'prm',(1:N*P)'),N,P));
+a = uint8(matrix(grand(1,"prm",(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind] = gsort(a,'g');
+[a1,ind] = gsort(a,"g");
 assert_checkequal(a1, uint8(matrix(N*P:-1:1,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 for i = 1:Nrand
-    b = uint8(10*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'g');
+    b = uint8(10*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"g");
     assert_checkequal(b1, matrix(b(ind),N,P));
     assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
 end
 
 //increasing values
-[a1,ind] = gsort(a,'g','i');
+[a1,ind] = gsort(a,"g","i");
 assert_checkequal(a1, uint8(matrix(1:N*P,N,P)));
 assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind] = gsort(a,'r');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1565,13 +1567,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc
-    test = [test, gsort(a(:,i),'g')];
+    test = [test, gsort(a(:,i),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing values
-[a1,ind] = gsort(a,'r','i');
-nc = size(a,'c');
+[a1,ind] = gsort(a,"r","i");
+nc = size(a,"c");
 test = [];
 for i = 1:nc
     test = [test, matrix(a(ind(:,i),i),N,1)];
@@ -1580,13 +1582,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nc ;
-    test = [test, gsort(a(:,i),'g','i')];
+    test = [test, gsort(a(:,i),"g","i")];
 end
 assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind] = gsort(a,'c');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c");
+nr = size(a,"r");
 test = [];
 for i = 1:nr;
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1595,13 +1597,13 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g')];
+    test = [test; gsort(a(i,:),"g")];
 end
 assert_checkequal(a1, test);
 
 //increasing
-[a1,ind] = gsort(a,'c','i');
-nr = size(a,'r');
+[a1,ind] = gsort(a,"c","i");
+nr = size(a,"r");
 test = [];
 for i = 1:nr
     test = [test; matrix(a(i,ind(i,:)),1,P)];
@@ -1610,7 +1612,7 @@ assert_checkequal(a1, test);
 
 test = [];
 for i = 1:nr
-    test = [test; gsort(a(i,:),'g','i')];
+    test = [test; gsort(a(i,:),"g","i")];
 end
 assert_checkequal(a1, test);
 
@@ -1624,35 +1626,35 @@ alr = [1,2,2;
 1,1,2;
 1,1,1];
 // a random permutation
-[ax,perm] = gsort(rand(1,N1,'u'));
+[ax,perm] = gsort(rand(1,N1,"u"));
 a = uint8(alr(perm,:));
 
-[a1,ind] = gsort(a,'lr');
+[a1,ind] = gsort(a,"lr");
 assert_checkequal(a1, uint8(alr));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g');
+[a2,ind2] = gsort(a*[100;10;1],"g");
 assert_checkequal(ind2, ind);
 ///////////////////////
 for i = 1:Nrand
-    b = uint8(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr');
+    b = uint8(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr");
     assert_checkequal(b1, b(ind,:));
     v = double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 // increasing
-[a1,ind] = gsort(a,'lr','i');
+[a1,ind] = gsort(a,"lr","i");
 assert_checkequal(a1, uint8(alr(N1:-1:1,:)));
 assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2] = gsort(a*[100;10;1],'g','i');
+[a2,ind2] = gsort(a*[100;10;1],"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lr','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lr","i");
     assert_checkequal(b1, b(ind,:));
     v= double(b1)*((vmax+1)^[P-1:-1:0])';
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1662,35 +1664,35 @@ end
 N1 = 3;P1 = 4;
 alr = alr';
 // a random permutation
-[ax,perm] = gsort(rand(1,P1,'u'));
+[ax,perm] = gsort(rand(1,P1,"u"));
 a = uint8(alr(:,perm));
 
-[a1,ind] = gsort(a,'lc');
+[a1,ind] = gsort(a,"lc");
 assert_checkequal(a1, uint8(alr));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g');
+[a2,ind2] = gsort([100,10,1]*a,"g");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax * rand(N1,P1,'u'));
-    [b1,ind] = gsort(b,'lc');
+    b = int(vmax * rand(N1,P1,"u"));
+    [b1,ind] = gsort(b,"lc");
     assert_checkequal(b1, b(:,ind));
     v = ((vmax+1)^[N1-1:-1:0])*double(b1);
     assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end
 
 //increasing
-[a1,ind] = gsort(a,'lc','i');
+[a1,ind] = gsort(a,"lc","i");
 assert_checkequal(a1, uint8(alr(:,P1:-1:1)));
 assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-[a2,ind2] = gsort([100,10,1]*a,'g','i');
+[a2,ind2] = gsort([100,10,1]*a,"g","i");
 assert_checkequal(ind2, ind);
 
 for i = 1:Nrand
-    b = int(vmax*rand(N,P,'u'));
-    [b1,ind] = gsort(b,'lc','i');
+    b = int(vmax*rand(N,P,"u"));
+    [b1,ind] = gsort(b,"lc","i");
     assert_checkequal(b1, b(:,ind));
     v= ((vmax+1)^[N-1:-1:0])*b1;
     assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
@@ -1701,30 +1703,30 @@ a = uint8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
 16,19,19,19,18,19]-5)';
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','i');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","i");
     t = b(2:$,:) < b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
     assert_checkequal(a(p(ind),:),b);
 end
 
-[b,ind]=gsort(a,'lr','d');
+[b,ind]=gsort(a,"lr","d");
 t=b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
 for k = 1:30
-    p = grand(1,'prm',(1:size(a,1))');
-    [b,ind] = gsort(a(p,:),'lr','d');
+    p = grand(1,"prm",(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),"lr","d");
     t = b(2:$,:) > b(1:$-1,:);
     assert_checkfalse(or(t(:,1)));
     assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
@@ -1733,87 +1735,87 @@ end
 
 a = b;
 a([10 60],:) = a([60 10],:);
-[b,ind] = gsort(a,'lr','i');
+[b,ind] = gsort(a,"lr","i");
 t = b(2:$,:) < b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
-[b,ind] = gsort(a,'lr','d');
+[b,ind] = gsort(a,"lr","d");
 t = b(2:$,:) > b(1:$-1,:);
 assert_checkfalse(or(t(:,1)));
 assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
 assert_checkequal(a(ind,:),b);
 
 //testing gsort with Nan's
-b = gsort([1 2 %nan 3 4],'g','i');
+b = gsort([1 2 %nan 3 4],"g","i");
 assert_checkequal(b(1:4), (1:4));
 assert_checkequal(find(isnan(b)), 5);
 
-b = gsort([1 2 %nan 1 3 ],'g','i');
+b = gsort([1 2 %nan 1 3 ],"g","i");
 assert_checkequal(b(1:4), [1 1 2 3]);
 assert_checkequal(find(isnan(b)), 5);
 
-b = gsort([1 2 %nan 1 3 ],'g','d');
+b = gsort([1 2 %nan 1 3 ],"g","d");
 assert_checkequal(b(2:$), [3 2 1 1]);
 assert_checkequal(find(isnan(b)), 1);
 
-b = gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
+b = gsort([1 2 %nan 1 3 %nan 2 3],"g","d");
 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
 assert_checkequal(find(isnan(b)), [1 2]);
 
-b = gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
+b = gsort([1 2 %nan 1 3 %nan 2 3],"g","i");
 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
 assert_checkequal(find(isnan(b)), [7 8]);
 
 m = [1 2 %nan;1 3 %nan;1 2 3];
-b = gsort(m,'lr','i');
-assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%nan;1,3,%nan]');
+b = gsort(m,"lr","i");
+assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%nan;1,3,%nan]");
 
-b = gsort(m,'lr','d');
-assert_checkequal(sci2exp(b,0), '[1,3,%nan;1,2,%nan;1,2,3]');
+b = gsort(m,"lr","d");
+assert_checkequal(sci2exp(b,0), "[1,3,%nan;1,2,%nan;1,2,3]");
 
 m = m(:,[3 1 2]);
-b = gsort(m,'lc','i');
-assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,3,%nan;1,2,3]');
+b = gsort(m,"lc","i");
+assert_checkequal(sci2exp(b,0), "[1,2,%nan;1,3,%nan;1,2,3]");
 
-b = gsort(m,'lc','d');
-assert_checkequal(sci2exp(b,0), '[%nan,2,1;%nan,3,1;3,2,1]');
+b = gsort(m,"lc","d");
+assert_checkequal(sci2exp(b,0), "[%nan,2,1;%nan,3,1;3,2,1]");
 
 //testing gsort with Inf's
-b = gsort([1 2 %inf 3 4],'g','i');
+b = gsort([1 2 %inf 3 4],"g","i");
 assert_checkequal(b(1:4), (1:4));
 assert_checkequal(find(isinf(b)), 5);
 
-b=gsort([1 2 %inf 1 3 ],'g','i');
+b=gsort([1 2 %inf 1 3 ],"g","i");
 assert_checkequal(b(1:4), [1 1 2 3]);
 assert_checkequal(find(isinf(b)), 5);
 
-b=gsort([1 2 %inf 1 3 ],'g','d');
+b=gsort([1 2 %inf 1 3 ],"g","d");
 assert_checkequal(b(2:$), [3 2 1 1]);
 assert_checkequal(find(isinf(b)), 1);
 
-b=gsort([1 2 %inf 1 3 %inf 2 3],'g','d');
+b=gsort([1 2 %inf 1 3 %inf 2 3],"g","d");
 assert_checkequal(b(3:$), [3,3,2,2,1,1]);
 assert_checkequal(find(isinf(b)), [1 2]);
 
-b=gsort([1 2 %inf 1 3 %inf 2 3],'g','i');
+b=gsort([1 2 %inf 1 3 %inf 2 3],"g","i");
 assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
 assert_checkequal(find(isinf(b)), [7 8]);
 
 m = [1 2 %inf;1 3 %inf;1 2 3];
-b = gsort(m,'lr','i');
-assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%inf;1,3,%inf]');
+b = gsort(m,"lr","i");
+assert_checkequal(sci2exp(b,0), "[1,2,3;1,2,%inf;1,3,%inf]");
 
-b = gsort(m,'lr','d');
-assert_checkequal(sci2exp(b,0), '[1,3,%inf;1,2,%inf;1,2,3]');
+b = gsort(m,"lr","d");
+assert_checkequal(sci2exp(b,0), "[1,3,%inf;1,2,%inf;1,2,3]");
 
 m = m(:,[3 1 2]);
-b = gsort(m,'lc','i');
-assert_checkequal(sci2exp(b,0), '[1,2,%inf;1,3,%inf;1,2,3]');
+b = gsort(m,"lc","i");
+assert_checkequal(sci2exp(b,0), "[1,2,%inf;1,3,%inf;1,2,3]");
 
-b = gsort(m,'lc','d');
-assert_checkequal(sci2exp(b,0), '[%inf,2,1;%inf,3,1;3,2,1]');
+b = gsort(m,"lc","d");
+assert_checkequal(sci2exp(b,0), "[%inf,2,1;%inf,3,1;3,2,1]");
 
 //gsort
 a = [5 1 3 2 4];
@@ -1829,9 +1831,9 @@ assert_checkequal(k, [1 5 3 4 2]);
 assert_checkequal(s, [5 4 3 2 1]);
 
 a = string([5 1 3 2 4]);
-assert_checkequal(gsort(a,'g','i'), string(1:5));
+assert_checkequal(gsort(a,"g","i"), string(1:5));
 
-[s,k]=gsort(a,'g','i');
+[s,k]=gsort(a,"g","i");
 assert_checkequal(k, [2 4 3 5 1]);
 assert_checkequal(s, string(1:5));
 
@@ -1846,107 +1848,107 @@ b = [5 1 3 2 4;6 1 2 4 1];
 B = sparse(b);
 
 // opts = 'r' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'r','d');
-[s1,k1] = gsort(B(:),'r','d');
+[s,k] = gsort(b(:),"r","d");
+[s1,k1] = gsort(B(:),"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:),'r','i');
-[s1,k1] = gsort(B(:),'r','i');
+[s,k] = gsort(b(:),"r","i");
+[s1,k1] = gsort(B(:),"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','r','d');
-[s1,k1] = gsort(B(:)','r','d');
+[s,k] = gsort(b(:)',"r","d");
+[s1,k1] = gsort(B(:)',"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','r','i');
-[s1,k1] = gsort(B(:)','r','i');
+[s,k] = gsort(b(:)',"r","i");
+[s1,k1] = gsort(B(:)',"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
 // opts = 'c' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'c','d');
-[s1,k1] = gsort(B(:),'c','d');
+[s,k] = gsort(b(:),"c","d");
+[s1,k1] = gsort(B(:),"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:),'c','i');
-[s1,k1] = gsort(B(:),'c','i');
+[s,k] = gsort(b(:),"c","i");
+[s1,k1] = gsort(B(:),"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','c','d');
-[s1,k1] = gsort(B(:)','c','d');
+[s,k] = gsort(b(:)',"c","d");
+[s1,k1] = gsort(B(:)',"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','c','i');
-[s1,k1] = gsort(B(:)','c','i');
+[s,k] = gsort(b(:)',"c","i");
+[s1,k1] = gsort(B(:)',"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
 // opts = 'g' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'g','d');
-[s1,k1] = gsort(B(:),'g','d');
+[s,k] = gsort(b(:),"g","d");
+[s1,k1] = gsort(B(:),"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:),'g','i');
-[s1,k1] = gsort(B(:),'g','i');
+[s,k] = gsort(b(:),"g","i");
+[s1,k1] = gsort(B(:),"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','g','d');
-[s1,k1] = gsort(B(:)','g','d');
+[s,k] = gsort(b(:)',"g","d");
+[s1,k1] = gsort(B(:)',"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','g','i');
-[s1,k1] = gsort(B(:)','g','i');
+[s,k] = gsort(b(:)',"g","i");
+[s1,k1] = gsort(B(:)',"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
 // opts = 'lr' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'lr','d');
-[s1,k1] = gsort(B(:),'lr','d');
+[s,k] = gsort(b(:),"lr","d");
+[s1,k1] = gsort(B(:),"lr","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:),'lr','i');
-[s1,k1] = gsort(B(:),'lr','i');
+[s,k] = gsort(b(:),"lr","i");
+[s1,k1] = gsort(B(:),"lr","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','lr','d');
-[s1,k1] = gsort(B(:)','lr','d');
+[s,k] = gsort(b(:)',"lr","d");
+[s1,k1] = gsort(B(:)',"lr","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','lr','i');
-[s1,k1] = gsort(B(:)','lr','i');
+[s,k] = gsort(b(:)',"lr","i");
+[s1,k1] = gsort(B(:)',"lr","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
 // opts = 'lc' and direction = 'd' or 'i'
-[s,k] = gsort(b(:),'lc','d');
-[s1,k1] = gsort(B(:),'lc','d');
+[s,k] = gsort(b(:),"lc","d");
+[s1,k1] = gsort(B(:),"lc","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:),'lc','i');
-[s1,k1] = gsort(B(:),'lc','i');
+[s,k] = gsort(b(:),"lc","i");
+[s1,k1] = gsort(B(:),"lc","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','lc','d');
-[s1,k1] = gsort(B(:)','lc','d');
+[s,k] = gsort(b(:)',"lc","d");
+[s1,k1] = gsort(B(:)',"lc","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(b(:)','lc','i');
-[s1,k1] = gsort(B(:)','lc','i');
+[s,k] = gsort(b(:)',"lc","i");
+[s1,k1] = gsort(B(:)',"lc","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
@@ -1955,87 +1957,87 @@ assert_checkequal(k1,k);
 A = [1 -%i;%i 0];
 A1 = sparse(A);
 
-c = gsort(A(:),'g','d');
-d = full(gsort(A1(:),'g','d'));
+c = gsort(A(:),"g","d");
+d = full(gsort(A1(:),"g","d"));
 assert_checkequal(c,d);
 
-c = gsort(A(:),'g','i');
-d = full(gsort(A1(:),'g','i'));
+c = gsort(A(:),"g","i");
+d = full(gsort(A1(:),"g","i"));
 assert_checkequal(c,d);
 
-c = gsort(A(:),'r','d');
-d = full(gsort(A1(:),'r','d'));
+c = gsort(A(:),"r","d");
+d = full(gsort(A1(:),"r","d"));
 assert_checkequal(c,d);
 
-c = gsort(A(:),'r','i');
-d = full(gsort(A1(:),'r','i'));
+c = gsort(A(:),"r","i");
+d = full(gsort(A1(:),"r","i"));
 assert_checkequal(c,d);
 
-c = gsort(A(:),'c','d');
-d = full(gsort(A1(:),'c','d'));
+c = gsort(A(:),"c","d");
+d = full(gsort(A1(:),"c","d"));
 assert_checkequal(c,d);
 
-c = gsort(A(:),'c','i');
-d = full(gsort(A1(:),'c','i'));
+c = gsort(A(:),"c","i");
+d = full(gsort(A1(:),"c","i"));
 assert_checkequal(c,d);
 
 B = [1 1+%i 4; -2*%i 3 3-%i];
 B1 = sparse(B);
 
-c = gsort(B(:),'g','d');
-d = full(gsort(B1(:),'g','d'));
+c = gsort(B(:),"g","d");
+d = full(gsort(B1(:),"g","d"));
 assert_checkequal(c,d);
 
-c = gsort(B(:),'g','i');
-d = full(gsort(B1(:),'g','i'));
+c = gsort(B(:),"g","i");
+d = full(gsort(B1(:),"g","i"));
 assert_checkequal(c,d);
 
-c = gsort(B(:),'r','d');
-d = full(gsort(B1(:),'r','d'));
+c = gsort(B(:),"r","d");
+d = full(gsort(B1(:),"r","d"));
 assert_checkequal(c,d);
 
-c = gsort(B(:),'r','i');
-d = full(gsort(B1(:),'r','i'));
+c = gsort(B(:),"r","i");
+d = full(gsort(B1(:),"r","i"));
 assert_checkequal(c,d);
 
-c = gsort(B(:),'c','d');
-d = full(gsort(B1(:),'c','d'));
+c = gsort(B(:),"c","d");
+d = full(gsort(B1(:),"c","d"));
 assert_checkequal(c,d);
 
-c = gsort(B(:),'c','i');
-d = full(gsort(B1(:),'c','i'));
+c = gsort(B(:),"c","i");
+d = full(gsort(B1(:),"c","i"));
 assert_checkequal(c,d);
 
 C = [-%i 3*%i;4 9;-2*%i 7];
 C1 = sparse(C);
 
-[s,k] = gsort(C(:),'g','d');
-[s1,k1] = gsort(C1(:),'g','d');
+[s,k] = gsort(C(:),"g","d");
+[s1,k1] = gsort(C1(:),"g","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(C(:),'g','i');
-[s1,k1] = gsort(C1(:),'g','i');
+[s,k] = gsort(C(:),"g","i");
+[s1,k1] = gsort(C1(:),"g","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(C(:),'r','d');
-[s1,k1] = gsort(C1(:),'r','d');
+[s,k] = gsort(C(:),"r","d");
+[s1,k1] = gsort(C1(:),"r","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(C(:),'r','i');
-[s1,k1] = gsort(C1(:),'r','i');
+[s,k] = gsort(C(:),"r","i");
+[s1,k1] = gsort(C1(:),"r","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(C(:),'c','d');
-[s1,k1] = gsort(C1(:),'c','d');
+[s,k] = gsort(C(:),"c","d");
+[s1,k1] = gsort(C1(:),"c","d");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
-[s,k] = gsort(C(:),'c','i');
-[s1,k1] = gsort(C1(:),'c','i');
+[s,k] = gsort(C(:),"c","i");
+[s1,k1] = gsort(C1(:),"c","i");
 assert_checkequal(full(s1),s);
 assert_checkequal(k1,k);
 
@@ -2054,10 +2056,10 @@ hs = gsort(A);
 assert_checkequal(hs(:), s);
 
 // 'c' 'r' 'lc' 'lr'
-[hsc hindc]   = gsort(A, 'c');
-[hsr hindr]   = gsort(A, 'r');
-[hslc hindlc] = gsort(A, 'lc');
-[hslr hindlr] = gsort(A, 'lr');
+[hsc hindc]   = gsort(A, "c");
+[hsr hindr]   = gsort(A, "r");
+[hslc hindlc] = gsort(A, "lc");
+[hslr hindlr] = gsort(A, "lr");
 
 a       = matrix(A, 6, 4, 16); // 2 * 8 = 16
 sc      = zeros(a);
@@ -2070,10 +2072,10 @@ slr     = zeros(a);
 indlr   = zeros(6, 1, 16);
 
 for i = 1:16
-    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),'c');
-    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),'r');
-    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),'lc');
-    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),'lr');
+    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),"c");
+    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),"r");
+    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),"lc");
+    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),"lr");
 end
 
 sc      = matrix(sc, 6, 4, 2, 8);
@@ -2095,10 +2097,10 @@ assert_checkequal(hslr, slr);
 assert_checkequal(hindlr, indlr);
 
 // whitout indices
-hsc  = gsort(A, 'c');
-hsr  = gsort(A, 'r');
-hslc = gsort(A, 'lc');
-hslr = gsort(A, 'lr');
+hsc  = gsort(A, "c");
+hsr  = gsort(A, "r");
+hslc = gsort(A, "lc");
+hslr = gsort(A, "lr");
 
 assert_checkequal(hsc, sc);
 assert_checkequal(hsr, sr);
@@ -2107,20 +2109,20 @@ assert_checkequal(hslr, slr);
 
 // ----- increasing -----
 // 'g'
-[hs hind]   = gsort(A, 'g', 'i');
-[s ind]     = gsort(A(:), 'g', 'i');
+[hs hind]   = gsort(A, "g", "i");
+[s ind]     = gsort(A(:), "g", "i");
 
 assert_checkequal(hs(:), s);
 assert_checkequal(hind(:), ind);
 
-hs = gsort(A, 'g', 'i');
+hs = gsort(A, "g", "i");
 assert_checkequal(hs(:), s);
 
 // 'c' 'r' 'lc' 'lr'
-[hsc hindc]   = gsort(A, 'c', 'i');
-[hsr hindr]   = gsort(A, 'r', 'i');
-[hslc hindlc] = gsort(A, 'lc', 'i');
-[hslr hindlr] = gsort(A, 'lr', 'i');
+[hsc hindc]   = gsort(A, "c", "i");
+[hsr hindr]   = gsort(A, "r", "i");
+[hslc hindlc] = gsort(A, "lc", "i");
+[hslr hindlr] = gsort(A, "lr", "i");
 
 a       = matrix(A, 6, 4, 16); // 2 * 8 = 16
 sc      = zeros(a);
@@ -2133,10 +2135,10 @@ slr     = zeros(a);
 indlr   = zeros(6, 1, 16);
 
 for i = 1:16
-    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),'c', 'i');
-    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),'r', 'i');
-    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),'lc', 'i');
-    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),'lr', 'i');
+    [sc(:,:,i) indc(:,:,i)]   = gsort(a(:,:,i),"c", "i");
+    [sr(:,:,i) indr(:,:,i)]   = gsort(a(:,:,i),"r", "i");
+    [slc(:,:,i) indlc(:,:,i)] = gsort(a(:,:,i),"lc", "i");
+    [slr(:,:,i) indlr(:,:,i)] = gsort(a(:,:,i),"lr", "i");
 end
 
 sc      = matrix(sc, 6, 4, 2, 8);
@@ -2158,10 +2160,10 @@ assert_checkequal(hslr, slr);
 assert_checkequal(hindlr, indlr);
 
 // whitout indices
-hsc  = gsort(A, 'c', 'i');
-hsr  = gsort(A, 'r', 'i');
-hslc = gsort(A, 'lc', 'i');
-hslr = gsort(A, 'lr', 'i');
+hsc  = gsort(A, "c", "i");
+hsr  = gsort(A, "r", "i");
+hslc = gsort(A, "lc", "i");
+hslr = gsort(A, "lr", "i");
 
 assert_checkequal(hsc, sc);
 assert_checkequal(hsr, sr);
index 817dece..a1034d5 100644 (file)
@@ -56,8 +56,8 @@ assert_checkequal(Al, Am);
 assert_checkequal(Akl, Ak);
 // test max(A,'c') and max(A,'r')
 // max(A,'r') returns a row vector which contains max for each column
-[Am, Akm] = max(A1, 'r');
-nc = size(A1, 'c');
+[Am, Akm] = max(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 Ak1 = [];
 for i = 1:nc
@@ -68,8 +68,8 @@ end
 assert_checkequal(Am, Am1);
 assert_checkequal(Akm, Ak1);
 // max(A,'c');
-[Am, Akm] = max(A1, 'c');
-nc = size(A1, 'r');
+[Am, Akm] = max(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 Ak1 = [];
 for i = 1:nc
@@ -258,8 +258,8 @@ Al = max(list(A1, A2, A3, A4));
 assert_checkequal(Al, sparse(Am));
 // test max(A,'c') and max(A,'r')
 // max(A,'r') returns a row vector which contains max for each column
-[Am] = max(A1, 'r');
-nc = size(A1, 'c');
+[Am] = max(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 for i = 1:nc
     [am] = max(A1(:,i));
@@ -267,8 +267,8 @@ for i = 1:nc
 end
 assert_checkequal(Am, sparse(Am1));
 // max(A,'c');
-[Am] = max(A1, 'c');
-nc = size(A1, 'r');
+[Am] = max(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 for i = 1:nc
     [am] = max(A1(i,:));
@@ -294,8 +294,8 @@ Al = min(list(A1, A2, A3, A4));
 assert_checkequal(Al, sparse(Am));
 // test min(A,'c') and min(A,'r')
 // min(A,'r') returns a row vector which contains min for each column
-[Am] = min(A1, 'r');
-nc = size(A1, 'c');
+[Am] = min(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 for i = 1:nc
     [am] = min(A1(:,i));
@@ -303,8 +303,8 @@ for i = 1:nc
 end
 assert_checkequal(Am, sparse(Am1));
 // min(A,'c');
-[Am] = min(A1, 'c');
-nc = size(A1, 'r');
+[Am] = min(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 for i = 1:nc
     [am] = min(A1(i,:));
index 325e7eb..74f1422 100644 (file)
@@ -72,8 +72,8 @@ assert_checkequal(Akl, Ak);
 // test max(A,'c') and max(A,'r')
 // max(A,'r') returns a row vector which contains max for each column
 
-[Am, Akm] = max(A1, 'r');
-nc = size(A1, 'c');
+[Am, Akm] = max(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 Ak1 = [];
 for i = 1:nc
@@ -86,8 +86,8 @@ assert_checkequal(Akm, Ak1);
 
 // max(A,'c');
 
-[Am, Akm] = max(A1, 'c');
-nc = size(A1, 'r');
+[Am, Akm] = max(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 Ak1 = [];
 for i = 1:nc
@@ -320,8 +320,8 @@ assert_checkequal(Al, sparse(Am));
 // test max(A,'c') and max(A,'r')
 // max(A,'r') returns a row vector which contains max for each column
 
-[Am] = max(A1, 'r');
-nc = size(A1, 'c');
+[Am] = max(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 for i = 1:nc
     [am] = max(A1(:,i));
@@ -331,8 +331,8 @@ assert_checkequal(Am, sparse(Am1));
 
 // max(A,'c');
 
-[Am] = max(A1, 'c');
-nc = size(A1, 'r');
+[Am] = max(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 for i = 1:nc
     [am] = max(A1(i,:));
@@ -365,8 +365,8 @@ assert_checkequal(Al, sparse(Am));
 // test min(A,'c') and min(A,'r')
 // min(A,'r') returns a row vector which contains min for each column
 
-[Am] = min(A1, 'r');
-nc = size(A1, 'c');
+[Am] = min(A1, "r");
+nc = size(A1, "c");
 Am1 = [];
 for i = 1:nc
     [am] = min(A1(:,i));
@@ -376,8 +376,8 @@ assert_checkequal(Am, sparse(Am1));
 
 // min(A,'c');
 
-[Am] = min(A1, 'c');
-nc = size(A1, 'r');
+[Am] = min(A1, "c");
+nc = size(A1, "r");
 Am1 = [];
 for i = 1:nc
     [am] = min(A1(i,:));
index c1950da..3ec5d09 100644 (file)
@@ -57,7 +57,7 @@ types::Function::ReturnValue sci_bdiag(types::typed_list &in, int _iRetCount, ty
         return types::Function::Error;
     }
 
-    pDblMatrix = in[0]->getAs<types::Double>()->clone()->getAs<types::Double>(); // input data will be modified
+    pDblMatrix = in[0]->clone()->getAs<types::Double>(); // input data will be modified
     if (pDblMatrix->getRows() != pDblMatrix->getCols())
     {
         Scierror(20, _("%s: Wrong type for argument %d: Square matrix expected.\n"), "bdiag", 1);
index 7396e92..11db9e2 100644 (file)
@@ -346,9 +346,11 @@ types::Function::ReturnValue sci_schur(types::typed_list &in, int _iRetCount, ty
             if (_iRetCount == 2)
             {
                 out.push_back(pDblOut[0]);
+                pDblOut[0] = NULL;
             }
 
             out.push_back(pDbl[0]); // pDbl[0] has been overwritten by its real Schur form T.
+
             break;
         }
         case 11: // double double
@@ -356,14 +358,17 @@ types::Function::ReturnValue sci_schur(types::typed_list &in, int _iRetCount, ty
             for (int i = 0; i < 2; i++)
             {
                 out.push_back(pDbl[i]);
+                pDbl[1] = NULL;
             }
 
             if (_iRetCount == 4)
             {
                 out.push_back(pDblOut[0]);
+                pDblOut[0] = NULL;
                 if (_iRetCount > 1)
                 {
                     out.push_back(pDblOut[1]);
+                    pDblOut[1] = NULL;
                 }
             }
 
@@ -378,7 +383,9 @@ types::Function::ReturnValue sci_schur(types::typed_list &in, int _iRetCount, ty
             else
             {
                 out.push_back(pDblOut[0]);
+                pDblOut[0] = NULL;
                 out.push_back(pDblOut[2]);
+                pDblOut[2] = NULL;
 
                 if (_iRetCount == 3)
                 {
@@ -399,25 +406,43 @@ types::Function::ReturnValue sci_schur(types::typed_list &in, int _iRetCount, ty
                     for (int i = 0; i < 2; i++)
                     {
                         out.push_back(pDbl[i]);
+                        pDbl[1] = NULL;
                     }
                     out.push_back(pDblOut[1]);
+                    pDblOut[1] = NULL;
                     break;
                 }
                 case 3 : // Q Z dim
                 {
                     out.push_back(pDblOut[0]);
+                    pDblOut[0] = NULL;
                 }
                 case 2 : // Z dim
                 {
                     out.push_back(pDblOut[1]);
+                    pDblOut[1] = NULL;
                     break;
                 }
             }
             out.push_back(pDblOut[2]);
+            pDblOut[2] = NULL;
             break;
         }
     }
 
+    for (int i = 0; i < 3; ++i)
+    {
+        if (pDblOut[i])
+        {
+            pDblOut[i]->killMe();
+        }
+    }
+
+
+    if (pDbl[1])
+    {
+        pDbl[1]->killMe();
+    }
     ConfigVariable::setSchurFunction(NULL);
     return types::Function::OK;
 }
index 4b19a5a..48e8df4 100644 (file)
@@ -58,7 +58,7 @@ types::Function::ReturnValue sci_spec(types::typed_list &in, int _iRetCount, typ
         std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_spec";
         return Overload::call(wstFuncName, in, _iRetCount, out, &exec);
     }
-    pDblA = in[0]->getAs<types::Double>()->clone()->getAs<types::Double>();
+    pDblA = in[0]->clone()->getAs<types::Double>();
 
     if (pDblA->getCols() != pDblA->getRows())
     {
index b69ea3f..6d5c3ae 100644 (file)
@@ -183,6 +183,18 @@ types::Function::ReturnValue sci_spget(types::typed_list &in, int _iRetCount, ty
             out.push_back(pValues);
         }
     }
+    else
+    {
+        if (pBools)
+        {
+            pBools->killMe();
+        }
+
+        if (pValues)
+        {
+            pValues->killMe();
+        }
+    }
 
     if (_iRetCount > 2)
     {
index 095cc8d..c0d971c 100644 (file)
@@ -6,5 +6,6 @@ src/c/windows_tools.def
 src/nowindows_tools/nowindows_tools.def
 #memory leaks tools configuration files
 src/c/CScilex/vld.ini
+src/c/WScilex/vld.ini
 src/c/CScilex/memory_leak_report.txt