WebSVN – gelsvn – Diff – /trunk/src/CGLA/CGLA.h


#ifndef __CGLA_CGLA_H__
#define __CGLA_CGLA_H__
 
#include <cmath>
#include <cfloat>
#include <climits>
#include <cassert>
#include <algorithm>
#include <functional>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#endif
 
namespace CGLA 
{
  /** Procedural definition of NAN */  
  const float CGLA_NAN = log(-1.0f);
 
  /** NAN is used for initialization of vectors and matrices
      in debug mode */
  const float CGLA_INIT_VALUE = CGLA_NAN;
 
  /** Numerical constant representing something large.
      value is a bit arbitrary */
  const double BIG=10e+30;
 
  /** Numerical constant represents something extremely small.
      value is a bit arbitrary */
  const double MINUTE=10e-30;
 
  /** Numerical constant represents something very small.
      value is a bit arbitrary */
  const double TINY=3e-7;
	
  /** Numerical constant represents something small.
      value is a bit arbitrary */
  const double SMALL=10e-2;
 
  const double SQRT3=sqrt(3.0);
 
  /// Useful enum that represents coordiante axes.
  enum Axis {XAXIS=0,YAXIS=1,ZAXIS=2};
 
#ifdef WIN32
	inline bool isnan(double x) { return _isnan(x);}
#else
	inline bool isnan(double x) { return isnan(x);}
#endif
 
  template<class Scalar>
  Scalar s_min(Scalar a, Scalar b)
  {
    return a<b ? a : b;
  }
 
  template<class Scalar>
  Scalar s_max(Scalar a, Scalar b)
  {
    return a>b ? a : b;
  }
 
  ///Template for a function that squares the argument.
  template <class Scalar>
  inline Scalar sqr(Scalar x) {///
    return x*x;}
	
  /// Scalaremplate for a function that returns the cube of the argument.
  template <class Scalar>
  inline Scalar qbe(Scalar x) {///
    return x*x*x;}
 
  template <class Scalar>
  inline bool is_zero(Scalar x)	{return (x > -MINUTE && x < MINUTE);}
 
  template <class Scalar>
  inline bool is_tiny(Scalar x)	{return (x > -TINY && x < TINY);}
 
  /** What power of 2 ?. if x is the argument, find the largest 
      y so that 2^y <= x */
  inline int two_to_what_power(unsigned int x) 
  {
    if (x<1) 
      return -1;
    int i = 0;
    while (x != 1) {x>>=1;i++;}
    return i;
  }
 
#ifdef __sgi
  inline int round(float x) {return int(rint(x));}
#else
  inline int round(float x) {return int(x+0.5);}
#endif
 
  template<class T>
  inline T sign(T x) {return x>=T(0) ? 1 : -1;}
 
 
  template<class T>
  inline T int_pow(T x, unsigned int k) 
  {
    T y = static_cast<T>(1);
    for(unsigned int i=0;i<k;++i)
      y *= x;
    return y;
  }
 
	/** raw_assign takes a CGLA vector, matrix or whatever has a get() function
			as its first argument and a raw pointer to a (presumed scalar) entity 
			as the second argument. the contents dereferenced by the pointer is 
			copied to the entity given as first argument. */
  template<class T, class S>
  void raw_assign(T& a,  const S* b)
  {
    memcpy(static_cast<void*>(a.get()),static_cast<const void*>(b),sizeof(T));
  }
	
}
 
#endif
 

Rev 59	Rev 66
1	`#ifndef __CGLA_CGLA_H__`	1	`#ifndef __CGLA_CGLA_H__`
2	`#define __CGLA_CGLA_H__`	2	`#define __CGLA_CGLA_H__`
3		3
4	`#include <cmath>`	4	`#include <cmath>`
-		5	`#include <cfloat>`
5	`#include <climits>`	6	`#include <climits>`
6	`#include <cassert>`	7	`#include <cassert>`
7	`#include <algorithm>`	8	`#include <algorithm>`
-		9	`#include <functional>`
8		10
9	`#ifndef M_PI`	11	`#ifndef M_PI`
10	`#define M_PI 3.14159265358979323846`	12	`#define M_PI 3.14159265358979323846`
11	`#define M_PI_2 1.57079632679489661923`	13	`#define M_PI_2 1.57079632679489661923`
12	`#endif`	14	`#endif`
13		15
14	`namespace CGLA`	16	`namespace CGLA`
15	`{`	17	`{`
16	`/** Procedural definition of NAN */`	18	`/** Procedural definition of NAN */`
17	`const float CGLA_NAN = log(-1.0f);`	19	`const float CGLA_NAN = log(-1.0f);`
18		20
19	`/** NAN is used for initialization of vectors and matrices`	21	`/** NAN is used for initialization of vectors and matrices`
20	`in debug mode */`	22	`in debug mode */`
21	`const float CGLA_INIT_VALUE = CGLA_NAN;`	23	`const float CGLA_INIT_VALUE = CGLA_NAN;`
22		24
23	`/** Numerical constant representing something large.`	25	`/** Numerical constant representing something large.`
24	`value is a bit arbitrary */`	26	`value is a bit arbitrary */`
25	`const double BIG=10e+30;`	27	`const double BIG=10e+30;`
26		28
27	`/** Numerical constant represents something extremely small.`	29	`/** Numerical constant represents something extremely small.`
28	`value is a bit arbitrary */`	30	`value is a bit arbitrary */`
29	`const double MINUTE=10e-30;`	31	`const double MINUTE=10e-30;`
30		32
31	`/** Numerical constant represents something very small.`	33	`/** Numerical constant represents something very small.`
32	`value is a bit arbitrary */`	34	`value is a bit arbitrary */`
33	`const double TINY=3e-7;`	35	`const double TINY=3e-7;`
34		36
35	`/** Numerical constant represents something small.`	37	`/** Numerical constant represents something small.`
36	`value is a bit arbitrary */`	38	`value is a bit arbitrary */`
37	`const double SMALL=10e-2;`	39	`const double SMALL=10e-2;`
38		40
39	`const double SQRT3=sqrt(3.0);`	41	`const double SQRT3=sqrt(3.0);`
40		42
41	`/// Useful enum that represents coordiante axes.`	43	`/// Useful enum that represents coordiante axes.`
42	`enum Axis {XAXIS=0,YAXIS=1,ZAXIS=2};`	44	`enum Axis {XAXIS=0,YAXIS=1,ZAXIS=2};`
43		45
44	`#ifdef WIN32`	46	`#ifdef WIN32`
45	`inline bool isnan(double x) { return _isnan(x);}`	47	`inline bool isnan(double x) { return _isnan(x);}`
46	`#else`	48	`#else`
47	`inline bool isnan(double x) { return isnan(x);}`	49	`inline bool isnan(double x) { return isnan(x);}`
48	`#endif`	50	`#endif`
49		51
50	`template<class Scalar>`	52	`template<class Scalar>`
51	`Scalar s_min(Scalar a, Scalar b)`	53	`Scalar s_min(Scalar a, Scalar b)`
52	`{`	54	`{`
53	`return a<b ? a : b;`	55	`return a<b ? a : b;`
54	`}`	56	`}`
55		57
56	`template<class Scalar>`	58	`template<class Scalar>`
57	`Scalar s_max(Scalar a, Scalar b)`	59	`Scalar s_max(Scalar a, Scalar b)`
58	`{`	60	`{`
59	`return a>b ? a : b;`	61	`return a>b ? a : b;`
60	`}`	62	`}`
61		63
62	`///Template for a function that squares the argument.`	64	`///Template for a function that squares the argument.`
63	`template <class Scalar>`	65	`template <class Scalar>`
64	`inline Scalar sqr(Scalar x) {///`	66	`inline Scalar sqr(Scalar x) {///`
65	`return x*x;}`	67	`return x*x;}`
66		68
67	`/// Scalaremplate for a function that returns the cube of the argument.`	69	`/// Scalaremplate for a function that returns the cube of the argument.`
68	`template <class Scalar>`	70	`template <class Scalar>`
69	`inline Scalar qbe(Scalar x) {///`	71	`inline Scalar qbe(Scalar x) {///`
70	`return xxx;}`	72	`return xxx;}`
71		73
72	`template <class Scalar>`	74	`template <class Scalar>`
73	`inline bool is_zero(Scalar x) {return (x > -MINUTE && x < MINUTE);}`	75	`inline bool is_zero(Scalar x) {return (x > -MINUTE && x < MINUTE);}`
74		76
75	`template <class Scalar>`	77	`template <class Scalar>`
76	`inline bool is_tiny(Scalar x) {return (x > -TINY && x < TINY);}`	78	`inline bool is_tiny(Scalar x) {return (x > -TINY && x < TINY);}`
77		79
78	`/** What power of 2 ?. if x is the argument, find the largest`	80	`/** What power of 2 ?. if x is the argument, find the largest`
79	`y so that 2^y <= x */`	81	`y so that 2^y <= x */`
80	`inline int two_to_what_power(unsigned int x)`	82	`inline int two_to_what_power(unsigned int x)`
81	`{`	83	`{`
82	`if (x<1)`	84	`if (x<1)`
83	`return -1;`	85	`return -1;`
84	`int i = 0;`	86	`int i = 0;`
85	`while (x != 1) {x>>=1;i++;}`	87	`while (x != 1) {x>>=1;i++;}`
86	`return i;`	88	`return i;`
87	`}`	89	`}`
88		90
89	`#ifdef __sgi`	91	`#ifdef __sgi`
90	`inline int round(float x) {return int(rint(x));}`	92	`inline int round(float x) {return int(rint(x));}`
91	`#else`	93	`#else`
92	`inline int round(float x) {return int(x+0.5);}`	94	`inline int round(float x) {return int(x+0.5);}`
93	`#endif`	95	`#endif`
94		96
95	`template<class T>`	97	`template<class T>`
96	`inline T sign(T x) {return x>=T(0) ? 1 : -1;}`	98	`inline T sign(T x) {return x>=T(0) ? 1 : -1;}`
97		99
98		100
99	`template<class T>`	101	`template<class T>`
100	`inline T int_pow(T x, unsigned int k)`	102	`inline T int_pow(T x, unsigned int k)`
101	`{`	103	`{`
102	`T y = static_cast<T>(1);`	104	`T y = static_cast<T>(1);`
103	`for(unsigned int i=0;i<k;++i)`	105	`for(unsigned int i=0;i<k;++i)`
104	`y *= x;`	106	`y *= x;`
105	`return y;`	107	`return y;`
106	`}`	108	`}`
107		109
108	`/** raw_assign takes a CGLA vector, matrix or whatever has a get() function`	110	`/** raw_assign takes a CGLA vector, matrix or whatever has a get() function`
109	`as its first argument and a raw pointer to a (presumed scalar) entity`	111	`as its first argument and a raw pointer to a (presumed scalar) entity`
110	`as the second argument. the contents dereferenced by the pointer is`	112	`as the second argument. the contents dereferenced by the pointer is`
111	`copied to the entity given as first argument. */`	113	`copied to the entity given as first argument. */`
112	`template<class T, class S>`	114	`template<class T, class S>`
113	`void raw_assign(T& a, const S* b)`	115	`void raw_assign(T& a, const S* b)`
114	`{`	116	`{`
115	`memcpy(static_cast<void>(a.get()),static_cast<const void>(b),sizeof(T));`	117	`memcpy(static_cast<void>(a.get()),static_cast<const void>(b),sizeof(T));`
116	`}`	118	`}`
117		119
118	`}`	120	`}`
119		121
120	`#endif`	122	`#endif`
121		123

Subversion Repositories gelsvn

(root)/trunk/src/CGLA/CGLA.h – Rev 59 → 66