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