Convert internal functions of graphics and gui to api scilab
[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] = (char*)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 = (double*)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 = (double*)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 = (int*)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 = (char**)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 /*--------------------------------------------------------------------------*/