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