Replace Min, Max and Abs by std::min, std::max and std::abs
[scilab.git] / scilab / modules / elementary_functions / src / cpp / diag.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - DIGITEO - Cedric Delamarre
4  * Copyright (C) 2014 - Scilab Enterprises - Sylvain GENIN
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13 /*--------------------------------------------------------------------------*/
14
15 #include "diag.hxx"
16
17 types::Double* diag(types::Double* pIn,  int iStartPos)
18 {
19     types::Double* pDblOut = NULL;
20
21     int iRows = pIn->getRows();
22     int iCols = pIn->getCols();
23
24     int iSize       = 0;
25     int iStartRow   = 0;
26     int iStartCol   = 0;
27     int iPos        = 0;
28
29     if (iRows != 1 && iCols != 1) // pIn is a matrix
30     {
31         if (iStartPos < 0)
32         {
33             iSize = std::max(0, std::min(iRows + iStartPos, iCols));
34             iStartRow = -iStartPos;
35         }
36         else
37         {
38             iSize = std::max(0, std::min(iRows, iCols - iStartPos));
39             iStartCol = iStartPos;
40         }
41
42         if (iSize)
43         {
44             pDblOut = new types::Double(iSize, 1, pIn->isComplex());
45         }
46         else
47         {
48             return types::Double::Empty();
49         }
50
51         for (int i = 0; i < iSize; i++)
52         {
53             iPos = (i + iStartCol) * iRows + (i + iStartRow);
54             pDblOut->set(i, pIn->get(iPos));
55
56             if (pIn->isComplex())
57             {
58                 pDblOut->setImg(i, pIn->getImg(iPos));
59             }
60         }
61     }
62     else // pIn is a vector
63     {
64         int iSizeOfVector = std::max(iRows, iCols);
65         if (iStartPos < 0)
66         {
67             iSize = iSizeOfVector - iStartPos;
68             iStartRow = -iStartPos;
69         }
70         else
71         {
72             iSize = iSizeOfVector + iStartPos;
73             iStartCol = iStartPos;
74         }
75
76         pDblOut = new types::Double(iSize, iSize, pIn->isComplex());
77         memset(pDblOut->get(), 0x00, iSize * iSize * sizeof(double));
78
79         if (pIn->isComplex())
80         {
81             memset(pDblOut->getImg(), 0x00, iSize * iSize * sizeof(double));
82         }
83
84         for (int i = 0; i < iSizeOfVector; i++)
85         {
86             iPos = (i + iStartCol) * iSize + (i + iStartRow);
87             pDblOut->set(iPos, pIn->get(i));
88
89             if (pIn->isComplex())
90             {
91                 pDblOut->setImg(iPos, pIn->getImg(i));
92             }
93         }
94     }
95
96     return pDblOut;
97 }
98
99 types::Polynom* diag(types::Polynom* pIn,  int iStartPos)
100 {
101     types::Polynom* pPolyOut    = NULL;
102     types::SinglePoly* pSP      = NULL;
103
104     int iRows = pIn->getRows();
105     int iCols = pIn->getCols();
106
107     int iSize       = 0;
108     int iStartRow   = 0;
109     int iStartCol   = 0;
110     int iPos        = 0;
111     int iRank       = 0;
112
113     double* pdRData = 0;
114     double* pdIData = 0;
115
116     if (iRows != 1 && iCols != 1) // pIn is a matrix
117     {
118         if (iStartPos < 0)
119         {
120             iSize = std::max(0, std::min(iRows + iStartPos, iCols));
121             iStartRow = -iStartPos;
122         }
123         else
124         {
125             iSize = std::max(0, std::min(iRows, iCols - iStartPos));
126             iStartCol = iStartPos;
127         }
128
129         if (iSize)
130         {
131             pPolyOut = new types::Polynom(pIn->getVariableName(), iSize, 1);
132             pPolyOut->setComplex(pIn->isComplex());
133         }
134         else
135         {
136             return NULL;
137         }
138
139         if (pIn->isComplex())
140         {
141             for (int i = 0; i < iSize; i++)
142             {
143                 iRank = pIn->get(i * (iSize + 1))->getRank();
144                 pSP = new types::SinglePoly(&pdRData, &pdIData, iRank);
145                 iPos = (i + iStartCol) * iRows + (i + iStartRow);
146
147                 for (int j = 0; j < iRank; j++)
148                 {
149                     pdRData[j] = pIn->get(iPos)->getCoefReal()[j];
150                     pdIData[j] = pIn->get(iPos)->getCoefImg()[j];
151                 }
152
153                 pPolyOut->set(i, pSP);
154                 delete pSP;
155                 pSP = NULL;
156             }
157         }
158         else
159         {
160             for (int i = 0; i < iSize; i++)
161             {
162                 iRank = pIn->get(i * (iSize + 1))->getRank();
163                 pSP = new types::SinglePoly(&pdRData, iRank);
164                 iPos = (i + iStartCol) * iRows + (i + iStartRow);
165
166                 for (int j = 0; j < iRank; j++)
167                 {
168                     pdRData[j] = pIn->get(iPos)->getCoefReal()[j];
169                 }
170
171                 pPolyOut->set(i, pSP);
172                 delete pSP;
173                 pSP = NULL;
174             }
175         }
176     }
177     else // pIn is a vector
178     {
179         int iSizeOfVector = std::max(iRows, iCols);
180         if (iStartPos < 0)
181         {
182             iSize = iSizeOfVector - iStartPos;
183             iStartRow = -iStartPos;
184         }
185         else
186         {
187             iSize = iSizeOfVector + iStartPos;
188             iStartCol = iStartPos;
189         }
190
191         pPolyOut = new types::Polynom(pIn->getVariableName(), iSize, iSize);
192         pPolyOut->setComplex(pIn->isComplex());
193
194         if (pIn->isComplex())
195         {
196             for (int i = 0; i < iSizeOfVector; i++)
197             {
198                 iRank = pIn->get(i)->getRank();
199                 pSP = new types::SinglePoly(&pdRData, &pdIData, iRank);
200                 iPos = (i + iStartCol) * iSize + (i + iStartRow);
201
202                 for (int j = 0; j < iRank; j++)
203                 {
204                     pdRData[j] = pIn->get(i)->getCoefReal()[j];
205                     pdIData[j] = pIn->get(i)->getCoefImg()[j];
206                 }
207
208                 pPolyOut->set(iPos, pSP);
209                 delete pSP;
210                 pSP = NULL;
211             }
212         }
213         else
214         {
215             for (int i = 0; i < iSizeOfVector; i++)
216             {
217                 iRank = pIn->get(i)->getRank();
218                 pSP = new types::SinglePoly(&pdRData, iRank);
219                 iPos = (i + iStartCol) * iSize + (i + iStartRow);
220
221                 for (int j = 0; j < iRank; j++)
222                 {
223                     pdRData[j] = pIn->get(i)->getCoefReal()[j];
224                 }
225
226                 pPolyOut->set(iPos, pSP);
227                 delete pSP;
228                 pSP = NULL;
229             }
230         }
231     }
232
233     pPolyOut->updateRank();
234     return pPolyOut;
235 }
236
237
238 types::String* diag(types::String* pIn,  int iStartPos)
239 {
240     types::String* pStrOut = NULL;
241
242     int iRows = pIn->getRows();
243     int iCols = pIn->getCols();
244
245     int iSize       = 0;
246     int iStartRow   = 0;
247     int iStartCol   = 0;
248     int iPos        = 0;
249
250     if (iRows != 1 && iCols != 1) // pIn is a matrix
251     {
252         if (iStartPos < 0)
253         {
254             iSize = std::max(0, std::min(iRows + iStartPos, iCols));
255             iStartRow = -iStartPos;
256         }
257         else
258         {
259             iSize = std::max(0, std::min(iRows, iCols - iStartPos));
260             iStartCol = iStartPos;
261         }
262
263         if (iSize)
264         {
265             pStrOut = new types::String(iSize, 1);
266         }
267         else
268         {
269             return NULL;
270         }
271
272         for (int i = 0; i < iSize; i++)
273         {
274             iPos = (i + iStartCol) * iRows + (i + iStartRow);
275             pStrOut->set(i, pIn->get(iPos));
276         }
277     }
278     else // pIn is a vector
279     {
280         int iSizeOfVector = std::max(iRows, iCols);
281         if (iStartPos < 0)
282         {
283             iSize = iSizeOfVector - iStartPos;
284             iStartRow = -iStartPos;
285         }
286         else
287         {
288             iSize = iSizeOfVector + iStartPos;
289             iStartCol = iStartPos;
290         }
291
292         pStrOut = new types::String(iSize, iSize);
293
294         for (int i = 0; i < iSize * iSize; i++)
295         {
296             pStrOut->set(i, L"");
297         }
298
299         for (int i = 0; i < iSizeOfVector; i++)
300         {
301             iPos = (i + iStartCol) * iSize + (i + iStartRow);
302             pStrOut->set(iPos, pIn->get(i));
303         }
304     }
305
306     return pStrOut;
307 }
308