[sdl_omap.git] / src / video / math_private.h

/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 */

/*
 * from: @(#)fdlibm.h 5.1 93/09/24
 * $Id: math_private.h 1969 2006-02-24 09:57:14Z slouken $
 */

#ifndef _MATH_PRIVATE_H_
#define _MATH_PRIVATE_H_

#include "SDL_name.h"
#include "SDL_endian.h"

#define huge		really_big /* huge is a reserved keyword in VC++ 6.0 */
#define u_int32_t	uint32_t

/* The original fdlibm code used statements like:
	n0 = ((*(int*)&one)>>29)^1;		* index of high word *
	ix0 = *(n0+(int*)&x);			* high word of x *
	ix1 = *((1-n0)+(int*)&x);		* low word of x *
   to dig two 32 bit words out of the 64 bit IEEE floating point
   value.  That is non-ANSI, and, moreover, the gcc instruction
   scheduler gets it wrong.  We instead use the following macros.
   Unlike the original code, we determine the endianness at compile
   time, not at run time; I don't see much benefit to selecting
   endianness at run time.  */

/* A union which permits us to convert between a double and two 32 bit
   ints.  */

/*
 * Math on arm is special:
 * For FPA, float words are always big-endian.
 * For VFP, floats words follow the memory system mode.
 */

#if (SDL_BYTEORDER == SDL_BIG_ENDIAN) || \
    (!defined(__VFP_FP__) && (defined(__arm__) || defined(__thumb__)))

typedef union
{
  double value;
  struct
  {
    u_int32_t msw;
    u_int32_t lsw;
  } parts;
} ieee_double_shape_type;

#else

typedef union
{
  double value;
  struct
  {
    u_int32_t lsw;
    u_int32_t msw;
  } parts;
} ieee_double_shape_type;

#endif

/* Get two 32 bit ints from a double.  */

#define EXTRACT_WORDS(ix0,ix1,d)				\
do {								\
  ieee_double_shape_type ew_u;					\
  ew_u.value = (d);						\
  (ix0) = ew_u.parts.msw;					\
  (ix1) = ew_u.parts.lsw;					\
} while (0)

/* Get the more significant 32 bit int from a double.  */

#define GET_HIGH_WORD(i,d)					\
do {								\
  ieee_double_shape_type gh_u;					\
  gh_u.value = (d);						\
  (i) = gh_u.parts.msw;						\
} while (0)

/* Get the less significant 32 bit int from a double.  */

#define GET_LOW_WORD(i,d)					\
do {								\
  ieee_double_shape_type gl_u;					\
  gl_u.value = (d);						\
  (i) = gl_u.parts.lsw;						\
} while (0)

/* Set a double from two 32 bit ints.  */

#define INSERT_WORDS(d,ix0,ix1)					\
do {								\
  ieee_double_shape_type iw_u;					\
  iw_u.parts.msw = (ix0);					\
  iw_u.parts.lsw = (ix1);					\
  (d) = iw_u.value;						\
} while (0)

/* Set the more significant 32 bits of a double from an int.  */

#define SET_HIGH_WORD(d,v)					\
do {								\
  ieee_double_shape_type sh_u;					\
  sh_u.value = (d);						\
  sh_u.parts.msw = (v);						\
  (d) = sh_u.value;						\
} while (0)

/* Set the less significant 32 bits of a double from an int.  */

#define SET_LOW_WORD(d,v)					\
do {								\
  ieee_double_shape_type sl_u;					\
  sl_u.value = (d);						\
  sl_u.parts.lsw = (v);						\
  (d) = sl_u.value;						\
} while (0)

/* A union which permits us to convert between a float and a 32 bit
   int.  */

typedef union
{
  float value;
  u_int32_t word;
} ieee_float_shape_type;

/* Get a 32 bit int from a float.  */

#define GET_FLOAT_WORD(i,d)					\
do {								\
  ieee_float_shape_type gf_u;					\
  gf_u.value = (d);						\
  (i) = gf_u.word;						\
} while (0)

/* Set a float from a 32 bit int.  */

#define SET_FLOAT_WORD(d,i)					\
do {								\
  ieee_float_shape_type sf_u;					\
  sf_u.word = (i);						\
  (d) = sf_u.value;						\
} while (0)


#ifdef __STDC__
static const double
#else
static double
#endif
zero    =  0.0,
one	=  1.0,
two	=  2.0,
two53	=  9007199254740992.0,	/* 0x43400000, 0x00000000 */
two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
huge   = 1.0e+300,
tiny   = 1.0e-300;

#endif /* _MATH_PRIVATE_H_ */
Commit	Line	Data
e14743d1	1	/*
	2	* ====================================================
	3	* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
	4	*
	5	* Developed at SunPro, a Sun Microsystems, Inc. business.
	6	* Permission to use, copy, modify, and distribute this
	7	* software is freely granted, provided that this notice
	8	* is preserved.
	9	* ====================================================
	10	*/
	11
	12	/*
	13	* from: @(#)fdlibm.h 5.1 93/09/24
	14	* $Id: math_private.h 1969 2006-02-24 09:57:14Z slouken $
	15	*/
	16
	17	#ifndef _MATH_PRIVATE_H_
	18	#define _MATH_PRIVATE_H_
	19
	20	#include "SDL_name.h"
	21	#include "SDL_endian.h"
	22
	23	#define huge really_big /* huge is a reserved keyword in VC++ 6.0 */
	24	#define u_int32_t uint32_t
	25
	26	/* The original fdlibm code used statements like:
	27	n0 = (((int)&one)>>29)^1; * index of high word *
	28	ix0 = (n0+(int)&x); * high word of x *
	29	ix1 = ((1-n0)+(int)&x); * low word of x *
	30	to dig two 32 bit words out of the 64 bit IEEE floating point
	31	value. That is non-ANSI, and, moreover, the gcc instruction
	32	scheduler gets it wrong. We instead use the following macros.
	33	Unlike the original code, we determine the endianness at compile
	34	time, not at run time; I don't see much benefit to selecting
	35	endianness at run time. */
	36
	37	/* A union which permits us to convert between a double and two 32 bit
	38	ints. */
	39
	40	/*
	41	* Math on arm is special:
	42	* For FPA, float words are always big-endian.
	43	* For VFP, floats words follow the memory system mode.
	44	*/
	45
	46	#if (SDL_BYTEORDER == SDL_BIG_ENDIAN) \|\| \
	47	(!defined(__VFP_FP__) && (defined(__arm__) \|\| defined(__thumb__)))
	48
	49	typedef union
	50	{
	51	double value;
	52	struct
	53	{
	54	u_int32_t msw;
	55	u_int32_t lsw;
	56	} parts;
	57	} ieee_double_shape_type;
	58
	59	#else
	60
	61	typedef union
	62	{
	63	double value;
	64	struct
65	{
66	u_int32_t lsw;
67	u_int32_t msw;
68	} parts;
69	} ieee_double_shape_type;
70
71	#endif
72
73	/* Get two 32 bit ints from a double. */
74
75	#define EXTRACT_WORDS(ix0,ix1,d) \
76	do { \
77	ieee_double_shape_type ew_u; \
78	ew_u.value = (d); \
79	(ix0) = ew_u.parts.msw; \
80	(ix1) = ew_u.parts.lsw; \
81	} while (0)
82
83	/* Get the more significant 32 bit int from a double. */
84
85	#define GET_HIGH_WORD(i,d) \
86	do { \
87	ieee_double_shape_type gh_u; \
88	gh_u.value = (d); \
89	(i) = gh_u.parts.msw; \
90	} while (0)
91
92	/* Get the less significant 32 bit int from a double. */
93
94	#define GET_LOW_WORD(i,d) \
95	do { \
96	ieee_double_shape_type gl_u; \
97	gl_u.value = (d); \
98	(i) = gl_u.parts.lsw; \
99	} while (0)
100
101	/* Set a double from two 32 bit ints. */
102
103	#define INSERT_WORDS(d,ix0,ix1) \
104	do { \
105	ieee_double_shape_type iw_u; \
106	iw_u.parts.msw = (ix0); \
107	iw_u.parts.lsw = (ix1); \
108	(d) = iw_u.value; \
109	} while (0)
110
111	/* Set the more significant 32 bits of a double from an int. */
112
113	#define SET_HIGH_WORD(d,v) \
114	do { \
115	ieee_double_shape_type sh_u; \
116	sh_u.value = (d); \
117	sh_u.parts.msw = (v); \
118	(d) = sh_u.value; \
119	} while (0)
120
121	/* Set the less significant 32 bits of a double from an int. */
122
123	#define SET_LOW_WORD(d,v) \
124	do { \
125	ieee_double_shape_type sl_u; \
126	sl_u.value = (d); \
127	sl_u.parts.lsw = (v); \
128	(d) = sl_u.value; \
129	} while (0)
130
131	/* A union which permits us to convert between a float and a 32 bit
132	int. */
133
134	typedef union
135	{
136	float value;
137	u_int32_t word;
138	} ieee_float_shape_type;
139
140	/* Get a 32 bit int from a float. */
141
142	#define GET_FLOAT_WORD(i,d) \
143	do { \
144	ieee_float_shape_type gf_u; \
145	gf_u.value = (d); \
146	(i) = gf_u.word; \
147	} while (0)
148
149	/* Set a float from a 32 bit int. */
150
151	#define SET_FLOAT_WORD(d,i) \
152	do { \
153	ieee_float_shape_type sf_u; \
154	sf_u.word = (i); \
155	(d) = sf_u.value; \
156	} while (0)
157
158
159	#ifdef __STDC__
160	static const double
161	#else
162	static double
163	#endif
164	zero = 0.0,
165	one = 1.0,
166	two = 2.0,
167	two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
168	two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
169	twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
170	huge = 1.0e+300,
171	tiny = 1.0e-300;
172
173	#endif /* _MATH_PRIVATE_H_ */