Subversion Repositories gelsvn

Rev

Rev 595 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
595 jab 1
/* ----------------------------------------------------------------------- *
2
 * This file is part of GEL, http://www.imm.dtu.dk/GEL
3
 * Copyright (C) the authors and DTU Informatics
4
 * For license and list of authors, see ../../doc/intro.pdf
5
 * ----------------------------------------------------------------------- */
248 bj 6
 
595 jab 7
/** @file CGLA.h
8
 * @brief CGLA main header: contains a number of constants and function decs.
9
 */
10
 
12 jab 11
#ifndef __CGLA_CGLA_H__
12
#define __CGLA_CGLA_H__
2 bj 13
 
102 bj 14
#if (_MSC_VER >= 1200)
195 jrf 15
#pragma warning (disable: 4244 4800)
102 bj 16
#endif
17
 
2 bj 18
#include <cmath>
66 bj 19
#include <cfloat>
2 bj 20
#include <climits>
21
#include <cassert>
22
#include <algorithm>
66 bj 23
#include <functional>
2 bj 24
 
25
#ifndef M_PI
26
#define M_PI 3.14159265358979323846
27
#define M_PI_2 1.57079632679489661923
28
#endif
29
 
624 mono 30
#ifndef DEGREES_TO_RADIANS
31
#define DEGREES_TO_RADIANS (M_PI / 180.0)
32
#endif
33
 
12 jab 34
namespace CGLA 
35
{
129 jab 36
		inline float cgla_nan() 
37
		{
196 jrf 38
				static const float cgla_nan_value = log(-1.0f);
129 jab 39
				return cgla_nan_value;
40
		}
41
 
21 jrf 42
  /** Procedural definition of NAN */  
129 jab 43
#define CGLA_NAN cgla_nan()
21 jrf 44
 
45
  /** NAN is used for initialization of vectors and matrices
46
      in debug mode */
129 jab 47
#define CGLA_INIT_VALUE cgla_nan()
21 jrf 48
 
12 jab 49
  /** Numerical constant representing something large.
50
      value is a bit arbitrary */
51
  const double BIG=10e+30;
2 bj 52
 
12 jab 53
  /** Numerical constant represents something extremely small.
54
      value is a bit arbitrary */
55
  const double MINUTE=10e-30;
2 bj 56
 
12 jab 57
  /** Numerical constant represents something very small.
58
      value is a bit arbitrary */
59
  const double TINY=3e-7;
2 bj 60
 
12 jab 61
  /** Numerical constant represents something small.
62
      value is a bit arbitrary */
63
  const double SMALL=10e-2;
2 bj 64
 
417 jrf 65
  /** The GEL pseudo-random number generator uses
66
      UINT_MAX as RAND_MAX to avoid mod operations. */
67
  const unsigned int GEL_RAND_MAX=UINT_MAX;
68
 
129 jab 69
		inline double sqrt3()
70
		{
71
				static const double sqrt3_val = sqrt(3.0);
72
				return sqrt3_val;
73
		}
2 bj 74
 
129 jab 75
#define SQRT3 sqrt3()
76
 
12 jab 77
  /// Useful enum that represents coordiante axes.
78
  enum Axis {XAXIS=0,YAXIS=1,ZAXIS=2};
2 bj 79
 
197 jrf 80
  inline bool isnan(double x) { return x != x; }
55 jab 81
 
12 jab 82
  template<class Scalar>
83
  Scalar s_min(Scalar a, Scalar b)
84
  {
85
    return a<b ? a : b;
86
  }
2 bj 87
 
12 jab 88
  template<class Scalar>
89
  Scalar s_max(Scalar a, Scalar b)
90
  {
91
    return a>b ? a : b;
92
  }
2 bj 93
 
417 jrf 94
  /// Template for a function that squares the argument.
12 jab 95
  template <class Scalar>
96
  inline Scalar sqr(Scalar x) {///
97
    return x*x;}
2 bj 98
 
417 jrf 99
  /// Scalar template for a function that returns the cube of the argument.
12 jab 100
  template <class Scalar>
101
  inline Scalar qbe(Scalar x) {///
102
    return x*x*x;}
2 bj 103
 
12 jab 104
  template <class Scalar>
105
  inline bool is_zero(Scalar x)	{return (x > -MINUTE && x < MINUTE);}
2 bj 106
 
12 jab 107
  template <class Scalar>
108
  inline bool is_tiny(Scalar x)	{return (x > -TINY && x < TINY);}
2 bj 109
 
12 jab 110
  /** What power of 2 ?. if x is the argument, find the largest 
111
      y so that 2^y <= x */
45 jab 112
  inline int two_to_what_power(unsigned int x) 
12 jab 113
  {
114
    if (x<1) 
115
      return -1;
116
    int i = 0;
117
    while (x != 1) {x>>=1;i++;}
118
    return i;
119
  }
2 bj 120
 
121
#ifdef __sgi
12 jab 122
  inline int round(float x) {return int(rint(x));}
2 bj 123
#else
12 jab 124
  inline int round(float x) {return int(x+0.5);}
2 bj 125
#endif
126
 
12 jab 127
  template<class T>
128
  inline T sign(T x) {return x>=T(0) ? 1 : -1;}
2 bj 129
 
277 jrf 130
  /// Integer power function with O(log(n)) complexity
12 jab 131
  template<class T>
277 jrf 132
  inline T int_pow(T a, unsigned int n)
12 jab 133
  {
277 jrf 134
    T result = static_cast<T>(1);
135
    for(; n > 0; n >>= 1)
136
    {
137
      if(n & 1) result = result*a;
138
      a *= a;
139
    }
140
    return result;
12 jab 141
  }
417 jrf 142
 
143
  /// Function that seeds the GEL pseudo-random number generator
144
  void gel_srand(unsigned int seed);
2 bj 145
 
417 jrf 146
  /** GEL provides a linear congruential pseudo-random number 
147
      generator which is optimized for speed. This version allows 
148
      an integer argument which is useful for grid-based noise
149
      functions. */
150
  unsigned int gel_rand(unsigned int k);
151
 
152
  /** GEL provides a linear congruential pseudo-random number 
153
      generator which is optimized for speed. This means
154
      that GEL_RAND_MAX==UINT_MAX. */
155
  unsigned int gel_rand();
156
 
39 bj 157
	/** raw_assign takes a CGLA vector, matrix or whatever has a get() function
158
			as its first argument and a raw pointer to a (presumed scalar) entity 
159
			as the second argument. the contents dereferenced by the pointer is 
160
			copied to the entity given as first argument. */
12 jab 161
  template<class T, class S>
162
  void raw_assign(T& a,  const S* b)
163
  {
164
    memcpy(static_cast<void*>(a.get()),static_cast<const void*>(b),sizeof(T));
165
  }
2 bj 166
 
167
}
168
 
169
#endif