d306e95c4874e8864fdcc06655d064900105481c
[scilab.git] / scilab / modules / graphics / includes / math_graphics.h
1 /*------------------------------------------------------------------------
2  *    Graphic library
3  *    Copyright (C) 1998-2000 Enpc
4  *    Copyright INRIA 2006
5  *    Authors : Jean-Philippe Chancelier, Jean-Baptiste Silvy
6  --------------------------------------------------------------------------*/
7
8 #ifndef __SCIMATH_H__
9 #define __SCIMATH_H__
10 #include <limits.h>
11 #include <math.h>
12 #include "machine.h"
13
14 #include <stdlib.h>
15
16
17
18
19 #ifdef _MSC_VER 
20                 #include <float.h>
21                 #define finite(x) _finite(x) 
22 #else  /* _MSC_VER */ 
23         /** This should only be provided when finite prototype is missing **/
24         /** XXX : to be tested **/
25         #ifndef __cplusplus
26         int finite __PARAMS((double));
27         #endif
28 #endif /* _MSC_VER */
29
30 #ifdef _MSC_VER 
31         #include <float.h>
32         #define ISNAN(x) _isnan(x)
33 #else 
34         #define ISNAN(x) isnan(x)
35 #endif 
36
37 #define Abs(x) ( ( (x) >= 0) ? (x) : -( x) )
38 #ifndef Min
39 #define Min(x,y)        (((x)<(y))?(x):(y))
40 #endif 
41
42 #ifndef Max 
43 #define Max(x,y)        (((x)>(y))?(x):(y))
44 #endif
45
46 #define PI0 (integer *) 0
47 #define PD0 (double *) 0
48 #define SMDOUBLE 1.e-200 /* Smalest number to avoid dividing by zero */
49
50 /* angle conversion */
51 #define PI_OVER_180  0.01745329251994329576913914624236578987393
52 #define _180_OVER_PI 57.29577951308232087665461840231273527024
53 #define DEG2RAD(x) ((x) * PI_OVER_180  )
54 #define RAD2DEG(x) ((x) * _180_OVER_PI )
55
56 #define         round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
57 #define EPSILON 1.0e-13
58
59
60
61 /** 
62   #define linint(x) ((integer) floor(x)) 
63   #define inint(x) ((int) floor(x))  
64 **/
65
66 /** 
67   if we suppose that the x transmited is in the range of integers 
68   we could also use :
69   #define inint(x) (( x > 0 ) ? ((int) (x + 0.5)) : ((int) (x - 0.5));
70  **/
71
72 #define linint(x) ((integer) floor(x + 0.5 )) 
73 #define inint(x) ((int) floor(x + 0.5 ))  
74
75 /* XWindow function arguments can be  int16 or unsigned16 */
76
77 #define SCIINT16   short
78 #define INT16MAX   SHRT_MAX
79 #define INT16MIN   SHRT_MIN
80 #define int16max   0x7FFF
81 #define uns16max   0xFFFF
82
83 #if (defined(sun) && defined(SYSV)) 
84 #include <ieeefp.h>
85 #endif
86
87 #if defined(_MSC_VER)
88   #define M_PI 3.14159265358979323846
89 #else
90   #if defined(HAVE_VALUES_H)
91     #include <values.h>
92   #else
93     #if defined(HAVE_LIMITS_H)
94      #include <limits.h>
95     #endif
96   #endif
97 #endif
98
99 #ifndef M_PI
100 #define M_PI 3.14159265358979323846 
101 #endif
102
103 double Mini(double *vect, integer n) ;
104
105 double Maxi(double *vect,integer n) ;
106
107 extern double exp10 __PARAMS((double));
108
109 /* prototypes */
110
111 /*----------------------------------------------------------------------------*/
112 /* perform the rotation of point from to point dest with angle in radian  */
113 void rotate2D( double from[2], double center[2], double angle, double dest[2] ) ;
114
115 /* perform the rotation of point from to point to. */
116 /* the angle is directly given with its sine and cosine for speed */
117 void rotate2Dim( double from[2]   ,
118                  double center[2] ,
119                  double cosAngle  ,
120                  double sinAngle  ,
121                  double dest[2]    ) ;
122
123 /* perform the rotation of point from to point dest given in int with angle in radian  */
124 void iRotate2D( int from[2], int center[2], double angle, int dest[2] ) ;
125
126 /* perform the rotation of point from to point dest given in int. */
127 /* the angle is directly given with its sine and cosine for speed */
128 void iRotate2Dim( int    from[2]   ,
129                   int    center[2] ,
130                   double cosAngle  ,
131                   double sinAngle  ,
132                   int    dest[2]    ) ;
133
134 /* perform an homethety point from to point dest. The 2 factors stand for the ration */
135 /* along the 2 coordinates */
136 void homothety2D( double from[2], double center[2], double factors[2], double dest[2] ) ;
137
138 /* perform an homethety point from to point dest given in pixels. */
139 /* The 2 factors stand for the ration along the 2 coordinates */
140 void iHomothety2D( int from[2], int center[2], double factors[2], int dest[2] ) ;
141
142
143 /* perform the translation of point from to point dest with vector trans */
144 void translate2D( double from[2], double trans[2], double dest[2] ) ;
145
146 /* perform the translation of point from to point dest with vector trans given in pixels.*/
147 void iTranslate2D( int from[2], int trans[2], int dest[2] ) ;
148
149 /**
150  * Normalize a 2d vector.
151  */
152 void normalize2d( double vect[2] ) ;
153
154 /**
155  * Normalize a 2d vector in pixels coordinates.
156  */
157 void iNormalize2d( int vect[2] ) ;
158
159 /**
160  * return the scalar product of two 2d vectors.
161  */
162 #define DOT_PROD_2D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) )
163
164 /*----------------------------------------------------------------------------*/
165
166 /*----------------------------------------------------------------------------*/
167 /* check if two values can be considered equal given an accurracy */
168 int safeEqual( double val1, double val2, double accuracy ) ;
169
170 /* with a macro it is faster */
171 /* the x == y test is put to avoid division by 0 */
172 #define SAFE_EQUAL(x,y,acc) ( (x) == (y) ) || ( Abs( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
173
174 /* test if a value if lesser than an other or just sligthy greater */
175 #define SAFE_LT(x,y,acc) ( (x) == (y) || ( (x) - (y) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
176 #define SAFE_GT(x,y,acc) ( (x) == (y) || ( (y) - (x) ) < (acc) * Max( Abs( (x) ), Abs( (y) ) ) )
177 /*----------------------------------------------------------------------------*/
178
179 /*----------------------------------------------------------------------------*/
180 /* truncate an integer to a 16 bits integer. Overflow value are trucated to the min */
181 /* and max of 16 bits integer. */
182 #define INT_2_16B(i) ( (i) > INT16MAX ? (INT16MAX) : ( (i) < INT16MIN ? INT16MIN : ((SCIINT16) i)) )
183 /*----------------------------------------------------------------------------*/
184
185 /*----------------------------------------------------------------------------*/
186 /* truncate an integer to a char. Overflow value are trucated to the min */
187 /* and max of char integer. */
188 #define INT_2_UCHAR(i) ( (i) > UCHAR_MAX ? (UCHAR_MAX) : ( (i) < 0  ? 0 : ((char) i)) )
189 /*----------------------------------------------------------------------------*/
190
191 /*----------------------------------------------------------------------------*/
192 /* truncate a float or double to an int. Overflow value are trucated to the min */
193 /* and max of 32 bits integer. */
194 #define FLOAT_2_INT(f) ( (f) > INT_MAX ? (INT_MAX) : ( (f) < INT_MIN ? (INT_MIN) : ( inint( f ) ) ) )
195 /*----------------------------------------------------------------------------*/
196
197 /*----------------------------------------------------------------------------*/
198 /* return the number of digits of a positive integer (ie for 10236 it is 5 )  */
199 /* the added 0.5 is to avoid trouble with 10^i which could become 9.999999999 */
200 #define GET_NB_DIGITS(i) ( (i) == 0 ? 1 : ((int) floor( log10( (i) + 0.5 ) ) ) + 1 )
201 /*----------------------------------------------------------------------------*/
202
203
204
205
206
207 #endif /* SCI_MATH.HG */
208