move splitURL in the paths - filenames subsection
[scilab.git] / scilab / modules / graphics / includes / math_graphics.h
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 1998 - 2000 - ENPC - Jean-Philipe Chancelier
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  *    Graphic library
16  --------------------------------------------------------------------------*/
17
18 #ifndef __SCIMATH_H__
19 #define __SCIMATH_H__
20
21 #include <stdlib.h>
22 #include "dynlib_graphics.h"
23 #include "BOOL.h"
24 #include "core_math.h"
25
26 #ifdef _MSC_VER
27 #include <float.h>
28 #define finite(x) _finite(x)
29 #else  /* _MSC_VER */
30 /** This should only be provided when finite prototype is missing **/
31 /** XXX : to be tested **/
32 #ifndef __cplusplus
33 int finite (double);
34 #endif
35 #endif /* _MSC_VER */
36
37 #ifdef _MSC_VER
38 #include <float.h>
39 #define ISNAN(x) _isnan(x)
40 #else
41 #define ISNAN(x) isnan(x)
42 #endif
43
44
45 #define PI0 (int *) 0
46 #define PD0 (double *) 0
47 #define SMDOUBLE 1.e-200 /* Smalest number to avoid dividing by zero */
48
49 /* angle conversion */
50 #define         round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
51 #define EPSILON 1.0e-13
52
53 #if (defined(sun) || defined(SYSV))
54 #include <ieeefp.h>
55 #endif
56
57 #if defined(_MSC_VER)
58 #define M_PI 3.14159265358979323846
59 #else
60 #if defined(HAVE_VALUES_H)
61 #include <values.h>
62 #else
63 #if defined(HAVE_LIMITS_H)
64 #include <limits.h>
65 #endif
66 #endif
67 #endif
68
69 #ifndef M_PI
70 #define M_PI 3.14159265358979323846
71 #endif
72
73 GRAPHICS_IMPEXP double Mini(const double vect[], int n);
74
75 GRAPHICS_IMPEXP double Maxi(const double vect[], int n);
76
77
78
79 /* prototypes */
80
81 /*----------------------------------------------------------------------------*/
82 /************************************************************************/
83 /* 2D algorithms                                                        */
84 /************************************************************************/
85 /* perform the rotation of point from to point dest with angle in radian  */
86 GRAPHICS_IMPEXP void rotate2D(double from[2], double center[2], double angle, double dest[2]);
87
88 /* perform the rotation of point from to point to. */
89 /* the angle is directly given with its sine and cosine for speed */
90 GRAPHICS_IMPEXP void rotate2Dim(double from[2]   ,
91                                 double center[2] ,
92                                 double cosAngle  ,
93                                 double sinAngle  ,
94                                 double dest[2]);
95
96 /* perform the translation of point from to point dest with vector trans */
97 GRAPHICS_IMPEXP void translate2D(double from[2], double trans[2], double dest[2]);
98
99 /* perform the translation of point from to point dest with vector trans given in pixels.*/
100 GRAPHICS_IMPEXP void iTranslate2D(int from[2], int trans[2], int dest[2]);
101
102 /**
103  * Normalize a 2d vector.
104  */
105 GRAPHICS_IMPEXP void normalize2d(double vect[2]);
106
107 /**
108  * Normalize a 2d vector in pixels coordinates.
109  */
110 GRAPHICS_IMPEXP void iNormalize2d(int vect[2]);
111
112 /**
113  * Perform the substraction of vect1 and vect2 and store it in res
114  */
115 GRAPHICS_IMPEXP void vectSubstract2D(const double vect1[2], const double vect2[], double res[2]);
116
117 /**
118  * substraction of two vector
119  * @param res result of v1 + v2
120  */
121 GRAPHICS_IMPEXP void vectAdd2D(const double v1[2], const double v2[2], double res[2]);
122
123 /**
124  * Multiply a vector by a scalar
125  * @param res scalar.v
126  */
127 GRAPHICS_IMPEXP void scalarMult2D(const double v[2], const double scalar, double res[2]);
128
129 /**
130  * return the scalar product of two 2d vectors.
131  */
132 #define DOT_PROD_2D(v1,v2) (((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]))
133
134 /**
135  * Square norm of a vector
136  */
137 #define SQUARE_NORM_2D(v) (DOT_PROD_2D((v),(v)))
138
139 /**
140  * Norm of a 2D vector
141  */
142 #define NORM_2D(v) (sqrt(SQUARE_NORM_2D(v)))
143
144 /**
145  * Compute wether the point lies within the triangle defined by A, B and C
146  */
147 GRAPHICS_IMPEXP BOOL isPointInTriangle(const double point[2], const double a[2],
148                                        const double b[2], const double c[2]);
149
150 /**
151  * Compute wether p1 and p2 are on the same side of line (A,B).
152  */
153 GRAPHICS_IMPEXP BOOL areOnSameSideOfLine(const double p1[2], const double p2[2],
154         const double a[2], const double b[2]);
155
156 /************************************************************************/
157 /* 3D algorithms                                                        */
158 /************************************************************************/
159
160 /**
161  * Scalar product of 2 vectors in 3D
162  */
163 #define DOT_PROD_3D(v1,v2) (((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) + ((v1)[2]) * ((v2)[2]))
164
165 /**
166  * Cross product of two vector
167  * @param res v1^v2
168  */
169 GRAPHICS_IMPEXP void crossProduct(const double v1[3], const double v2[3], double res[3]);
170
171 /**
172  * Square norm of a 3D vector
173  */
174 #define SQUARE_NORM_3D(v) (DOT_PROD_3D((v),(v)))
175
176 /**
177  * Norm of a 3D vector
178  */
179 #define NORM_3D(v) (sqrt(SQUARE_NORM_3D(v)))
180
181 /**
182  * substraction of two vector
183  * @param res result of v1 - v2
184  */
185 GRAPHICS_IMPEXP void vectSubstract3D(const double v1[3], const double v2[3], double res[3]);
186
187 /**
188  * substraction of two vector
189  * @param res result of v1 + v2
190  */
191 GRAPHICS_IMPEXP void vectAdd3D(const double v1[3], const double v2[3], double res[3]);
192
193 /**
194  * Multiply a vector by a scalar
195  * @param res scalar.v
196  */
197 GRAPHICS_IMPEXP void scalarMult3D(const double v[3], double scalar, double res[3]);
198
199 /**
200  * Normalize a 3D vector
201  */
202 GRAPHICS_IMPEXP void normalize3D(double vect[3]);
203
204 /**
205  * Set a 4x4 matrix to identity.
206  */
207 GRAPHICS_IMPEXP void setToIdentity(double mat4D[4][4]);
208
209 /**
210  * Compute the product mat4D*vect3D and store the result in res.
211  */
212 GRAPHICS_IMPEXP void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3]);
213
214 /*----------------------------------------------------------------------------*/
215
216 /* check if two values can be considered equal given an accurracy */
217 /* the x == y test is put to avoid division by 0 */
218 #define SAFE_EQUAL2(x,y,acc) (Abs((x) - (y)) / Max(Abs((x) + (y)), EPSILON) < (acc))
219
220 #define SAFE_EQUAL(x,y,acc) ((x) == (y)) || (Abs((x) - (y)) < (acc) * Max(Abs((x)), Abs((y))))
221 /* test if a value if lesser than an other or just sligthy greater */
222 #define SAFE_LT(x,y,acc) ((x) == (y) || ((x) - (y)) < (acc) * Max(Abs((x)), Abs((y))))
223 #define SAFE_GT(x,y,acc) ((x) == (y) || ((y) - (x)) < (acc) * Max(Abs((x)), Abs((y))))
224 /*----------------------------------------------------------------------------*/
225
226 /*----------------------------------------------------------------------------*/
227 /* truncate an int to a 16 bits integer. Overflow value are truncated to the min */
228 /* and max of 16 bits integer. */
229 #define INT_2_16B(i) ((i) > INT16MAX ? (INT16MAX) : ((i) < INT16MIN ? INT16MIN : ((SCIINT16) i)))
230 /*----------------------------------------------------------------------------*/
231
232 /*----------------------------------------------------------------------------*/
233 /* truncate an int to a char. Overflow value are truncated to the min */
234 /* and max of char integer. */
235 #define INT_2_UCHAR(i) ((i) > UCHAR_MAX ? (UCHAR_MAX) : ((i) < 0  ? 0 : ((char) i)))
236 /*----------------------------------------------------------------------------*/
237
238 /*----------------------------------------------------------------------------*/
239 /* truncate a float or double to an int. Overflow value are truncated to the min */
240 /* and max of 32 bits integer. */
241 #define FLOAT_2_INT(f) ((f) > INT_MAX ? (INT_MAX) : ((f) < INT_MIN ? (INT_MIN) : (inint(f))))
242 /*----------------------------------------------------------------------------*/
243
244 /*----------------------------------------------------------------------------*/
245 /* return the number of digits of a positive int (ie for 10236 it is 5)  */
246 /* the added 0.5 is to avoid trouble with 10^i which could become 9.999999999 */
247 #define GET_NB_DIGITS_POS(i) ((i) == 0 ? 1 : ((int) floor(log10((i) + 0.5))) + 1)
248 /*----------------------------------------------------------------------------*/
249
250 /*----------------------------------------------------------------------------*/
251 /* return the number of digits of an int (ie for 10236 it is 5 or -102 it is 4)  */
252 /* For negative values, the length is increased by 1 because of the '-' sign" */
253 #define GET_NB_DIGITS(i) ((i) > 0 ? GET_NB_DIGITS_POS(i) : GET_NB_DIGITS_POS(-i) + 1)
254 /*----------------------------------------------------------------------------*/
255
256
257
258
259 #endif /* SCI_MATH.HG */
260