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