Bug 13271 fixed: plot2d with logscale and %nan value freezed scilab
[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  * 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.1-en.txt
11  *
12  */
13
14 /*------------------------------------------------------------------------*/
15 /* file: BasicAlgos.c                                                     */
16 /* desc : Several basic algorithms which can be used in several places in */
17 /*        the code.                                                       */
18 /*------------------------------------------------------------------------*/
19 #include <string.h>
20 #include "BasicAlgos.h"
21 #include "MALLOC.h"
22 #include "core_math.h"
23 #include "freeArrayOfString.h"
24 /*------------------------------------------------------------------------*/
25 double sciFindStPosMin(const double x[], int n)
26 {
27     double min = -1.0;
28     int i = 0;
29
30     if (n <= 0)
31     {
32         return min;
33     }
34
35     for (i = 0; i < n; i++)
36     {
37         if (x[i] > 0)
38         {
39             min = x[i];
40             break;
41         }
42     }
43
44     for (; i < n ; i++)
45     {
46         if (x[i] > 0.0 && x[i] < min)
47         {
48             min = x[i];
49         }
50     }
51
52     /* if we have found at least one positive value in x, min strictly positive */
53     return min;
54 }
55 /*------------------------------------------------------------------------*/
56 int checkMonotony(const double vector[], int nbElement)
57 {
58     int i = 0;
59     if ( vector[1] >= vector[0] )
60     {
61         /* might be increasing */
62         for ( i = 1 ; i < nbElement - 1 ; i++ )
63         {
64             if ( vector[i + 1] < vector[i] )
65             {
66                 /* not increasing */
67                 return 0 ;
68             }
69         }
70         return 1 ;
71     }
72     else
73     {
74         /* might be decreasing */
75         for ( i = 1 ; i < nbElement - 1 ; i++ )
76         {
77             if ( vector[i + 1] > vector[i] )
78             {
79                 /* not decreasing */
80                 return 0 ;
81             }
82         }
83         return -1 ;
84
85     }
86     return 0 ;
87
88 }
89 /*------------------------------------------------------------------------*/
90 BOOL containsOneFiniteElement(const double vector[], int nbElement)
91 {
92     int i = 0;
93     for (i = 0; i < nbElement; i++)
94     {
95         if (finite(vector[i]))
96         {
97             return TRUE;
98         }
99     }
100     return FALSE;
101 }
102 /*------------------------------------------------------------------------*/
103 void doubleArrayCopy(double dest[], const double src[], int nbElement)
104 {
105     memcpy( dest, src, nbElement * sizeof(double) ) ;
106 }
107 /*------------------------------------------------------------------------*/
108 void intArrayCopy(int dest[], const int src[], int nbElement)
109 {
110     memcpy( dest, src, nbElement * sizeof(int) ) ;
111 }
112 /*------------------------------------------------------------------------*/
113 void stringArrayCopy(char * dest[], char * src[], int nbElement)
114 {
115     int i = 0;
116     for ( i = 0 ; i < nbElement ; i++ )
117     {
118         int elemSize =  (int)strlen( src[i] ) + 1 ;
119         FREE( dest[i] ) ;
120
121         dest[i] = MALLOC( elemSize * sizeof(char) ) ;
122
123         if ( dest[i] == NULL )
124         {
125             destroyStringArray( dest, nbElement ) ;
126             return ;
127         }
128
129         strcpy( dest[i], src[i] ) ;
130     }
131 }
132 /*------------------------------------------------------------------------*/
133 void setDoubleArraySingleValue(double dest[], double value, int nbElement)
134 {
135     int i = 0;
136     for ( i = 0 ; i < nbElement ; i++ )
137     {
138         dest[i] = value ;
139     }
140 }
141 /*------------------------------------------------------------------------*/
142 double* createNewArrayFromSource(int destSize, const double src[], int srcSize)
143 {
144     int i = 0;
145     int endCopy = Min( destSize, srcSize ) ;
146     /* create new array */
147     double * dest = MALLOC( destSize * sizeof(double) ) ;
148
149     if ( dest == NULL )
150     {
151         return NULL ;
152     }
153
154     /* copy the element which needs to be copied */
155     memcpy( dest, src, endCopy * sizeof( double ) ) ;
156
157     for ( i = endCopy ; i < destSize ; i++ )
158     {
159         dest[i] = 0.0 ;
160     }
161
162     return dest ;
163
164 }
165 /*------------------------------------------------------------------------*/
166 void destroyStringArray(char * src[], int nbStrings)
167 {
168     freeArrayOfString(src, nbStrings);
169 }
170 /*--------------------------------------------------------------------------*/
171 double* createDoubleArrayCopy(const double src[], int nbElement)
172 {
173     double * res = MALLOC( nbElement * sizeof(double) ) ;
174
175     if ( res == NULL )
176     {
177         return NULL ;
178     }
179
180     memcpy( res, src, nbElement * sizeof(double) ) ;
181
182     return res ;
183 }
184 /*--------------------------------------------------------------------------*/
185 int * createIntArrayCopy(const int src[], int nbElement)
186 {
187     int * res = MALLOC( nbElement * sizeof(int) ) ;
188
189     if ( res == NULL )
190     {
191         return NULL ;
192     }
193
194     memcpy( res, src, nbElement * sizeof(int) ) ;
195
196     return res ;
197 }
198 /*--------------------------------------------------------------------------*/
199 char ** createStringArrayCopy(char * src[], int nbElement)
200 {
201     char ** res = createStringArray(nbElement);
202     if ( res == NULL )
203     {
204         return NULL ;
205     }
206
207     stringArrayCopy( res, src, nbElement ) ;
208
209     return res ;
210
211 }
212 /*--------------------------------------------------------------------------*/
213 char ** createStringArray(int nbElement)
214 {
215     int i = 0;
216     char ** res = MALLOC( nbElement * sizeof(char *) ) ;
217
218     if ( res == NULL )
219     {
220         return NULL ;
221     }
222
223     for ( i = 0 ; i < nbElement; i++ )
224     {
225         res[i] = NULL ;
226     }
227
228     return res ;
229 }
230 /*--------------------------------------------------------------------------*/