fix some gcc 4.9 valid warnings
[scilab.git] / scilab / modules / elementary_functions / src / cpp / max.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - 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 <algorithm>
14 #include <vector>
15
16 #include "types_tools.hxx"
17 #include "max.hxx"
18 /*--------------------------- Double ---------------------------------------*/
19 void max(std::vector<types::Double*> vectIn, int iOrientation, types::Double* pDblIndex, types::Double* pOut)
20 {
21     int iDims       = vectIn[0]->getDims();
22     int* iDimsArray = vectIn[0]->getDimsArray();
23     int iSize       = vectIn[0]->getSize();
24     int iInit       = 0;
25     double dValue   = 0;
26
27     if (vectIn.size() > 1) // Find the max value between all inputs matrix
28     {
29         //Find the first non scalar to init output matrix.
30         for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
31         {
32             if (vectIn[iter]->isScalar() == false)
33             {
34                 iInit = iter;
35                 break;
36             }
37         }
38
39         iDims = vectIn[iInit]->getDims();
40         iDimsArray = vectIn[iInit]->getDimsArray();
41         iSize = vectIn[iInit]->getSize();
42
43         // Init output matrix
44         for (int i = 0; i < iSize; i++)
45         {
46             pOut->set(i, vectIn[iInit]->get(i));
47         }
48
49         if (pDblIndex)
50         {
51             for (int i = 0; i < pDblIndex->getSize(); i++)
52             {
53                 pDblIndex->set(i, 1);
54             }
55
56             for (int i = 0; i < iSize; i++)
57             {
58                 for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
59                 {
60                     int iPos = i;
61                     if (vectIn[iter]->isScalar())
62                     {
63                         iPos = 0;
64                     }
65
66                     dValue = vectIn[iter]->get(iPos);
67                     if (pOut->get(i) < dValue || ISNAN(pOut->get(i)))
68                     {
69                         pOut->set(i, dValue);
70                         pDblIndex->set(i, iter + 1);
71                     }
72                 }
73             }
74         }
75         else
76         {
77             for (int i = 0; i < iSize; i++)
78             {
79                 for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
80                 {
81                     int iPos = i;
82                     if (vectIn[iter]->isScalar())
83                     {
84                         iPos = 0;
85                     }
86
87                     dValue = vectIn[iter]->get(iPos);
88                     if (pOut->get(i) < dValue || ISNAN(pOut->get(i)))
89                     {
90                         pOut->set(i, dValue);
91                     }
92                 }
93             }
94         }
95     }
96     else
97     {
98         if (iOrientation == 0) // Find the max value between all matrix elements
99         {
100             double dMax = vectIn[0]->get(0);
101             int iIndex = 0;
102             for (int i = 1; i < iSize; i++)
103             {
104                 dValue = vectIn[0]->get(i);
105                 if (dMax < dValue || ISNAN(dMax))
106                 {
107                     dMax = dValue;
108                     iIndex = i;
109                 }
110             }
111
112             pOut->set(0, dMax);
113             if (pDblIndex)
114             {
115                 if (pDblIndex->isScalar())
116                 {
117                     pDblIndex->set(0, iIndex + 1);
118                 }
119                 else
120                 {
121                     int* piIndexes = new int[iDims];
122                     types::getIndexesWithDims(iIndex, piIndexes, iDimsArray, iDims);
123                     for (int i = 0; i < pDblIndex->getSize(); i++)
124                     {
125                         pDblIndex->set(i, piIndexes[i] + 1);
126                     }
127                     delete piIndexes;
128                 }
129             }
130         }
131         else // Find the max value between all elements of the dimension N (iOrientation)
132         {
133             int iSizeOfDimN = iDimsArray[iOrientation - 1];
134             int iIncrement  = 1;
135             int iIncrOut    = 0;
136
137             for (int i = 0; i < iOrientation - 1; i++)
138             {
139                 iIncrement *= iDimsArray[i];
140             }
141
142             for (int j = 0; j < iSize; j += (iIncrement * iSizeOfDimN))
143             {
144                 for (int i = j; i < iIncrement + j; i++)
145                 {
146                     // init pOut with the first values of the dim N
147                     pOut->set(iIncrOut, vectIn[0]->get(i));
148
149                     if (pDblIndex)
150                     {
151                         pDblIndex->set(iIncrOut, 1);
152                     }
153
154                     for (int k = 1; k < iSizeOfDimN; k++)
155                     {
156                         dValue = vectIn[0]->get(k * iIncrement + i);
157                         if (pOut->get(iIncrOut) < dValue || ISNAN(pOut->get(iIncrOut)))
158                         {
159                             pOut->set(iIncrOut, dValue);
160                             if (pDblIndex)
161                             {
162                                 pDblIndex->set(iIncrOut, k + 1);
163                             }
164                         }
165                     }
166                     iIncrOut++;
167                 }
168             }
169         }
170     }
171 }