utf: module elementary_functions 25/17625/1
Antoine ELIAS [Tue, 5 Jan 2016 14:55:07 +0000 (15:55 +0100)]
Change-Id: Id6a08c99418e21da5d6859fd8b290bb7109e814d

59 files changed:
scilab/modules/ast/includes/types/matrixiterator.hxx
scilab/modules/ast/src/cpp/ast/runvisitor.cpp
scilab/modules/ast/src/cpp/types/list.cpp
scilab/modules/core/includes/machine.h.vc
scilab/modules/elementary_functions/includes/gsort.hxx
scilab/modules/elementary_functions/sci_gateway/cpp/elem_func_gw.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_abs.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_acos.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_acosh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_asin.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_asinh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_atan.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_atanh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_ceil.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_clean.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_conj.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_cos.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_cosh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_cumprod.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_cumsum.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_diag.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_dsearch.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_exp.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_expm.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_eye.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_floor.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_frexp.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_gsort.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_imag.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_imult.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_int.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_isreal.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_kron.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_log.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_log1p.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_ones.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_prod.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_rand.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_rat.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_real.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_round.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sign.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sin.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sinh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_size.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sqrt.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_sum.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_tan.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_tanh.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_tril.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_triu.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_zeros.cpp
scilab/modules/elementary_functions/src/c/elementary_functions.vcxproj
scilab/modules/elementary_functions/src/c/elementary_functions.vcxproj.filters
scilab/modules/elementary_functions/src/cpp/diag.cpp
scilab/modules/elementary_functions/src/cpp/gsort.cpp
scilab/modules/elementary_functions/src/cpp/gsort.hxx [deleted file]

index 5fc5551..d24e6d5 100644 (file)
@@ -126,36 +126,45 @@ template<typename S, typename V> bool set(S &, int, int, V)
 
 template<> bool set(types::Double & d, int r, int c, double v)
 {
-    return d.set(r, c, v);
+    d.set(r, c, v);
+    return true;
 }
 template<> bool set(types::Double & d, int r, int c, std::complex<double> v)
 {
-    return d.set(r, c, v.real()) && d.setImg(r, c, v.imag());
+    d.set(r, c, v.real());
+    d.setImg(r, c, v.imag());
+    return true;
 }
 
 template<> bool set(types::Sparse & s, int r, int c, double v)
 {
-    return s.set(r, c, v);
+    s.set(r, c, v);
+    return true;
 }
 template<> bool set(types::Sparse & s, int r, int c, std::complex<double> v)
 {
-    return s.set(r, c, v);
+    s.set(r, c, v);
+    return true;
 }
 template<> bool set(types::Bool & d, int r, int c, bool v)
 {
-    return d.set(r, c, v);
+    d.set(r, c, v);
+    return true;
 }
 template<> bool set(types::SparseBool & d, int r, int c, bool v)
 {
-    return d.set(r, c, v);
+    d.set(r, c, v);
+    return true;
 }
 template<> bool set(types::Bool & d, int r, int c, int v)
 {
-    return d.set(r, c, v);
+    d.set(r, c, v);
+    return true;
 }
 template<> bool set(types::SparseBool & d, int r, int c, int v)
 {
-    return d.set(r, c, v != 0);
+    d.set(r, c, v != 0);
+    return true;
 }
 
 template<> bool set(types::Sparse::RealSparse_t& s, int r, int c, double v)
index 7197f4b..bdb4779 100644 (file)
@@ -33,7 +33,7 @@
 #include "generic_operations.hxx"
 #include "types_or.hxx"
 #include "types_and.hxx"
-
 #include "macrofile.hxx"
 #include "macro.hxx"
 #include "cell.hxx"
index 1f651c8..8512934 100644 (file)
@@ -107,6 +107,7 @@ List* List::append(InternalType *_typedValue)
     _typedValue->IncreaseRef();
     m_plData->push_back(_typedValue);
     m_iSize = static_cast<int>(m_plData->size());
+    return this;
 }
 
 /**
index e2faad9..f701ed7 100644 (file)
 */
 
 #define SHARED_LIB_EXT ".dll"
-#define SHARED_LIB_EXTW L".dll"
 
 /* PATH_SEPARATOR : Under Windows by default is ; */
 #define PATH_SEPARATOR ";"
 
 /* DIR_SEPARATOR : Under Windows by default is \ */
 #define DIR_SEPARATOR "\\"
-#define DIR_SEPARATORW L"\\"
 
 #define HAVE_LIBINTL_H
 
index ec3327b..39e171f 100644 (file)
 #include "string.hxx"
 #include "int.hxx"
 
-types::Double* gsort(types::Double* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
+extern "C"
+{
+#include "dynlib_elementary_functions.h"
+}
 
-types::String* gsort(types::String* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::Double* gsort(types::Double* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
 
-types::Int8* gsort(types::Int8* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::Int16* gsort(types::Int16* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::Int32* gsort(types::Int32* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::Int64* gsort(types::Int64* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::String* gsort(types::String* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
 
-types::UInt8* gsort(types::UInt8* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::UInt16* gsort(types::UInt16* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::UInt32* gsort(types::UInt32* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-types::UInt64* gsort(types::UInt64* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::Int8* gsort(types::Int8* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::Int16* gsort(types::Int16* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::Int32* gsort(types::Int32* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::Int64* gsort(types::Int64* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::UInt8* gsort(types::UInt8* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::UInt16* gsort(types::UInt16* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::UInt32* gsort(types::UInt32* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
+ELEMENTARY_FUNCTIONS_IMPEXP types::UInt64* gsort(types::UInt64* pIn, types::Double* pInd, const std::string& strWay, const std::string& strProcess);
 
 #endif /* __GSORT_H__ */
index 2497d8e..16219aa 100644 (file)
@@ -25,7 +25,7 @@
 #include "sparse.hxx"
 #include "int.hxx"
 
-#define MODULE_NAME L"elementary_functions"
+#define MODULE_NAME "elementary_functions"
 extern "C"
 {
 #include "gw_elementary_functions.h"
@@ -33,64 +33,64 @@ extern "C"
 
 int ElemFuncModule::Load()
 {
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"abs", &sci_abs, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"acos", &sci_acos, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"asin", &sci_asin, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"atan", &sci_atan, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"ceil", &sci_ceil, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"clean", &sci_clean, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"conj", &sci_conj, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cos", &sci_cos, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cumprod", &sci_cumprod, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cumsum", &sci_cumsum, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"diag", &sci_diag, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"dsearch", &sci_dsearch, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"exp", &sci_exp, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"expm", &sci_expm, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"eye", &sci_eye, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"floor", &sci_floor, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"frexp", &sci_frexp, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"gsort", &sci_gsort, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"imag", &sci_imag, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"imult", &sci_imult, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"int", &sci_int, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isreal", &sci_isreal, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isequal", &sci_isequal, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"kron", &sci_kron, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log", &sci_log, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log1p", &sci_log1p, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"matrix", &sci_matrix, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"max", &sci_max, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"min", &sci_min, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"nearfloat", &sci_nearfloat, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"number_properties", &sci_number_properties, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"ones", &sci_ones, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"prod", &sci_prod, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"rand", &sci_rand, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"real", &sci_real, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"round", &sci_round, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sign", &sci_sign, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sin", &sci_sin, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"size", &sci_size, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sqrt", &sci_sqrt, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sum", &sci_sum, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tan", &sci_tan, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"testmatrix", &sci_testmatrix, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tril", &sci_tril, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"triu", &sci_triu, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"zeros", &sci_zeros, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"rat", &sci_rat, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"base2dec", &sci_base2dec, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"dec2base", &sci_dec2base, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"log10", &sci_log10, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"cosh", &sci_cosh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"sinh", &sci_sinh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"tanh", &sci_tanh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"acosh", &sci_acosh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"asinh", &sci_asinh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"atanh", &sci_atanh, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"isvector", &sci_isvector, MODULE_NAME));
-    symbol::Context::getInstance()->addFunction(types::Function::createFunction(L"issquare", &sci_issquare, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("abs", &sci_abs, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("acos", &sci_acos, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("asin", &sci_asin, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("atan", &sci_atan, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("ceil", &sci_ceil, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("clean", &sci_clean, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("conj", &sci_conj, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("cos", &sci_cos, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("cumprod", &sci_cumprod, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("cumsum", &sci_cumsum, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("diag", &sci_diag, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("dsearch", &sci_dsearch, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("exp", &sci_exp, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("expm", &sci_expm, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("eye", &sci_eye, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("floor", &sci_floor, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("frexp", &sci_frexp, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("gsort", &sci_gsort, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("imag", &sci_imag, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("imult", &sci_imult, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("int", &sci_int, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("isreal", &sci_isreal, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("isequal", &sci_isequal, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("kron", &sci_kron, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("log", &sci_log, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("log1p", &sci_log1p, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("matrix", &sci_matrix, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("max", &sci_max, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("min", &sci_min, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("nearfloat", &sci_nearfloat, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("number_properties", &sci_number_properties, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("ones", &sci_ones, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("prod", &sci_prod, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("rand", &sci_rand, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("real", &sci_real, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("round", &sci_round, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("sign", &sci_sign, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("sin", &sci_sin, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("size", &sci_size, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("sqrt", &sci_sqrt, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("sum", &sci_sum, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("tan", &sci_tan, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("testmatrix", &sci_testmatrix, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("tril", &sci_tril, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("triu", &sci_triu, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("zeros", &sci_zeros, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("rat", &sci_rat, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("base2dec", &sci_base2dec, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("dec2base", &sci_dec2base, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("log10", &sci_log10, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("cosh", &sci_cosh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("sinh", &sci_sinh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("tanh", &sci_tanh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("acosh", &sci_acosh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("asinh", &sci_asinh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("atanh", &sci_atanh, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("isvector", &sci_isvector, MODULE_NAME));
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction("issquare", &sci_issquare, MODULE_NAME));
     return 1;
 }
 
index 5423000..583332c 100644 (file)
@@ -184,8 +184,8 @@ types::Function::ReturnValue sci_abs(types::typed_list &in, int _iRetCount, type
         }
         default:
         {
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_abs";
-            return Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_abs";
+            return Overload::call(stFuncName, in, _iRetCount, out);
         }
     }
 
index 3362ae0..0cd0691 100644 (file)
@@ -50,8 +50,8 @@ types::Function::ReturnValue sci_acos(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_acos";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_acos";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
index 269328c..0b8ce9f 100644 (file)
@@ -114,8 +114,8 @@ types::Function::ReturnValue sci_acosh(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_acosh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_acosh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 8133d39..c735c9d 100644 (file)
@@ -48,8 +48,8 @@ types::Function::ReturnValue sci_asin(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_asin";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_asin";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
index a3c636a..6e13c55 100644 (file)
@@ -81,8 +81,8 @@ types::Function::ReturnValue sci_asinh(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_asinh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_asinh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 099e036..f25dbc7 100644 (file)
@@ -56,8 +56,8 @@ types::Function::ReturnValue sci_atan(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_atan";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_atan";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblX = in[0]->getAs<types::Double>();
index b1e58fc..d28f2d1 100644 (file)
@@ -122,8 +122,8 @@ types::Function::ReturnValue sci_atanh(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_atanh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_atanh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index c205728..f07e664 100644 (file)
@@ -164,8 +164,8 @@ types::Function::ReturnValue sci_ceil(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_ceil";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_ceil";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index d5ab32c..4f77b21 100644 (file)
@@ -96,8 +96,8 @@ types::Function::ReturnValue sci_clean(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_clean";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_clean";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
 
index 3f2511d..3272d63 100644 (file)
@@ -56,8 +56,8 @@ types::Function::ReturnValue sci_conj(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_conj";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_conj";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     iSize = pDblOut->getSize();
index b0a9f1c..7bdd5e1 100644 (file)
@@ -103,8 +103,8 @@ types::Function::ReturnValue sci_cos(types::typed_list &in, int _iRetCount, type
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_cos";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_cos";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index cecb26c..406bd86 100644 (file)
@@ -81,8 +81,8 @@ types::Function::ReturnValue sci_cosh(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_cosh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_cosh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 0019c29..67c9cf8 100644 (file)
@@ -93,8 +93,8 @@ types::Function::ReturnValue sci_cumprod(types::typed_list &in, int _iRetCount,
             pDblIn = getAsDouble(in[0]->getAs<types::UInt64>());
             break;
         default :
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_cumprod";
-            return Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_cumprod";
+            return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in.size() >= 2)
@@ -142,21 +142,21 @@ types::Function::ReturnValue sci_cumprod(types::typed_list &in, int _iRetCount,
                 return types::Function::Error;
             }
 
-            wchar_t* wcsString = pStr->get(0);
+            char* str = pStr->get(0);
 
-            if (wcscmp(wcsString, L"*") == 0)
+            if (strcmp(str, "*") == 0)
             {
                 iOrientation = 0;
             }
-            else if (wcscmp(wcsString, L"r") == 0)
+            else if (strcmp(str, "r") == 0)
             {
                 iOrientation = 1;
             }
-            else if (wcscmp(wcsString, L"c") == 0)
+            else if (strcmp(str, "c") == 0)
             {
                 iOrientation = 2;
             }
-            else if (wcscmp(wcsString, L"m") == 0)
+            else if (strcmp(str, "m") == 0)
             {
                 int iDims = 0;
                 int* piDimsArray = NULL;
@@ -182,11 +182,11 @@ types::Function::ReturnValue sci_cumprod(types::typed_list &in, int _iRetCount,
                     }
                 }
             }
-            else if ((wcscmp(wcsString, L"native") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "native") == 0) && (in.size() == 2))
             {
                 iOuttype = 1;
             }
-            else if ((wcscmp(wcsString, L"double") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "double") == 0) && (in.size() == 2))
             {
                 iOuttype = 2;
             }
@@ -249,13 +249,13 @@ types::Function::ReturnValue sci_cumprod(types::typed_list &in, int _iRetCount,
             return types::Function::Error;
         }
 
-        wchar_t* wcsString = pStr->get(0);
+        char* str = pStr->get(0);
 
-        if (wcscmp(wcsString, L"native") == 0)
+        if (strcmp(str, "native") == 0)
         {
             iOuttype = 1;
         }
-        else if (wcscmp(wcsString, L"double") == 0)
+        else if (strcmp(str, "double") == 0)
         {
             iOuttype = 2;
         }
index accd33b..7d5407b 100644 (file)
@@ -92,8 +92,8 @@ types::Function::ReturnValue sci_cumsum(types::typed_list &in, int _iRetCount, t
             pDblIn = getAsDouble(in[0]->getAs<types::UInt64>());
             break;
         default:
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_cumsum";
-            return Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_cumsum";
+            return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
 
@@ -142,21 +142,21 @@ types::Function::ReturnValue sci_cumsum(types::typed_list &in, int _iRetCount, t
                 return types::Function::Error;
             }
 
-            wchar_t* wcsString = pStr->get(0);
+            char* str = pStr->get(0);
 
-            if (wcscmp(wcsString, L"*") == 0)
+            if (strcmp(str, "*") == 0)
             {
                 iOrientation = 0;
             }
-            else if (wcscmp(wcsString, L"r") == 0)
+            else if (strcmp(str, "r") == 0)
             {
                 iOrientation = 1;
             }
-            else if (wcscmp(wcsString, L"c") == 0)
+            else if (strcmp(str, "c") == 0)
             {
                 iOrientation = 2;
             }
-            else if (wcscmp(wcsString, L"m") == 0)
+            else if (strcmp(str, "m") == 0)
             {
                 int iDims = 0;
                 int* piDimsArray = NULL;
@@ -182,11 +182,11 @@ types::Function::ReturnValue sci_cumsum(types::typed_list &in, int _iRetCount, t
                     }
                 }
             }
-            else if ((wcscmp(wcsString, L"native") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "native") == 0) && (in.size() == 2))
             {
                 iOuttype = 1;
             }
-            else if ((wcscmp(wcsString, L"double") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "double") == 0) && (in.size() == 2))
             {
                 iOuttype = 2;
             }
@@ -249,13 +249,13 @@ types::Function::ReturnValue sci_cumsum(types::typed_list &in, int _iRetCount, t
             return types::Function::Error;
         }
 
-        wchar_t* wcsString = pStr->get(0);
+        char* str = pStr->get(0);
 
-        if (wcscmp(wcsString, L"native") == 0)
+        if (strcmp(str, "native") == 0)
         {
             iOuttype = 1;
         }
-        else if (wcscmp(wcsString, L"double") == 0)
+        else if (strcmp(str, "double") == 0)
         {
             iOuttype = 2;
         }
index 8184d4a..85a5a04 100644 (file)
@@ -47,14 +47,14 @@ types::Function::ReturnValue sci_diag(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isGenericType() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_diag";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_diag";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in[0]->getAs<types::GenericType>()->getDims() > 2)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_diag";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_diag";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in.size() == 2)
@@ -116,8 +116,8 @@ types::Function::ReturnValue sci_diag(types::typed_list &in, int _iRetCount, typ
             break;
         default :
         {
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_diag";
-            return Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_diag";
+            return Overload::call(stFuncName, in, _iRetCount, out);
         }
     }
 
index 398f07a..c8ce19f 100644 (file)
@@ -55,7 +55,7 @@ types::Function::ReturnValue sci_dsearch(types::typed_list &in, int _iRetCount,
     // input data
     if (in[0]->isDouble() == false || in[1]->isDouble() == false)
     {
-        std::wstring stType;
+        std::string stType;
         //build manually overload name
         if (in[0]->isDouble() == false)
         {
@@ -66,7 +66,7 @@ types::Function::ReturnValue sci_dsearch(types::typed_list &in, int _iRetCount,
             stType = in[1]->getShortTypeStr();
         }
 
-        return Overload::call(L"%" + stType + L"_dsearch", in, _iRetCount, out);
+        return Overload::call("%" + stType + "_dsearch", in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
@@ -110,13 +110,13 @@ types::Function::ReturnValue sci_dsearch(types::typed_list &in, int _iRetCount,
             return types::Function::Error;
         }
 
-        wchar_t* wcsString = in[2]->getAs<types::String>()->get(0);
+        char* str = in[2]->getAs<types::String>()->get(0);
 
-        if (wcscmp(wcsString, L"c") == 0)
+        if (strcmp(str, "c") == 0)
         {
             iTypeSearch = 1;
         }
-        else if (wcscmp(wcsString, L"d") == 0)
+        else if (strcmp(str, "d") == 0)
         {
             iTypeSearch = 0;
         }
index 071e38f..6be5e89 100644 (file)
@@ -116,8 +116,8 @@ types::Function::ReturnValue sci_exp(types::typed_list &in, int _iRetCount, type
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_exp";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_exp";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 03f109b..fc21f07 100644 (file)
@@ -42,15 +42,15 @@ types::Function::ReturnValue sci_expm(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_expm";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_expm";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
 
     if (pDblIn->getDims() > 2)
     {
-        return Overload::call(L"%hm_expm", in, _iRetCount, out);
+        return Overload::call("%hm_expm", in, _iRetCount, out);
     }
 
     if (pDblIn->getSize() == 0)
index 755168e..13f44c8 100644 (file)
@@ -47,7 +47,7 @@ types::Function::ReturnValue sci_eye(types::typed_list &in, int _iRetCount, type
             case 1:
             {
                 //call overload
-                return Overload::generateNameAndCall(L"eye", in, _iRetCount, out);
+                return Overload::generateNameAndCall("eye", in, _iRetCount, out);
             }
         }
 
index bb2be38..bb9bb1b 100644 (file)
@@ -161,8 +161,8 @@ types::Function::ReturnValue sci_floor(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_floor";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_floor";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 38d1671..28be01f 100644 (file)
@@ -42,16 +42,16 @@ types::Function::ReturnValue sci_frexp(types::typed_list &in, int _iRetCount, ty
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_frexp";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_frexp";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::Double* pDblIn = in[0]->getAs<types::Double>();
 
     if (pDblIn->getDims() > 2)
     {
-        std::wstring wstFuncName = L"%hm_frexp";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%hm_frexp";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (pDblIn->isComplex())
index f744b9c..839e364 100644 (file)
@@ -29,8 +29,8 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
 {
     types::Double* pDblInd = NULL;
 
-    std::wstring wstrWay     = L"d";
-    std::wstring wstrProcess = L"g";
+    std::string strWay     = "d";
+    std::string strProcess = "g";
 
     if (in.size() < 1 || in.size() > 3)
     {
@@ -53,8 +53,8 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
             return types::Function::Error;
         }
 
-        wstrWay = in[2]->getAs<types::String>()->get(0);
-        if (wstrWay != L"i" && wstrWay != L"d")
+        strWay = in[2]->getAs<types::String>()->get(0);
+        if (strWay != "i" && strWay != "d")
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: ['i' 'd'] expected.\n"), "gsort", 3);
             return types::Function::Error;
@@ -69,13 +69,13 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
             return types::Function::Error;
         }
 
-        wstrProcess = in[1]->getAs<types::String>()->get(0);
+        strProcess = in[1]->getAs<types::String>()->get(0);
 
-        if ( wstrProcess != L"c"  &&
-                wstrProcess != L"r"  &&
-                wstrProcess != L"g"  &&
-                wstrProcess != L"lc" &&
-                wstrProcess != L"lr")
+        if ( strProcess != "c"  &&
+                strProcess != "r"  &&
+                strProcess != "g"  &&
+                strProcess != "lc" &&
+                strProcess != "lr")
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: ['g' 'r' 'c' 'lc' 'lr'] expected.\n"), "gsort", 2);
             return types::Function::Error;
@@ -85,21 +85,21 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
     // get data and perform operation for each types::
     if (in[0]->isGenericType() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_gsort";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_gsort";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::GenericType* pGTOut = in[0]->getAs<types::GenericType>();
 
     if (pGTOut->getDims() > 2)
     {
-        return Overload::call(L"%hm_gsort", in, _iRetCount, out);
+        return Overload::call("%hm_gsort", in, _iRetCount, out);
     }
 
     if (_iRetCount == 2)
     {
-        int iRowsInd = (wstrProcess == L"lc") ? 1 : pGTOut->getRows();
-        int iColsInd = (wstrProcess == L"lr") ? 1 : pGTOut->getCols();
+        int iRowsInd = (strProcess == "lc") ? 1 : pGTOut->getRows();
+        int iColsInd = (strProcess == "lr") ? 1 : pGTOut->getCols();
 
         pDblInd = new types::Double(iRowsInd, iColsInd);
     }
@@ -108,17 +108,17 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
     {
         types::Double* pDblIn = in[0]->getAs<types::Double>();
         // doc says : "With complex numbers, gsort can be overloaded"
-        if (pDblIn->isComplex() && symbol::Context::getInstance()->getFunction(symbol::Symbol(L"%_gsort")))
+        if (pDblIn->isComplex() && symbol::Context::getInstance()->getFunction(symbol::Symbol("%_gsort")))
         {
             if (_iRetCount == 2)
             {
                 delete pDblInd;
             }
 
-            return Overload::call(L"%_gsort", in, _iRetCount, out);
+            return Overload::call("%_gsort", in, _iRetCount, out);
         }
 
-        types::Double* pDblOut = gsort(pDblIn, pDblInd, wstrWay, wstrProcess);
+        types::Double* pDblOut = gsort(pDblIn, pDblInd, strWay, strProcess);
         out.push_back(pDblOut);
     }
     else if (in[0]->isSparse()) // sparse
@@ -128,67 +128,67 @@ types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, ty
             delete pDblInd;
         }
 
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_gsort";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_gsort";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
     else if (in[0]->isString()) // string
     {
         types::String* pStringIn = in[0]->getAs<types::String>();
-        types::String* pStringOut = gsort(pStringIn, pDblInd, wstrWay, wstrProcess);
+        types::String* pStringOut = gsort(pStringIn, pDblInd, strWay, strProcess);
         out.push_back(pStringOut);
     }
     else if (in[0]->isInt8()) // int
     {
         types::Int8* pIIn = in[0]->getAs<types::Int8>();
-        types::Int8* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::Int8* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isInt16())
     {
         types::Int16* pIIn = in[0]->getAs<types::Int16>();
-        types::Int16* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::Int16* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isInt32())
     {
         types::Int32* pIIn = in[0]->getAs<types::Int32>();
-        types::Int32* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::Int32* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isInt64())
     {
         types::Int64* pIIn = in[0]->getAs<types::Int64>();
-        types::Int64* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::Int64* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isUInt8()) // uint
     {
         types::UInt8* pIIn = in[0]->getAs<types::UInt8>();
-        types::UInt8* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::UInt8* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isUInt16())
     {
         types::UInt16* pIIn = in[0]->getAs<types::UInt16>();
-        types::UInt16* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::UInt16* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isUInt32())
     {
         types::UInt32* pIIn = in[0]->getAs<types::UInt32>();
-        types::UInt32* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::UInt32* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else if (in[0]->isUInt64())
     {
         types::UInt64* pIIn = in[0]->getAs<types::UInt64>();
-        types::UInt64* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
+        types::UInt64* pIOut = gsort(pIIn, pDblInd, strWay, strProcess);
         out.push_back(pIOut);
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_gsort";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_gsort";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     /***** set result *****/
index a85df2d..ccd85ca 100644 (file)
@@ -144,8 +144,8 @@ types::Function::ReturnValue sci_imag(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_imag";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_imag";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 3fbb7ac..fc942dc 100644 (file)
@@ -145,8 +145,8 @@ types::Function::ReturnValue sci_imult(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_imult";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_imult";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 85b87f9..245f8d2 100644 (file)
@@ -211,8 +211,8 @@ types::Function::ReturnValue sci_int(types::typed_list &in, int _iRetCount, type
 
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_int";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_int";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index f9c784e..76d13a5 100644 (file)
@@ -157,8 +157,8 @@ types::Function::ReturnValue sci_isreal(types::typed_list &in, int _iRetCount, t
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_isreal";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_isreal";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 267c9d1..c149d87 100644 (file)
@@ -51,12 +51,12 @@ types::Function::ReturnValue sci_kron(types::typed_list &in, int _iRetCount, typ
     else if (in[0]->isInt() || in[1]->isInt())
     {
         // int .*. double || double .*. int || int .*. int
-        return Overload::call(L"%_kron", in, _iRetCount, out);
+        return Overload::call("%_kron", in, _iRetCount, out);
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_kron";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_kron";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     out.push_back(pDblOut);
index ea0ca9d..d16af6d 100644 (file)
@@ -50,8 +50,8 @@ types::Function::ReturnValue sci_log(types::typed_list &in, int _iRetCount, type
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_log";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_log";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::Double* pDblIn = in[0]->getAs<types::Double>();
index ea416fd..a55b539 100644 (file)
@@ -47,8 +47,8 @@ types::Function::ReturnValue sci_log1p(types::typed_list &in, int _iRetCount, ty
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_log1p";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_log1p";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::Double* pDblIn = in[0]->getAs<types::Double>();
index 45572f2..8470cfe 100644 (file)
@@ -50,8 +50,8 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
             in[0]->isSparse()       == false &&
             in[0]->isSparseBool()   == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_matrix";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_matrix";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pGTIn = in[0]->getAs<types::GenericType>();
@@ -173,11 +173,10 @@ types::Function::ReturnValue sci_matrix(types::typed_list &in, int _iRetCount, t
         return types::Function::Error;
     }
 
-    bOk = pGTOut->reshape(piSizes, iDims);
+    pGTOut = pGTOut->reshape(piSizes, iDims);
 
-    if (bOk == false)
+    if (pGTOut == nullptr)
     {
-        pGTOut->killMe();
         Scierror(999, _("%s: Input and output matrices must have the same number of elements.\n"), "matrix");
         return types::Function::Error;
     }
index 23b7987..87b8a5e 100644 (file)
@@ -97,10 +97,8 @@ types::Function::ReturnValue sci_MinMax(types::typed_list &in, int _iRetCount, t
 
     if (inputs[0]->isDouble() == false && inputs[0]->isInt() == false)
     {
-        wchar_t* wcsMinMax = to_wide_string(fname);
-        std::wstring wstFuncName = L"%" + inputs[0]->getShortTypeStr() + L"_" + wcsMinMax;
-        FREE(wcsMinMax);
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + inputs[0]->getShortTypeStr() + "_" + fname;
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::GenericType* pGT = NULL;
@@ -137,16 +135,16 @@ types::Function::ReturnValue sci_MinMax(types::typed_list &in, int _iRetCount, t
 
     if (inputs.size() == 2 && inputs[1]->isString())
     {
-        std::wstring wcsOrientation = inputs[1]->getAs<types::String>()->get(0);
-        if (wcsOrientation == L"r")
+        std::string orientation = inputs[1]->getAs<types::String>()->get(0);
+        if (orientation == "r")
         {
             iOrientation = 1;
         }
-        else if (wcsOrientation == L"c")
+        else if (orientation == "c")
         {
             iOrientation = 2;
         }
-        else if (wcsOrientation == L"m")
+        else if (orientation == "m")
         {
             // old function was "mtlsel"
             for (int i = 0; i < iDims; i++)
@@ -158,7 +156,7 @@ types::Function::ReturnValue sci_MinMax(types::typed_list &in, int _iRetCount, t
                 }
             }
         }
-        else if (wcsOrientation == L"*")
+        else if (orientation == "*")
         {
             iOrientation = 0;
         }
index 36a20c3..05d2181 100644 (file)
@@ -45,7 +45,7 @@ types::Function::ReturnValue sci_ones(types::typed_list &in, int _iRetCount, typ
             case 1:
             {
                 //call overload
-                return Overload::generateNameAndCall(L"ones", in, _iRetCount, out);
+                return Overload::generateNameAndCall("ones", in, _iRetCount, out);
             }
         }
 
index 7fdf6ad..9729112 100644 (file)
@@ -120,8 +120,8 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
         }
         default:
         {
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_prod";
-            return Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_prod";
+            return Overload::call(stFuncName, in, _iRetCount, out);
         }
     }
 
@@ -170,21 +170,21 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
                 return types::Function::Error;
             }
 
-            wchar_t* wcsString = pStr->get(0);
+            char* str = pStr->get(0);
 
-            if (wcscmp(wcsString, L"*") == 0)
+            if (strcmp(str, "*") == 0)
             {
                 iOrientation = 0;
             }
-            else if (wcscmp(wcsString, L"r") == 0)
+            else if (strcmp(str, "r") == 0)
             {
                 iOrientation = 1;
             }
-            else if (wcscmp(wcsString, L"c") == 0)
+            else if (strcmp(str, "c") == 0)
             {
                 iOrientation = 2;
             }
-            else if (wcscmp(wcsString, L"m") == 0)
+            else if (strcmp(str, "m") == 0)
             {
                 int iDims = 0;
                 int* piDimsArray = NULL;
@@ -210,11 +210,11 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
                     }
                 }
             }
-            else if ((wcscmp(wcsString, L"native") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "native") == 0) && (in.size() == 2))
             {
                 iOuttype = 1;
             }
-            else if ((wcscmp(wcsString, L"double") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "double") == 0) && (in.size() == 2))
             {
                 iOuttype = 2;
             }
@@ -277,13 +277,13 @@ types::Function::ReturnValue sci_prod(types::typed_list &in, int _iRetCount, typ
             return types::Function::Error;
         }
 
-        wchar_t* wcsString = pStr->get(0);
+        char* str = pStr->get(0);
 
-        if (wcscmp(wcsString, L"native") == 0)
+        if (strcmp(str, "native") == 0)
         {
             iOuttype = 1;
         }
-        else if (wcscmp(wcsString, L"double") == 0)
+        else if (strcmp(str, "double") == 0)
         {
             iOuttype = 2;
         }
index 5b4ec2a..9b469ba 100644 (file)
@@ -24,13 +24,13 @@ extern "C"
 #include "basic_functions.h"
 }
 
-const wchar_t g_pwstConfigInfo[] = {L"info"};
-const wchar_t g_pwstConfigSeed[] = {L"seed"};
+const char g_pstConfigInfo[] = "info";
+const char g_pstConfigSeed[] = "seed";
 
-const wchar_t g_pwstTypeUniform[] = {L"uniform"};
-const wchar_t g_pwstTypeNormal[] = {L"normal"};
+const char g_pstTypeUniform[] = "uniform";
+const char g_pstTypeNormal[] = "normal";
 
-int setRandType(wchar_t _wcType);
+int setRandType(char _wcType);
 double getNextRandValue(int _iRandType, int* _piRandSave, int _iForceInit);
 
 /*
@@ -64,9 +64,9 @@ types::Function::ReturnValue sci_rand(types::typed_list &in, int _iRetCount, typ
             return types::Function::Error;
         }
 
-        wchar_t* pwstKey = pS->get(0);
+        char* key = pS->get(0);
 
-        if (pwstKey[0] == g_pwstConfigInfo[0])
+        if (key[0] == g_pstConfigInfo[0])
         {
             //info
             if (iSizeIn > 1)
@@ -77,14 +77,14 @@ types::Function::ReturnValue sci_rand(types::typed_list &in, int _iRetCount, typ
 
             if (siRandType == 0)
             {
-                out.push_back(new types::String(g_pwstTypeUniform));
+                out.push_back(new types::String(g_pstTypeUniform));
             }
             else
             {
-                out.push_back(new types::String(g_pwstTypeNormal));
+                out.push_back(new types::String(g_pstTypeNormal));
             }
         }
-        else if (pwstKey[0] == g_pwstConfigSeed[0])
+        else if (key[0] == g_pstConfigSeed[0])
         {
             //seed
             if (iSizeIn == 1)
@@ -111,7 +111,7 @@ types::Function::ReturnValue sci_rand(types::typed_list &in, int _iRetCount, typ
         }
         else
         {
-            siRandType = setRandType(pwstKey[0]);
+            siRandType = setRandType(key[0]);
         }
     }
     else
@@ -151,7 +151,7 @@ types::Function::ReturnValue sci_rand(types::typed_list &in, int _iRetCount, typ
                 case 1:
                 {
                     //call overload
-                    return Overload::generateNameAndCall(L"rand", in, _iRetCount, out);
+                    return Overload::generateNameAndCall("rand", in, _iRetCount, out);
                 }
             }
 
@@ -234,7 +234,7 @@ double getNextRandValue(int _iRandType, int* _piRandSave, int _iForceInit)
     return dblVal;
 }
 
-int setRandType(wchar_t _wcType)
+int setRandType(char _wcType)
 {
     if (_wcType == L'g' || _wcType == L'n')
     {
index eda8863..7980c75 100644 (file)
@@ -53,21 +53,21 @@ types::Function::ReturnValue sci_rat(types::typed_list &in, int _iRetCount, type
     /***** get data *****/
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_rat";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_rat";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
 
     if (pDblIn->getDims() > 2)
     {
-        return Overload::call(L"%hm_rat", in, _iRetCount, out);
+        return Overload::call("%hm_rat", in, _iRetCount, out);
     }
 
     if (pDblIn->isComplex())
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_rat";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_rat";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in.size() == 2)
index 42a7049..f04a913 100644 (file)
@@ -103,8 +103,8 @@ types::Function::ReturnValue sci_real(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_real";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_real";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index f7fbe8d..e763d22 100644 (file)
@@ -114,8 +114,8 @@ types::Function::ReturnValue sci_round(types::typed_list &in, int _iRetCount, ty
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_round";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_round";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 }
 /*--------------------------------------------------------------------------*/
index 0a33729..d492a27 100644 (file)
@@ -95,8 +95,8 @@ types::Function::ReturnValue sci_sign(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sign";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_sign";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 1bbcf81..3e593b4 100644 (file)
@@ -98,8 +98,8 @@ types::Function::ReturnValue sci_sin(types::typed_list &in, int _iRetCount, type
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sin";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_sin";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 380b152..8b397c7 100644 (file)
@@ -81,8 +81,8 @@ types::Function::ReturnValue sci_sinh(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sinh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_sinh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index d32522e..46d2a52 100644 (file)
@@ -43,18 +43,18 @@ types::Function::ReturnValue sci_size(types::typed_list &in, int _iRetCount, typ
         // Dedicated case for lists.
         case types::InternalType::ScilabMList:
         {
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_size";
-            Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_size";
+            Overload::call(stFuncName, in, _iRetCount, out);
             break;
         }
         case types::InternalType::ScilabTList:
         {
             // calls the overload if it exists.
-            std::wstring wstFuncName = L"%"  + in[0]->getTypeStr() + L"_size";
-            types::InternalType *pIT = symbol::Context::getInstance()->get(symbol::Symbol(wstFuncName));
+            std::string stFuncName = "%"  + in[0]->getTypeStr() + "_size";
+            types::InternalType *pIT = symbol::Context::getInstance()->get(symbol::Symbol(stFuncName));
             if (pIT)
             {
-                return Overload::call(wstFuncName, in, _iRetCount, out);
+                return Overload::call(stFuncName, in, _iRetCount, out);
             }
         }
         case types::InternalType::ScilabList:
@@ -74,8 +74,8 @@ types::Function::ReturnValue sci_size(types::typed_list &in, int _iRetCount, typ
         {
             if (in[0]->isGenericType() == false)
             {
-                std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_size";
-                return Overload::call(wstFuncName, in, _iRetCount, out);
+                std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_size";
+                return Overload::call(stFuncName, in, _iRetCount, out);
             }
             int iMode = -1;
 
index 6ff58b3..be80070 100644 (file)
@@ -39,8 +39,8 @@ types::Function::ReturnValue sci_sqrt(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sqrt";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_sqrt";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     types::Double* input = in[0]->getAs<types::Double>();
index 7963a21..5faaabd 100644 (file)
@@ -115,8 +115,8 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
         }
         default:
         {
-            std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_sum";
-            types::Function::ReturnValue ret = Overload::call(wstFuncName, in, _iRetCount, out);
+            std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_sum";
+            types::Function::ReturnValue ret = Overload::call(stFuncName, in, _iRetCount, out);
 
             if (isCopy && pDblIn)
             {
@@ -172,21 +172,21 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
                 return types::Function::Error;
             }
 
-            wchar_t* wcsString = pStr->get(0);
+            char* str = pStr->get(0);
 
-            if (wcscmp(wcsString, L"*") == 0)
+            if (strcmp(str, "*") == 0)
             {
                 iOrientation = 0;
             }
-            else if (wcscmp(wcsString, L"r") == 0)
+            else if (strcmp(str, "r") == 0)
             {
                 iOrientation = 1;
             }
-            else if (wcscmp(wcsString, L"c") == 0)
+            else if (strcmp(str, "c") == 0)
             {
                 iOrientation = 2;
             }
-            else if (wcscmp(wcsString, L"m") == 0)
+            else if (strcmp(str, "m") == 0)
             {
                 int iDims = 0;
                 int* piDimsArray = NULL;
@@ -212,11 +212,11 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
                     }
                 }
             }
-            else if ((wcscmp(wcsString, L"native") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "native") == 0) && (in.size() == 2))
             {
                 iOuttype = 1;
             }
-            else if ((wcscmp(wcsString, L"double") == 0) && (in.size() == 2))
+            else if ((strcmp(str, "double") == 0) && (in.size() == 2))
             {
                 iOuttype = 2;
             }
@@ -279,13 +279,13 @@ types::Function::ReturnValue sci_sum(types::typed_list &in, int _iRetCount, type
             return types::Function::Error;
         }
 
-        wchar_t* wcsString = pStr->get(0);
+        char* str = pStr->get(0);
 
-        if (wcscmp(wcsString, L"native") == 0)
+        if (strcmp(str, "native") == 0)
         {
             iOuttype = 1;
         }
-        else if (wcscmp(wcsString, L"double") == 0)
+        else if (strcmp(str, "double") == 0)
         {
             iOuttype = 2;
         }
index 939a475..f60a017 100644 (file)
@@ -49,8 +49,8 @@ types::Function::ReturnValue sci_tan(types::typed_list &in, int _iRetCount, type
 
     if (in[0]->isDouble() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_tan";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_tan";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     pDblIn = in[0]->getAs<types::Double>();
index 63af171..9215ae8 100644 (file)
@@ -81,8 +81,8 @@ types::Function::ReturnValue sci_tanh(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_tanh";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_tanh";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index c363503..969896c 100644 (file)
@@ -48,14 +48,14 @@ types::Function::ReturnValue sci_tril(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isGenericType() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_tril";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_tril";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in[0]->getAs<types::GenericType>()->getDims() > 2)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_tril";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_tril";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     // get offset
@@ -154,8 +154,8 @@ types::Function::ReturnValue sci_tril(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_tril";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_tril";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 2ba6c13..9e8332a 100644 (file)
@@ -50,14 +50,14 @@ types::Function::ReturnValue sci_triu(types::typed_list &in, int _iRetCount, typ
 
     if (in[0]->isGenericType() == false)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_triu";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in[0]->getAs<types::GenericType>()->getDims() > 2)
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_triu";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     if (in.size() == 2)
@@ -142,8 +142,8 @@ types::Function::ReturnValue sci_triu(types::typed_list &in, int _iRetCount, typ
     }
     else
     {
-        std::wstring wstFuncName = L"%" + in[0]->getShortTypeStr() + L"_triu";
-        return Overload::call(wstFuncName, in, _iRetCount, out);
+        std::string stFuncName = "%" + in[0]->getShortTypeStr() + "_triu";
+        return Overload::call(stFuncName, in, _iRetCount, out);
     }
 
     return types::Function::OK;
index 73734d2..d634158 100644 (file)
@@ -45,7 +45,7 @@ types::Function::ReturnValue sci_zeros(types::typed_list &in, int _iRetCount, ty
             case 1:
             {
                 //call overload
-                return Overload::generateNameAndCall(L"zeros", in, _iRetCount, out);
+                return Overload::generateNameAndCall("zeros", in, _iRetCount, out);
             }
         }
 
index 2fc7fd4..b905aed 100644 (file)
@@ -300,7 +300,6 @@ lib /DEF:"$(ProjectDir)cacsd_f_Import.def" /SUBSYSTEM:WINDOWS /MACHINE:$(Platfor
     <ClInclude Include="..\cpp\cumprod.hxx" />
     <ClInclude Include="..\cpp\cumsum.hxx" />
     <ClInclude Include="..\cpp\diag.hxx" />
-    <ClInclude Include="..\cpp\gsort.hxx" />
     <ClInclude Include="..\cpp\max.hxx" />
     <ClInclude Include="..\cpp\min.hxx" />
     <ClInclude Include="..\cpp\prod.hxx" />
index 96b4983..62cd55c 100644 (file)
     <ClInclude Include="..\cpp\diag.hxx">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\cpp\gsort.hxx">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="..\cpp\max.hxx">
       <Filter>Header Files</Filter>
     </ClInclude>
index 02714bb..dc50201 100644 (file)
@@ -148,7 +148,7 @@ types::InternalType* diag(types::String* pIn,  int iStartPos)
 
         for (int i = 0; i < iSize * iSize; i++)
         {
-            pStrOut->set(i, L"");
+            pStrOut->set(i, "");
         }
 
         for (int i = 0; i < iSizeOfVector; i++)
index 8672b39..afe743e 100644 (file)
@@ -120,29 +120,29 @@ bool descendent (std::pair<int, std::pair<T*, T*> > left, std::pair<int, std::pa
 }
 
 // string case
-bool increasingCompareStr (wchar_t* left, wchar_t* right)
+bool increasingCompareStr (char* left, char* right)
 {
-    return wcscmp(left, right) < 0;
+    return strcmp(left, right) < 0;
 }
 
-bool descendentCompareStr (wchar_t* left, wchar_t* right)
+bool descendentCompareStr (char* left, char* right)
 {
-    return wcscmp(left, right) > 0;
+    return strcmp(left, right) > 0;
 }
 
-bool descendentStr (std::pair<int, std::pair<wchar_t**, wchar_t**> > left, std::pair<int, std::pair<wchar_t**, wchar_t**> > right)
+bool descendentStr (std::pair<int, std::pair<char**, char**> > left, std::pair<int, std::pair<char**, char**> > right)
 {
     return std::lexicographical_compare(right.second.first, right.second.second, left.second.first, left.second.second, increasingCompareStr);
 }
 
-bool increasingStr (std::pair<int, std::pair<wchar_t**, wchar_t**> > left, std::pair<int, std::pair<wchar_t**, wchar_t**> > right)
+bool increasingStr (std::pair<int, std::pair<char**, char**> > left, std::pair<int, std::pair<char**, char**> > right)
 {
     return std::lexicographical_compare(left.second.first, left.second.second, right.second.first, right.second.second, increasingCompareStr);
 }
 
-bool descendentStr (std::pair<int, wchar_t*> left, std::pair<int, wchar_t*> right)
+bool descendentStr (std::pair<int, char*> left, std::pair<int, char*> right)
 {
-    int comp = wcscmp(left.second, right.second);
+    int comp = strcmp(left.second, right.second);
     // keep position order (position order is always increasing)
     if (comp == 0)
     {
@@ -152,9 +152,9 @@ bool descendentStr (std::pair<int, wchar_t*> left, std::pair<int, wchar_t*> righ
     return comp > 0;
 }
 
-bool increasingStr (std::pair<int, wchar_t*> left, std::pair<int, wchar_t*> right)
+bool increasingStr (std::pair<int, char*> left, std::pair<int, char*> right)
 {
-    int comp = wcscmp(left.second, right.second);
+    int comp = strcmp(left.second, right.second);
     // keep position order (position order is always increasing)
     if (comp == 0)
     {
@@ -165,7 +165,7 @@ bool increasingStr (std::pair<int, wchar_t*> left, std::pair<int, wchar_t*> righ
 }
 
 /*--------------------------- Double ---------------------------------------*/
-types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::Double* pOut = NULL;
 
@@ -194,30 +194,30 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
                       std::pair<int, std::pair<double*, double*> > right);
 
     // sort direction
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWayBasic   = &(increasing);
         pFuncWay        = &(increasing);
         pFuncWayL       = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWayBasic   = &(descendent);
         pFuncWay        = &(descendent);
         pFuncWayL       = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
@@ -230,7 +230,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
         double* pdblOutR = pOut->get();
         double* pdblOutI = pOut->getImg();
 
-        if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+        if (strProcess == "r" || strProcess == "c" || strProcess == "g")
         {
             std::vector<std::pair<std::pair<int, int>, double> > V;
             std::vector<std::pair<std::pair<int, int>, double> >::iterator it;
@@ -259,7 +259,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
                 V.clear();
             }
         }
-        else// wstrProcess == L"lr" and wstrProcess == L"lc"
+        else// strProcess == "lr" and strProcess == "lc"
         {
             std::vector<std::pair<int, std::pair<double*, double*> > > V;
             std::vector<std::pair<int, std::pair<double*, double*> > >::iterator it;
@@ -267,7 +267,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
             types::Double* pTemp = new types::Double(pIn->getRows(), pIn->getCols());
             double* pdblTemp = pTemp->get();
 
-            if (wstrProcess == L"lr")
+            if (strProcess == "lr")
             {
                 // transpose matrix pIn
                 types::Double* pTemp = pIn;
@@ -310,7 +310,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
             delete pTemp;
             pTemp = NULL;
 
-            if (wstrProcess == L"lr")
+            if (strProcess == "lr")
             {
                 delete pIn;
             }
@@ -318,7 +318,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
     }
     else
     {
-        if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+        if (strProcess == "r" || strProcess == "c" || strProcess == "g")
         {
             if (pDblInd)
             {
@@ -350,13 +350,13 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
             }
             else
             {
-                if (wstrProcess == L"g")
+                if (strProcess == "g")
                 {
                     pOut = pIn->clone()->getAs<types::Double>();
                     double* pdblOutR = pOut->get();
                     std::sort(pdblOutR, pdblOutR + pOut->getSize(), (*pFuncWayBasic));
                 }
-                else if (wstrProcess == L"c")
+                else if (strProcess == "c")
                 {
                     pOut = new types::Double(pIn->getCols(), pIn->getRows());
                     double* pdblOutR = pOut->get();
@@ -376,7 +376,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
                     vTransposeRealMatrix(pTemp->get(), pTemp->getRows(), pTemp->getCols(), pdblOutR);
                     delete pTemp;
                 }
-                else //wstrProcess == L"r"
+                else //strProcess == "r"
                 {
                     pOut = pIn->clone()->getAs<types::Double>();
                     double* pdblOutR = pOut->get();
@@ -388,7 +388,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
                 }
             }
         }
-        else// wstrProcess == L"lr" and wstrProcess == L"lc"
+        else// strProcess == "lr" and strProcess == "lc"
         {
             pOut = new types::Double(pIn->getDims(), pIn->getDimsArray());
             double* pdblOutR = pOut->get();
@@ -396,7 +396,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
             std::vector<std::pair<int, std::pair<double*, double*> > > V;
             std::vector<std::pair<int, std::pair<double*, double*> > >::iterator it;
 
-            if (wstrProcess == L"lr")
+            if (strProcess == "lr")
             {
                 // transpose matrix pIn
                 types::Double* pTemp = pIn;
@@ -428,7 +428,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
             }
 
             V.clear();
-            if (wstrProcess == L"lr")
+            if (strProcess == "lr")
             {
                 delete pIn;
             }
@@ -439,7 +439,7 @@ types::Double* gsort(types::Double* pIn, types::Double* pDblInd, const std::wstr
 }
 
 /*--------------------------- String ---------------------------------------*/
-types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::String* pOut = nullptr;
 
@@ -451,68 +451,68 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
     int iOffset1    = 1;
     int iOffset2    = 1;
 
-    bool (*pFuncWayStr)(std::pair<int, wchar_t*> left,
-                        std::pair<int, wchar_t*> right);
+    bool (*pFuncWayStr)(std::pair<int, char*> left,
+                        std::pair<int, char*> right);
 
-    bool (*pFuncWayStrL)(std::pair<int, std::pair<wchar_t**, wchar_t**> > left,
-                         std::pair<int, std::pair<wchar_t**, wchar_t**> > right);
+    bool (*pFuncWayStrL)(std::pair<int, std::pair<char**, char**> > left,
+                         std::pair<int, std::pair<char**, char**> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWayStr = &(increasingStr);
         pFuncWayStrL = &(increasingStr);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWayStr = &(descendentStr);
         pFuncWayStrL = &(descendentStr);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c")
+    else if (strProcess == "c")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r")
+    else if (strProcess == "r")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
-    else if (wstrProcess == L"lc")
+    else if (strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
-    else if (wstrProcess == L"lr")
+    else if (strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         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;
+            std::vector<std::pair<int, char*> > V;
+            std::vector<std::pair<int, char*> >::iterator it;
 
             for (int i = 0; i < iTimes; i++)
             {
                 for (int j = 0; j < iItem; j++)
                 {
                     iPos = i * iOffset2 + j * iOffset1;
-                    wchar_t* pWcsData = pIn->get(iPos);
-                    V.push_back(std::pair<int, wchar_t*>(j, pWcsData));
+                    char* pWcsData = pIn->get(iPos);
+                    V.push_back(std::pair<int, char*>(j, pWcsData));
                 }
 
                 std::sort(V.begin(), V.end(), (*pFuncWayStr));
@@ -532,25 +532,25 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::String>();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(pOut->get(), pOut->get() + pOut->getSize(), increasingCompareStr);
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(pOut->get(), pOut->get() + pOut->getSize(), descendentCompareStr);
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::String(pIn->getRows(), pIn->getCols());
 
                 // transpose matrix pIn
-                wchar_t** pwstOut = new wchar_t*[pIn->getSize()];
-                wchar_t** pwstIn = pIn->get();
+                char** pwstOut = new char*[pIn->getSize()];
+                char** pwstIn = pIn->get();
                 int iRows = pIn->getRows();
                 int iCols = pIn->getCols();
 
@@ -561,14 +561,14 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(pwstOut + (iItem * i), pwstOut + (iItem * (i + 1)), increasingCompareStr);
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -585,18 +585,18 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
 
                 delete[] pwstOut;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::String>();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(pOut->get() + (iItem * i), pOut->get() + (iItem * (i + 1)), increasingCompareStr);
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -606,20 +606,20 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "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;
+        std::vector<std::pair<int, std::pair<char**, char**> > > V;
+        std::vector<std::pair<int, std::pair<char**, char**> > >::iterator it;
 
-        wchar_t** pwstIn = NULL;
-        if (wstrProcess == L"lr")
+        char** pwstIn = NULL;
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::String* pTemp = pIn;
 
-            pwstIn = new wchar_t*[pTemp->getSize()];
-            wchar_t** pwstTemp = pTemp->get();
+            pwstIn = new char*[pTemp->getSize()];
+            char** pwstTemp = pTemp->get();
             int iRows = pTemp->getRows();
             int iCols = pTemp->getCols();
 
@@ -636,7 +636,7 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
 
         for (int i = 0; i < iTimes; i++)
         {
-            V.push_back(std::pair<int, std::pair<wchar_t**, wchar_t**> >(i, std::pair<wchar_t**, wchar_t**>(pwstIn + (i * iItem), pwstIn + (i + 1) * iItem)));
+            V.push_back(std::pair<int, std::pair<char**, char**> >(i, std::pair<char**, char**>(pwstIn + (i * iItem), pwstIn + (i + 1) * iItem)));
         }
 
         std::sort(V.begin(), V.end(), (*pFuncWayStrL));
@@ -657,7 +657,7 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
         }
         V.clear();
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete[] pwstIn;
         }
@@ -667,7 +667,7 @@ types::String* gsort(types::String* pIn, types::Double* pDblInd, const std::wstr
 }
 
 /*--------------------------- Int8 -----------------------------------------*/
-types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::Int8* pOut = NULL;
 
@@ -689,35 +689,35 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
     bool (*pFuncWayL)(std::pair<int, std::pair<char*, char*> > left,
                       std::pair<int, std::pair<char*, char*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -749,20 +749,20 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::Int8>();
                 char* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<char>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::Int8(pIn->getCols(), pIn->getRows());
                 char* piOut = pOut->get();
@@ -777,14 +777,14 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -808,19 +808,19 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::Int8>();
                 char* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -830,7 +830,7 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::Int8(pIn->getDims(), pIn->getDimsArray());
         char* piOut = pOut->get();
@@ -838,7 +838,7 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
         std::vector<std::pair<int, std::pair<char*, char*> > > V;
         std::vector<std::pair<int, std::pair<char*, char*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::Int8* pTemp = pIn;
@@ -878,7 +878,7 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -888,7 +888,7 @@ types::Int8* gsort(types::Int8* pIn, types::Double* pDblInd, const std::wstring&
 }
 
 /*--------------------------- Int16 -----------------------------------------*/
-types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::Int16* pOut = NULL;
 
@@ -910,35 +910,35 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
     bool (*pFuncWayL)(std::pair<int, std::pair<short*, short*> > left,
                       std::pair<int, std::pair<short*, short*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -970,20 +970,20 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::Int16>();
                 short* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<short>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::Int16(pIn->getCols(), pIn->getRows());
                 short* piOut = pOut->get();
@@ -998,14 +998,14 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1029,19 +1029,19 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::Int16>();
                 short* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1051,7 +1051,7 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::Int16(pIn->getDims(), pIn->getDimsArray());
         short* piOut = pOut->get();
@@ -1059,7 +1059,7 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
         std::vector<std::pair<int, std::pair<short*, short*> > > V;
         std::vector<std::pair<int, std::pair<short*, short*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::Int16* pTemp = pIn;
@@ -1099,7 +1099,7 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -1109,7 +1109,7 @@ types::Int16* gsort(types::Int16* pIn, types::Double* pDblInd, const std::wstrin
 }
 
 /*--------------------------- Int32 -----------------------------------------*/
-types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::Int32* pOut = NULL;
 
@@ -1131,35 +1131,35 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
     bool (*pFuncWayL)(std::pair<int, std::pair<int*, int*> > left,
                       std::pair<int, std::pair<int*, int*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -1191,20 +1191,20 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::Int32>();
                 int* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<int>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::Int32(pIn->getCols(), pIn->getRows());
                 int* piOut = pOut->get();
@@ -1219,14 +1219,14 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1250,19 +1250,19 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::Int32>();
                 int* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1272,7 +1272,7 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::Int32(pIn->getDims(), pIn->getDimsArray());
         int* piOut = pOut->get();
@@ -1280,7 +1280,7 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
         std::vector<std::pair<int, std::pair<int*, int*> > > V;
         std::vector<std::pair<int, std::pair<int*, int*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::Int32* pTemp = pIn;
@@ -1320,7 +1320,7 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -1330,7 +1330,7 @@ types::Int32* gsort(types::Int32* pIn, types::Double* pDblInd, const std::wstrin
 }
 
 /*--------------------------- Int64 -----------------------------------------*/
-types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::Int64* pOut = NULL;
 
@@ -1352,35 +1352,35 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
     bool (*pFuncWayL)(std::pair<int, std::pair<long long*, long long*> > left,
                       std::pair<int, std::pair<long long*, long long*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -1412,20 +1412,20 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::Int64>();
                 long long* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<long long>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::Int64(pIn->getCols(), pIn->getRows());
                 long long* piOut = pOut->get();
@@ -1440,14 +1440,14 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1471,19 +1471,19 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::Int64>();
                 long long* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1493,7 +1493,7 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::Int64(pIn->getDims(), pIn->getDimsArray());
         long long* piOut = pOut->get();
@@ -1501,7 +1501,7 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
         std::vector<std::pair<int, std::pair<long long*, long long*> > > V;
         std::vector<std::pair<int, std::pair<long long*, long long*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::Int64* pTemp = pIn;
@@ -1541,7 +1541,7 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -1551,7 +1551,7 @@ types::Int64* gsort(types::Int64* pIn, types::Double* pDblInd, const std::wstrin
 }
 
 /*--------------------------- UInt8 -----------------------------------------*/
-types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::UInt8* pOut = NULL;
 
@@ -1573,35 +1573,35 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
     bool (*pFuncWayL)(std::pair<int, std::pair<unsigned char*, unsigned char*> > left,
                       std::pair<int, std::pair<unsigned char*, unsigned char*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -1633,20 +1633,20 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::UInt8>();
                 unsigned char* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<unsigned char>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::UInt8(pIn->getCols(), pIn->getRows());
                 unsigned char* piOut = pOut->get();
@@ -1661,14 +1661,14 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1692,19 +1692,19 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::UInt8>();
                 unsigned char* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1714,7 +1714,7 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::UInt8(pIn->getDims(), pIn->getDimsArray());
         unsigned char* piOut = pOut->get();
@@ -1722,7 +1722,7 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
         std::vector<std::pair<int, std::pair<unsigned char*, unsigned char*> > > V;
         std::vector<std::pair<int, std::pair<unsigned char*, unsigned char*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::UInt8* pTemp = pIn;
@@ -1762,7 +1762,7 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -1772,7 +1772,7 @@ types::UInt8* gsort(types::UInt8* pIn, types::Double* pDblInd, const std::wstrin
 }
 
 /*--------------------------- UInt16 -----------------------------------------*/
-types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::UInt16* pOut = NULL;
 
@@ -1794,35 +1794,35 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
     bool (*pFuncWayL)(std::pair<int, std::pair<unsigned short*, unsigned short*> > left,
                       std::pair<int, std::pair<unsigned short*, unsigned short*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -1854,20 +1854,20 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::UInt16>();
                 unsigned short* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<unsigned short>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::UInt16(pIn->getCols(), pIn->getRows());
                 unsigned short* piOut = pOut->get();
@@ -1882,14 +1882,14 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1913,19 +1913,19 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::UInt16>();
                 unsigned short* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -1935,7 +1935,7 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::UInt16(pIn->getDims(), pIn->getDimsArray());
         unsigned short* piOut = pOut->get();
@@ -1943,7 +1943,7 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
         std::vector<std::pair<int, std::pair<unsigned short*, unsigned short*> > > V;
         std::vector<std::pair<int, std::pair<unsigned short*, unsigned short*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::UInt16* pTemp = pIn;
@@ -1983,7 +1983,7 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -1993,7 +1993,7 @@ types::UInt16* gsort(types::UInt16* pIn, types::Double* pDblInd, const std::wstr
 }
 
 /*--------------------------- UInt32 -----------------------------------------*/
-types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::UInt32* pOut = NULL;
 
@@ -2015,35 +2015,35 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
     bool (*pFuncWayL)(std::pair<int, std::pair<unsigned int*, unsigned int*> > left,
                       std::pair<int, std::pair<unsigned int*, unsigned int*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -2075,20 +2075,20 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::UInt32>();
                 unsigned int* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<unsigned int>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::UInt32(pIn->getCols(), pIn->getRows());
                 unsigned int* piOut = pOut->get();
@@ -2103,14 +2103,14 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -2134,19 +2134,19 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::UInt32>();
                 unsigned int* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -2156,7 +2156,7 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::UInt32(pIn->getDims(), pIn->getDimsArray());
         unsigned int* piOut = pOut->get();
@@ -2164,7 +2164,7 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
         std::vector<std::pair<int, std::pair<unsigned int*, unsigned int*> > > V;
         std::vector<std::pair<int, std::pair<unsigned int*, unsigned int*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::UInt32* pTemp = pIn;
@@ -2204,7 +2204,7 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
@@ -2214,7 +2214,7 @@ types::UInt32* gsort(types::UInt32* pIn, types::Double* pDblInd, const std::wstr
 }
 
 /*--------------------------- UInt64 -----------------------------------------*/
-types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstring& wstrWay, const std::wstring& wstrProcess)
+types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::string& strWay, const std::string& strProcess)
 {
     types::UInt64* pOut = NULL;
 
@@ -2236,35 +2236,35 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
     bool (*pFuncWayL)(std::pair<int, std::pair<unsigned long long*, unsigned long long*> > left,
                       std::pair<int, std::pair<unsigned long long*, unsigned long long*> > right);
 
-    if (wstrWay == L"i")
+    if (strWay == "i")
     {
         pFuncWay  = &(increasing);
         pFuncWayL = &(increasing);
     }
-    else // strWay == L"d"
+    else // strWay == "d"
     {
         pFuncWay  = &(descendent);
         pFuncWayL = &(descendent);
     }
 
-    if (wstrProcess == L"g")
+    if (strProcess == "g")
     {
         iItem = pIn->getSize();
     }
-    else if (wstrProcess == L"c" || wstrProcess == L"lr")
+    else if (strProcess == "c" || strProcess == "lr")
     {
         iTimes   = pIn->getRows();
         iItem    = pIn->getCols();
         iOffset1 = pIn->getRows();
     }
-    else if (wstrProcess == L"r" || wstrProcess == L"lc")
+    else if (strProcess == "r" || strProcess == "lc")
     {
         iTimes   = pIn->getCols();
         iItem    = pIn->getRows();
         iOffset2 = pIn->getRows();
     }
 
-    if (wstrProcess == L"r" || wstrProcess == L"c" || wstrProcess == L"g")
+    if (strProcess == "r" || strProcess == "c" || strProcess == "g")
     {
         if (pDblInd)
         {
@@ -2296,20 +2296,20 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
         }
         else
         {
-            if (wstrProcess == L"g")
+            if (strProcess == "g")
             {
                 pOut = pIn->clone()->getAs<types::UInt64>();
                 unsigned long long* piOut = pOut->get();
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     std::sort(piOut, piOut + pOut->getSize());
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     std::sort(piOut, piOut + pOut->getSize(), std::greater<unsigned long long>());
                 }
             }
-            else if (wstrProcess == L"c")
+            else if (strProcess == "c")
             {
                 pOut = new types::UInt64(pIn->getCols(), pIn->getRows());
                 unsigned long long* piOut = pOut->get();
@@ -2324,14 +2324,14 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
                 }
 
                 // sort output
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -2355,19 +2355,19 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
 
                 delete pTemp;
             }
-            else //wstrProcess == L"r"
+            else //strProcess == "r"
             {
                 pOut = pIn->clone()->getAs<types::UInt64>();
                 unsigned long long* piOut = pOut->get();
 
-                if (wstrWay == L"i")
+                if (strWay == "i")
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
                         std::sort(piOut + (iItem * i), piOut + (iItem * (i + 1)));
                     }
                 }
-                else // strWay == L"d"
+                else // strWay == "d"
                 {
                     for (int i = 0; i < iTimes; i++)
                     {
@@ -2377,7 +2377,7 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
             }
         }
     }
-    else// wstrProcess == L"lr" and wstrProcess == L"lc"
+    else// strProcess == "lr" and strProcess == "lc"
     {
         pOut = new types::UInt64(pIn->getDims(), pIn->getDimsArray());
         unsigned long long* piOut = pOut->get();
@@ -2385,7 +2385,7 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
         std::vector<std::pair<int, std::pair<unsigned long long*, unsigned long long*> > > V;
         std::vector<std::pair<int, std::pair<unsigned long long*, unsigned long long*> > >::iterator it;
 
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             // transpose matrix pIn
             types::UInt64* pTemp = pIn;
@@ -2425,7 +2425,7 @@ types::UInt64* gsort(types::UInt64* pIn, types::Double* pDblInd, const std::wstr
         }
 
         V.clear();
-        if (wstrProcess == L"lr")
+        if (strProcess == "lr")
         {
             delete pIn;
         }
diff --git a/scilab/modules/elementary_functions/src/cpp/gsort.hxx b/scilab/modules/elementary_functions/src/cpp/gsort.hxx
deleted file mode 100644 (file)
index 0520f47..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-*  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-*  Copyright (C) 2012 - DIGITEO - Antoine ELIAS
-*  Copyright (C) 2012 - DIGITEO - cedric delamarre
-*
-*  This file must be used under the terms of the CeCILL.
-*  This source file is licensed as described in the file COPYING, which
-*  you should have received as part of this distribution.  The terms
-*  are also available at
-*  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-*
-*/
-
-#ifndef __GSORT_H__
-#define __GSORT_H__
-
-#include "double.hxx"
-#include "sparse.hxx"
-#include "string.hxx"
-#include "int.hxx"
-
-extern "C"
-{
-#include "dynlib_elementary_functions.h"
-}
-
-ELEMENTARY_FUNCTIONS_IMPEXP types::Double* gsort(types::Double* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-
-ELEMENTARY_FUNCTIONS_IMPEXP types::String* gsort(types::String* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-
-ELEMENTARY_FUNCTIONS_IMPEXP types::Int8* gsort(types::Int8* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::Int16* gsort(types::Int16* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::Int32* gsort(types::Int32* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::Int64* gsort(types::Int64* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::UInt8* gsort(types::UInt8* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::UInt16* gsort(types::UInt16* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::UInt32* gsort(types::UInt32* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-ELEMENTARY_FUNCTIONS_IMPEXP types::UInt64* gsort(types::UInt64* pIn, types::Double* pInd, const std::wstring& wstrWay, const std::wstring& wstrProcess);
-
-#endif /* __GSORT_H__ */