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