initialize variables
[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 "rendererBasicAlgos.h"
24 #include "freeArrayOfString.h"
25 /*------------------------------------------------------------------------*/
26 double sciFindStPosMin( const double x[], int n )
27 {
28   double min = 0.;
29   int i = 0;
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 int checkMonotony( const double vector[], int nbElement )
51 {
52   int i = 0;
53   if( vector[1] >= vector[0] )
54   {
55     /* might be increasing */
56     for ( i = 1 ; i < nbElement - 1 ; i++ )
57     {
58       if ( vector[i+1] < vector[i] )
59       {
60         /* not increasing */
61         return 0 ;
62       }
63     }
64     return 1 ;
65   }
66   else
67   {
68     /* might be decreasing */
69     for ( i = 1 ; i < nbElement - 1 ; i++ )
70     {
71       if ( vector[i+1] > vector[i] )
72       {
73         /* not decreasing */
74         return 0 ;
75       }
76     }
77     return -1 ;
78
79   }
80   return 0 ;
81
82 }
83 /*------------------------------------------------------------------------*/
84 BOOL containsOneFiniteElement(const double vector[], int nbElement)
85 {
86         int i = 0;
87         for (i = 0; i < nbElement; i++)
88         {
89                 if (finite(vector[i]))
90                 {
91                         return TRUE;
92                 }
93         }
94         return FALSE;
95 }
96 /*------------------------------------------------------------------------*/
97 void doubleArrayCopy( double dest[], const double src[], int nbElement )
98 {
99   memcpy( dest, src, nbElement * sizeof(double) ) ;
100 }
101 /*------------------------------------------------------------------------*/
102 void intArrayCopy( int dest[], const int src[], int nbElement )
103 {
104   memcpy( dest, src, nbElement * sizeof(int) ) ;
105 }
106 /*------------------------------------------------------------------------*/
107 void stringArrayCopy( char * dest[], char * src[], int nbElement )
108 {
109   int i = 0;
110   for ( i = 0 ; i < nbElement ; i++ )
111   {
112     int elemSize =  (int)strlen( src[i] ) + 1 ;
113     FREE( dest[i] ) ;
114
115     dest[i] = MALLOC( elemSize * sizeof(char) ) ;
116
117     if ( dest[i] == NULL )
118     {
119       destroyStringArray( dest, nbElement ) ;
120       return ;
121     }
122
123     strcpy( dest[i], src[i] ) ;
124   }
125 }
126 /*------------------------------------------------------------------------*/
127 void setDoubleArraySingleValue( double dest[], double value, int nbElement )
128 {
129   int i = 0;
130   for ( i = 0 ; i < nbElement ; i++ )
131   {
132     dest[i] = value ;
133   }
134 }
135 /*------------------------------------------------------------------------*/
136 double * createNewArrayFromSource( int destSize, const double src[], int srcSize )
137 {
138   int i = 0;
139   int endCopy = Min( destSize, srcSize ) ;
140   /* create new array */
141   double * dest = MALLOC( destSize * sizeof(double) ) ;
142
143   if ( dest == NULL )
144   {
145     return NULL ;
146   }
147
148   /* copy the element which needs to be copied */
149   memcpy( dest, src, endCopy * sizeof( double ) ) ;
150
151   for ( i = endCopy ; i < destSize ; i++ )
152   {
153     dest[i] = 0.0 ;
154   }
155
156   return dest ;
157
158 }
159 /*------------------------------------------------------------------------*/
160 void destroyStringArray( char * src[], int nbStrings )
161 {
162         freeArrayOfString(src, nbStrings);
163 }
164 /*--------------------------------------------------------------------------*/
165 void destroyCppString(char * string)
166 {
167   destroyRendererString(string);
168 }
169 /*--------------------------------------------------------------------------*/
170 double * createDoubleArrayCopy( const double src[], int nbElement )
171 {
172   double * res = MALLOC( nbElement * sizeof(double) ) ;
173
174   if ( res == NULL )
175   {
176     return NULL ;
177   }
178
179   memcpy( res, src, nbElement * sizeof(double) ) ;
180
181   return res ;
182 }
183 /*--------------------------------------------------------------------------*/
184 int * createIntArrayCopy( const int src[], int nbElement )
185 {
186   int * res = MALLOC( nbElement * sizeof(int) ) ;
187   
188   if ( res == NULL )
189   {
190     return NULL ;
191   }
192   
193   memcpy( res, src, nbElement * sizeof(int) ) ;
194
195   return res ;
196 }
197 /*--------------------------------------------------------------------------*/
198 char ** createStringArrayCopy( char * src[], int nbElement )
199 {
200   char ** res = createStringArray(nbElement);
201
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 /*--------------------------------------------------------------------------*/