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