Enable Yosemite compilation
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15 /*--------------------------------------------------------------------------*/
16 #include <cmath>
17 #include <algorithm>
18 #include <vector>
19
20 #include "types_tools.hxx"
21 #include "max.hxx"
22 /*--------------------------- Double ---------------------------------------*/
23 void max(std::vector<types::Double*> vectIn, int iOrientation, types::Double* pDblIndex, types::Double* pOut)
24 {
25     int iDims       = vectIn[0]->getDims();
26     int* iDimsArray = vectIn[0]->getDimsArray();
27     int iSize       = vectIn[0]->getSize();
28     int iInit       = 0;
29     double dValue   = 0;
30
31     if (vectIn.size() > 1) // Find the max value between all inputs matrix
32     {
33         //Find the first non scalar to init output matrix.
34         for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
35         {
36             if (vectIn[iter]->isScalar() == false)
37             {
38                 iInit = iter;
39                 break;
40             }
41         }
42
43         iDims = vectIn[iInit]->getDims();
44         iDimsArray = vectIn[iInit]->getDimsArray();
45         iSize = vectIn[iInit]->getSize();
46
47         // Init output matrix
48         for (int i = 0; i < iSize; i++)
49         {
50             pOut->set(i, vectIn[iInit]->get(i));
51         }
52
53         if (pDblIndex)
54         {
55             for (int i = 0; i < pDblIndex->getSize(); i++)
56             {
57                 pDblIndex->set(i, 1);
58             }
59
60             for (int i = 0; i < iSize; i++)
61             {
62                 for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
63                 {
64                     int iPos = i;
65                     if (vectIn[iter]->isScalar())
66                     {
67                         iPos = 0;
68                     }
69
70                     dValue = vectIn[iter]->get(iPos);
71                     if (pOut->get(i) < dValue || ISNAN(pOut->get(i)))
72                     {
73                         pOut->set(i, dValue);
74                         pDblIndex->set(i, iter + 1);
75                     }
76                 }
77             }
78         }
79         else
80         {
81             for (int i = 0; i < iSize; i++)
82             {
83                 for (int iter = 0; iter < static_cast<int>(vectIn.size()); iter++)
84                 {
85                     int iPos = i;
86                     if (vectIn[iter]->isScalar())
87                     {
88                         iPos = 0;
89                     }
90
91                     dValue = vectIn[iter]->get(iPos);
92                     if (pOut->get(i) < dValue || ISNAN(pOut->get(i)))
93                     {
94                         pOut->set(i, dValue);
95                     }
96                 }
97             }
98         }
99     }
100     else
101     {
102         if (iOrientation == 0) // Find the max value between all matrix elements
103         {
104             double dMax = vectIn[0]->get(0);
105             int iIndex = 0;
106             for (int i = 1; i < iSize; i++)
107             {
108                 dValue = vectIn[0]->get(i);
109                 if (dMax < dValue || ISNAN(dMax))
110                 {
111                     dMax = dValue;
112                     iIndex = i;
113                 }
114             }
115
116             pOut->set(0, dMax);
117             if (pDblIndex)
118             {
119                 if (pDblIndex->isScalar())
120                 {
121                     pDblIndex->set(0, iIndex + 1);
122                 }
123                 else
124                 {
125                     int* piIndexes = new int[iDims];
126                     types::getIndexesWithDims(iIndex, piIndexes, iDimsArray, iDims);
127                     for (int i = 0; i < pDblIndex->getSize(); i++)
128                     {
129                         pDblIndex->set(i, piIndexes[i] + 1);
130                     }
131                     delete[] piIndexes;
132                 }
133             }
134         }
135         else // Find the max value between all elements of the dimension N (iOrientation)
136         {
137             int iSizeOfDimN = iDimsArray[iOrientation - 1];
138             int iIncrement  = 1;
139             int iIncrOut    = 0;
140
141             for (int i = 0; i < iOrientation - 1; i++)
142             {
143                 iIncrement *= iDimsArray[i];
144             }
145
146             for (int j = 0; j < iSize; j += (iIncrement * iSizeOfDimN))
147             {
148                 for (int i = j; i < iIncrement + j; i++)
149                 {
150                     // init pOut with the first values of the dim N
151                     pOut->set(iIncrOut, vectIn[0]->get(i));
152
153                     if (pDblIndex)
154                     {
155                         pDblIndex->set(iIncrOut, 1);
156                     }
157
158                     for (int k = 1; k < iSizeOfDimN; k++)
159                     {
160                         dValue = vectIn[0]->get(k * iIncrement + i);
161                         if (pOut->get(iIncrOut) < dValue || ISNAN(pOut->get(iIncrOut)))
162                         {
163                             pOut->set(iIncrOut, dValue);
164                             if (pDblIndex)
165                             {
166                                 pDblIndex->set(iIncrOut, k + 1);
167                             }
168                         }
169                     }
170                     iIncrOut++;
171                 }
172             }
173         }
174     }
175 }