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