no newline at end of file
[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 int C2F(entier2d)( integer * n, double * dx,integer * s )
39 {
40   integer ix;
41   for (ix = *n -1 ; ix >= 0; --ix) { dx[ix] = (double) s[ix]; }
42   return 0;
43 }  
44 /*------------------------------------------------------------------------*/
45 int checkMonotony( double vector[], int nbElement )
46 {
47   int i ;
48   if( vector[1] >= vector[0] )
49   {
50     /* might be incresing */
51     for ( i = 1 ; i < nbElement - 1 ; i++ )
52     {
53       if ( vector[i+1] < vector[i] )
54       {
55         /* not increasing */
56         return 0 ;
57       }
58     }
59     return 1 ;
60   }
61   else
62   {
63     /* might be decreasing */
64     for ( i = 1 ; i < nbElement - 1 ; i++ )
65     {
66       if ( vector[i+1] > vector[i] )
67       {
68         /* not decreasing */
69         return 0 ;
70       }
71     }
72     return -1 ;
73
74   }
75   return 0 ;
76
77 }
78 /*------------------------------------------------------------------------*/
79 void doubleArrayCopy( double dest[], const double src[], int nbElement )
80 {
81   memcpy( dest, src, nbElement * sizeof(double) ) ;
82 }
83 /*------------------------------------------------------------------------*/
84 void intArrayCopy( int dest[], const int src[], int nbElement )
85 {
86   memcpy( dest, src, nbElement * sizeof(int) ) ;
87 }
88 /*------------------------------------------------------------------------*/
89 void stringArrayCopy( char * dest[], const char * src[], int nbElement )
90 {
91   int i ;
92   for ( i = 0 ; i < nbElement ; i++ )
93   {
94     int elemSize = strlen( src[i] ) + 1 ;
95     FREE( dest[i] ) ;
96
97     dest[i] = MALLOC( elemSize * sizeof(char) ) ;
98
99     if ( dest[i] == NULL )
100     {
101       destroyStringArray( dest, nbElement ) ;
102       return ;
103     }
104
105     strcpy( dest[i], src[i] ) ;
106   }
107 }
108 /*------------------------------------------------------------------------*/
109 void setDoubleArraySingleValue( double dest[], double value, int nbElement )
110 {
111   int i ;
112   for ( i = 0 ; i < nbElement ; i++ )
113   {
114     dest[i] = value ;
115   }
116 }
117 /*------------------------------------------------------------------------*/
118 double * createNewArrayFromSource( int destSize, const double src[], int srcSize )
119 {
120   int i ;
121   int endCopy = Min( destSize, srcSize ) ;
122   /* create new array */
123   double * dest = MALLOC( destSize * sizeof(double) ) ;
124
125   if ( dest == NULL )
126   {
127     return NULL ;
128   }
129
130   /* copy the element which needs to be copied */
131   memcpy( dest, src, endCopy * sizeof( double ) ) ;
132
133   for ( i = endCopy ; i < destSize ; i++ )
134   {
135     dest[i] = 0.0 ;
136   }
137
138   return dest ;
139
140 }
141 /*------------------------------------------------------------------------*/
142 void destroyStringArray( char * src[], int nbStrings )
143 {
144   int i ;
145   for ( i = 0 ; i < nbStrings ; i++ )
146   {
147     FREE( src[i] ) ;
148     src[i] = NULL ;
149   }
150   FREE( src ) ;
151 }
152 /*-----------------------------------------------------------------------------------*/
153 int * createIntArrayCopy( const int src[], int nbElement )
154 {
155   int * res = MALLOC( nbElement * sizeof(int) ) ;
156   
157   if ( res == NULL )
158   {
159     return NULL ;
160   }
161   
162   memcpy( res, src, nbElement * sizeof(int) ) ;
163
164   return res ;
165 }
166 /*-----------------------------------------------------------------------------------*/
167 char ** createStringArrayCopy( const char * src[], int nbElement )
168 {
169   int i ;
170   char ** res = MALLOC( nbElement * sizeof(char *) ) ;
171
172   if ( res == NULL )
173   {
174     return NULL ;
175   }
176
177   for ( i = 0 ; i < nbElement; i++ )
178   {
179     res[i] = NULL ;
180   }
181
182   stringArrayCopy( res, src, nbElement ) ;
183
184   return res ;
185
186 }
187 /*-----------------------------------------------------------------------------------*/