
#ifndef __GLOBAL_H__
#define __GLOBAL_H__


#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "rand_mersenne.h"
#include "mex.h"


/******************************************************************************/
/* MACROS ET CONSTANTES                                                       */
/******************************************************************************/

#define CARRE(x) ((x)*(x))
#define CUBE(x)  ((x)*(x)*(x))
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define EPSILON  1e-12
#define INFINI   1e12
#define T_PI     3.14159265358979


/******************************************************************************/
/* STUCTURE DE POSITION                                                       */
/*                                                                            */
/* Stocke la position d'un point tire aleatoirement (x,y,z,r) ainsi que sa zone */
/* d'influence sur la matrice Qr (limites inferieures et superieures de la    */
/* zone d'influence selon x, y et z).                                            */
/******************************************************************************/

typedef struct {
	double x,y,z,r;
	long dix,fix;
	long diy,fiy;
	long diz,fiz;
} position_t;


/******************************************************************************/
/* STUCTURE DE POSITIONS                                                      */
/*                                                                            */
/* Stocke la position des points tires aleatoirement et leur zone d'influence */
/* sur la matrice Qr, ainsi que leur nombre. Il s'agit d'un vecteur temporai- */
/* re. En effet, lorsque l'on genere la position des points, on ne sait pas   */
/* s'ils ont une influence sur Qr. Donc on les stocke dans ce vecteur, puis   */
/* quand on connait leur nombre, on alloue la matrice des variables tirees a- */
/* leatoirement et on les y recopie.                                          */
/******************************************************************************/

typedef struct {
	position_t *tableau;
	long n;
} positions_t;


/******************************************************************************/
/* STUCTURE DE TIRAGE                                                         */
/*                                                                            */
/* Stocke la position d'un point genere aleatoirement, le multiplieur associe */
/* w, l'angle de rotation du motif associe theta, le type du motif qu'il porte*/
/* et un champ qui indique si l'angle du motif est fixe ou variable, le numero*/
/* de la fonction associee au motif, le numero de la zone a laquelle il appar-*/
/* tient et le numero du motif dans le cas ou le motif est un polygone, une   */
/* courbe spline fermee, une ellipse ou une fonction lissante quelconque.     */
/******************************************************************************/

typedef struct {
	double x,y,z,r,w,theta;
	char type_motif,angle;      /*  2 x 1 octet     */
	short numero_fonction,numero_zone,numero_motif;		/*	3 x 2 octets	*/
} tirage_t;


/******************************************************************************/
/* TYPE ANGLE                                                                 */
/*                                                                            */
/* Indique si l'angle de rotation des motifs est fixe (nul, ou donne dans le  */
/* cas des ellipses) ou genere uniformement sur [0,2*pi[.                     */
/******************************************************************************/

typedef enum {
	fixe,
	variable
} angle_t;


/******************************************************************************/
/* TYPE DE MOTIF                                                              */
/*                                                                            */
/* Identifie le type de motif associe a un point genere aleatoirement donne.  */
/******************************************************************************/

typedef enum {
	m_carre=1,
	m_cercle,
	m_shaper_cos_carre,
	m_shaper_exp
} motif_t;


/******************************************************************************/
/* TYPE DE NUMERO DE FONCTION DE MOTIF                                        */
/*                                                                            */
/* Identifie la fonction de motif a appeler pour un point genere aleatoire-   */
/* ment donne, lorsque l'on calcule la matrice Qr.                            */
/******************************************************************************/

typedef enum {
	n_carre_fixe,
	n_carre_variable,
	n_cercle,
	n_shaper_cos_carre,
	n_shaper_exp
} numero_fonction_t;


/******************************************************************************/
/* PROTOTYPES                                                                 */
/******************************************************************************/

void allocation_sorties(mxArray **, double **, long, long, long, double *);
char est_shaper(motif_t);


#endif

