cosmetic, rename functions
[scilab.git] / scilab / modules / elementary_functions / sci_gateway / cpp / sci_gsort.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - DIGITEO - Cedric DELAMARRE
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12 /*--------------------------------------------------------------------------*/
13 #include "elem_func_gw.hxx"
14 #include "function.hxx"
15 #include "double.hxx"
16 #include "string.hxx"
17 #include "overload.hxx"
18 #include "execvisitor.hxx"
19 #include "gsort.hxx"
20
21
22 extern "C"
23 {
24 #include "Scierror.h"
25 #include "localization.h"
26 }
27
28 /*--------------------------------------------------------------------------*/
29 types::Function::ReturnValue sci_gsort(types::typed_list &in, int _iRetCount, types::typed_list &out)
30 {
31     types::Double* pDblInd = NULL;
32
33     std::wstring wstrWay     = L"d";
34     std::wstring wstrProcess = L"g";
35
36     if (in.size() < 1 || in.size() > 3)
37     {
38         Scierror(77, _("%s: Wrong number of input argument(s): %d to %d expected.\n"), "gsort", 1, 3);
39         return types::Function::Error;
40     }
41
42     if (_iRetCount > 2)
43     {
44         Scierror(78, _("%s: Wrong number of output argument(s): %d to %d expected.\n"), "gsort", 1, 2);
45         return types::Function::Error;
46     }
47
48     /***** get data and perform operation *****/
49     if (in.size() == 3) // get Direction
50     {
51         if (in[2]->isString() == false)
52         {
53             Scierror(999, _("%s: Wrong type for input argument #%d : A string expected.\n"), "gsort", 3);
54             return types::Function::Error;
55         }
56
57         wstrWay = in[2]->getAs<types::String>()->get(0);
58         if (wstrWay != L"i" && wstrWay != L"d")
59         {
60             Scierror(999, _("%s: Wrong value for input argument #%d: ['i' 'd'] expected.\n"), "gsort", 3);
61             return types::Function::Error;
62         }
63     }
64
65     if (in.size() >= 2) // get Option
66     {
67         if (in[1]->isString() == false)
68         {
69             Scierror(999, _("%s: Wrong type for input argument #%d : A string expected.\n"), "gsort", 2);
70             return types::Function::Error;
71         }
72
73         wstrProcess = in[1]->getAs<types::String>()->get(0);
74
75         if ( wstrProcess != L"c"  &&
76                 wstrProcess != L"r"  &&
77                 wstrProcess != L"g"  &&
78                 wstrProcess != L"lc" &&
79                 wstrProcess != L"lr")
80         {
81             Scierror(999, _("%s: Wrong value for input argument #%d: ['g' 'r' 'c' 'lc' 'lr'] expected.\n"), "gsort", 2);
82             return types::Function::Error;
83         }
84     }
85
86     // get data and perform operation for each types::
87     if (in[0]->isGenericType() == false)
88     {
89         std::wstring wstFuncName = L"%"  + in[0]->getShortTypeStr() + L"_gsort";
90         return Overload::call(wstFuncName, in, _iRetCount, out, new ExecVisitor());
91     }
92
93     types::GenericType* pGTOut = in[0]->getAs<types::GenericType>();
94
95     if (pGTOut->getDims() > 2)
96     {
97         std::wstring wstFuncName = L"%hm_gsort";
98         return Overload::call(wstFuncName, in, _iRetCount, out, new ExecVisitor());
99     }
100
101     if (_iRetCount == 2)
102     {
103         int iRowsInd = (wstrProcess == L"lc") ? 1 : pGTOut->getRows();
104         int iColsInd = (wstrProcess == L"lr") ? 1 : pGTOut->getCols();
105
106         pDblInd = new types::Double(iRowsInd, iColsInd);
107     }
108
109     if (in[0]->isDouble()) // double
110     {
111         types::Double* pDblIn = in[0]->getAs<types::Double>();
112         // doc says : "With complex numbers, gsort can be overloaded"
113         if (pDblIn->isComplex() && symbol::Context::getInstance()->getFunction(symbol::Symbol(L"%_gsort")))
114         {
115             if (_iRetCount == 2)
116             {
117                 delete pDblInd;
118             }
119
120             return Overload::call(L"%_gsort", in, _iRetCount, out, new ExecVisitor());
121         }
122
123         types::Double* pDblOut = gsort(pDblIn, pDblInd, wstrWay, wstrProcess);
124         out.push_back(pDblOut);
125     }
126     else if (in[0]->isSparse()) // sparse
127     {
128         if (_iRetCount == 2)
129         {
130             delete pDblInd;
131         }
132
133         std::wstring wstFuncName = L"%"  + in[0]->getShortTypeStr() + L"_gsort";
134         return Overload::call(wstFuncName, in, _iRetCount, out, new ExecVisitor());
135     }
136     else if (in[0]->isString()) // string
137     {
138         types::String* pStringIn = in[0]->getAs<types::String>();
139         types::String* pStringOut = gsort(pStringIn, pDblInd, wstrWay, wstrProcess);
140         out.push_back(pStringOut);
141     }
142     else if (in[0]->isInt8()) // int
143     {
144         types::Int8* pIIn = in[0]->getAs<types::Int8>();
145         types::Int8* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
146         out.push_back(pIOut);
147     }
148     else if (in[0]->isInt16())
149     {
150         types::Int16* pIIn = in[0]->getAs<types::Int16>();
151         types::Int16* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
152         out.push_back(pIOut);
153     }
154     else if (in[0]->isInt32())
155     {
156         types::Int32* pIIn = in[0]->getAs<types::Int32>();
157         types::Int32* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
158         out.push_back(pIOut);
159     }
160     else if (in[0]->isInt64())
161     {
162         types::Int64* pIIn = in[0]->getAs<types::Int64>();
163         types::Int64* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
164         out.push_back(pIOut);
165     }
166     else if (in[0]->isUInt8()) // uint
167     {
168         types::UInt8* pIIn = in[0]->getAs<types::UInt8>();
169         types::UInt8* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
170         out.push_back(pIOut);
171     }
172     else if (in[0]->isUInt16())
173     {
174         types::UInt16* pIIn = in[0]->getAs<types::UInt16>();
175         types::UInt16* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
176         out.push_back(pIOut);
177     }
178     else if (in[0]->isUInt32())
179     {
180         types::UInt32* pIIn = in[0]->getAs<types::UInt32>();
181         types::UInt32* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
182         out.push_back(pIOut);
183     }
184     else if (in[0]->isUInt64())
185     {
186         types::UInt64* pIIn = in[0]->getAs<types::UInt64>();
187         types::UInt64* pIOut = gsort(pIIn, pDblInd, wstrWay, wstrProcess);
188         out.push_back(pIOut);
189     }
190     else
191     {
192         std::wstring wstFuncName = L"%"  + in[0]->getShortTypeStr() + L"_gsort";
193         return Overload::call(wstFuncName, in, _iRetCount, out, new ExecVisitor());
194     }
195
196     /***** set result *****/
197     if (_iRetCount == 2)
198     {
199         out.push_back(pDblInd);
200     }
201
202     return types::Function::OK;
203 }
204 /*--------------------------------------------------------------------------*/