Fix bug 2540
[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 "machine.h"
20 #include "BasicAlgos.h"
21 #include "MALLOC.h"
22 #include "core_math.h"
23 #include "rendererBasicAlgos.h"
24
25 /*------------------------------------------------------------------------*/
26 double sciFindStPosMin( const 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 int checkMonotony( const double vector[], int nbElement )
51 {
52   int i ;
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;
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 ;
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 ;
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 ;
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   int i ;
163   for ( i = 0 ; i < nbStrings ; i++ )
164   {
165     FREE( src[i] ) ;
166     src[i] = NULL ;
167   }
168   FREE( src ) ;
169 }
170 /*--------------------------------------------------------------------------*/
171 void destroyCppString(char * string)
172 {
173   destroyRendererString(string);
174 }
175 /*--------------------------------------------------------------------------*/
176 double * createDoubleArrayCopy( const double src[], int nbElement )
177 {
178   double * res = MALLOC( nbElement * sizeof(double) ) ;
179
180   if ( res == NULL )
181   {
182     return NULL ;
183   }
184
185   memcpy( res, src, nbElement * sizeof(double) ) ;
186
187   return res ;
188 }
189 /*--------------------------------------------------------------------------*/
190 int * createIntArrayCopy( const int src[], int nbElement )
191 {
192   int * res = MALLOC( nbElement * sizeof(int) ) ;
193   
194   if ( res == NULL )
195   {
196     return NULL ;
197   }
198   
199   memcpy( res, src, nbElement * sizeof(int) ) ;
200
201   return res ;
202 }
203 /*--------------------------------------------------------------------------*/
204 char ** createStringArrayCopy( char * src[], int nbElement )
205 {
206   char ** res = createStringArray(nbElement);
207
208   if ( res == NULL )
209   {
210     return NULL ;
211   }
212
213   stringArrayCopy( res, src, nbElement ) ;
214
215   return res ;
216
217 }
218 /*--------------------------------------------------------------------------*/
219 char ** createStringArray(int nbElement)
220 {
221   int i ;
222   char ** res = MALLOC( nbElement * sizeof(char *) ) ;
223
224   if ( res == NULL )
225   {
226     return NULL ;
227   }
228
229   for ( i = 0 ; i < nbElement; i++ )
230   {
231     res[i] = NULL ;
232   }
233
234   return res ;
235 }
236 /*--------------------------------------------------------------------------*/