* Bug 16365 fixed: median(m,'r'|'c') was wrong after 5dc990
[scilab.git] / scilab / modules / graphics / src / c / BasicAlgos.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 /*------------------------------------------------------------------------*/
18 /* file: BasicAlgos.c                                                     */
19 /* desc : Several basic algorithms which can be used in several places in */
20 /*        the code.                                                       */
21 /*------------------------------------------------------------------------*/
22 #include <string.h>
23 #include "BasicAlgos.h"
24 #include "sci_malloc.h"
25 #include "core_math.h"
26 #include "freeArrayOfString.h"
27 #include "returnanan.h"
28
29 /*------------------------------------------------------------------------*/
30 double sciFindStPosMin(const double x[], int n)
31 {
32     double min = -1.0;
33     int i = 0;
34     char hasNeg = 0;
35
36     if (n <= 0)
37     {
38         return min;
39     }
40
41     for (i = 0; i < n; i++)
42     {
43         if (x[i] > 0)
44         {
45             min = x[i];
46             break;
47         }
48         else if (!hasNeg && x[i] <= 0)
49         {
50             hasNeg = 1;
51         }
52     }
53
54     if (i == n && !hasNeg)
55     {
56         // we have only NaN
57         return C2F(returnanan)();
58     }
59
60     for (; i < n ; i++)
61     {
62         if (x[i] > 0.0 && x[i] < min)
63         {
64             min = x[i];
65         }
66     }
67
68     /* if we have found at least one positive value in x, min strictly positive */
69     return min;
70 }
71 /*------------------------------------------------------------------------*/
72 int checkMonotony(const double vector[], int nbElement)
73 {
74     int i = 0;
75     if ( vector[1] >= vector[0] )
76     {
77         /* might be increasing */
78         for ( i = 1 ; i < nbElement - 1 ; i++ )
79         {
80             if ( vector[i + 1] < vector[i] )
81             {
82                 /* not increasing */
83                 return 0 ;
84             }
85         }
86         return 1 ;
87     }
88     else
89     {
90         /* might be decreasing */
91         for ( i = 1 ; i < nbElement - 1 ; i++ )
92         {
93             if ( vector[i + 1] > vector[i] )
94             {
95                 /* not decreasing */
96                 return 0 ;
97             }
98         }
99         return -1 ;
100
101     }
102     return 0 ;
103
104 }
105 /*------------------------------------------------------------------------*/
106 BOOL containsOneFiniteElement(const double vector[], int nbElement)
107 {
108     int i = 0;
109     for (i = 0; i < nbElement; i++)
110     {
111         if (finite(vector[i]))
112         {
113             return TRUE;
114         }
115     }
116     return FALSE;
117 }
118 /*------------------------------------------------------------------------*/
119 void doubleArrayCopy(double dest[], const double src[], int nbElement)
120 {
121     memcpy( dest, src, nbElement * sizeof(double) ) ;
122 }
123 /*------------------------------------------------------------------------*/
124 void intArrayCopy(int dest[], const int src[], int nbElement)
125 {
126     memcpy( dest, src, nbElement * sizeof(int) ) ;
127 }
128 /*------------------------------------------------------------------------*/
129 BOOL stringArrayCopy(char * dest[], char * src[], int nbElement)
130 {
131     int i = 0;
132     for ( i = 0 ; i < nbElement ; i++ )
133     {
134         int elemSize =  (int)strlen( src[i] ) + 1 ;
135         FREE( dest[i] ) ;
136
137         dest[i] = MALLOC( elemSize * sizeof(char) ) ;
138
139         if ( dest[i] == NULL )
140         {
141             destroyStringArray( dest, nbElement ) ;
142             return FALSE;
143         }
144
145         strcpy( dest[i], src[i] ) ;
146     }
147     return TRUE;
148 }
149 /*------------------------------------------------------------------------*/
150 void setDoubleArraySingleValue(double dest[], double value, int nbElement)
151 {
152     int i = 0;
153     for ( i = 0 ; i < nbElement ; i++ )
154     {
155         dest[i] = value ;
156     }
157 }
158 /*------------------------------------------------------------------------*/
159 double* createNewArrayFromSource(int destSize, const double src[], int srcSize)
160 {
161     int i = 0;
162     int endCopy = Min( destSize, srcSize ) ;
163     /* create new array */
164     double * dest = MALLOC( destSize * sizeof(double) ) ;
165
166     if ( dest == NULL )
167     {
168         return NULL ;
169     }
170
171     /* copy the element which needs to be copied */
172     memcpy( dest, src, endCopy * sizeof( double ) ) ;
173
174     for ( i = endCopy ; i < destSize ; i++ )
175     {
176         dest[i] = 0.0 ;
177     }
178
179     return dest ;
180
181 }
182 /*------------------------------------------------------------------------*/
183 void destroyStringArray(char * src[], int nbStrings)
184 {
185     freeArrayOfString(src, nbStrings);
186 }
187 /*--------------------------------------------------------------------------*/
188 double* createDoubleArrayCopy(const double src[], int nbElement)
189 {
190     double * res = MALLOC( nbElement * sizeof(double) ) ;
191
192     if ( res == NULL )
193     {
194         return NULL ;
195     }
196
197     memcpy( res, src, nbElement * sizeof(double) ) ;
198
199     return res ;
200 }
201 /*--------------------------------------------------------------------------*/
202 int * createIntArrayCopy(const int src[], int nbElement)
203 {
204     int * res = MALLOC( nbElement * sizeof(int) ) ;
205
206     if ( res == NULL )
207     {
208         return NULL ;
209     }
210
211     memcpy( res, src, nbElement * sizeof(int) ) ;
212
213     return res ;
214 }
215 /*--------------------------------------------------------------------------*/
216 char ** createStringArrayCopy(char * src[], int nbElement)
217 {
218     char ** res = createStringArray(nbElement);
219     if ( res == NULL )
220     {
221         return NULL ;
222     }
223
224     if ( stringArrayCopy( res, src, nbElement ) )
225     {
226         return res ;
227     }
228     else
229     {
230         return NULL;
231     }
232
233
234 }
235 /*--------------------------------------------------------------------------*/
236 char ** createStringArray(int nbElement)
237 {
238     int i = 0;
239     char ** res = MALLOC( nbElement * sizeof(char *) ) ;
240
241     if ( res == NULL )
242     {
243         return NULL ;
244     }
245
246     for ( i = 0 ; i < nbElement; i++ )
247     {
248         res[i] = NULL ;
249     }
250
251     return res ;
252 }
253 /*--------------------------------------------------------------------------*/