#ifndef MacroH
#define MacroH
/*---------------------------------------------------------------------------------*
 * Vectors  :                                                                      *
 *---------------------------------------------------------------------------------*/
#define TernOpFac(v,o1,f,o2)     (v[0] o1 (f)) o2 (v[1] o1 (f)) o2 (v[2] o1 (f))
#define BinOpFac(v, o, f)        (v[0] o (f), v[1] o (f), v[2] o (f))

#define TernOpVec(v1,o1,v2,o2)   (v1[0] o1 v2[0]) o2 \
                                 (v1[1] o1 v2[1]) o2 \
                                 (v1[2] o1 v2[2])

#define TernOpFunc(v1,o1,v2,o2)  (v1(0) o1 v2(0)) o2 \
                                 (v1(1) o1 v2(1)) o2 \
                                 (v1(2) o1 v2(2))


#define BinOpVec(v1, o, v2)      ( v1[0] o v2[0], \
                                   v1[1] o v2[1], \
                                   v1[2] o v2[2] )
                                 
#define ProdVec(r, v1, v2)     ( (r)[0] = v1[1]*v2[2] - v1[2]*v2[1], \
                                 (r)[1] = v1[2]*v2[0] - v1[0]*v2[2], \
                                 (r)[2] = v1[0]*v2[1] - v1[1]*v2[0] )
/*---------------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------------*
 * Typecasts:                                                                      *
 *---------------------------------------------------------------------------------*/
#define p2pc(x)  ((char*)(x))         // 1 byte
#define p2pi(x)  ((short*)(x))        // 2 bytes
#define p2pl(x)  ((long*) (x))        // 4 bytes
#define p2pd(x)  ((double*)(x))       // 8 bytes
#define p2pD(x)  ((long double*)(x))  // 10 bytes

#define p2c(x)   (*p2pc(x))
#define p2i(x)   (*p2pi(x))
#define p2l(x)   (*p2pl(x))
#define p2d(x)   (*p2pd(x))
#define p2D(x)   (*p2pD(x))

#define p2p(x)   ((void*)(x))
#define x2p(x)   p2p(&x)
#define x2pc(x)  p2pc(x2p(x))

#define x2c(x)   p2c(&(x))
#define x2i(x)   p2i(&(x))
#define x2l(x)   p2l(&(x))
#define x2d(x)   p2d(&(x))
#define x2D(x)   p2D(&(x))
/*----------------------------------------------------------------------------*/
/* Order */
#define MIN(x,y)  ((x)< (y)?(x):(y))
#define MAX(x,y)  ((x)> (y)?(x):(y))
#define EQU(x,y)  ((x)==(y)?  1:0  )
/*---------------------------------------------------------------------------------*
 * Generic constants:                                                              *
 *---------------------------------------------------------------------------------*/
#define  char_Sign (0x80)
#define short_Sign (0x8000)
#define  long_Sign (0x80000000)
/*----------------------------------------------------------------------------*/

#endif