Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

gul Namespace Reference


Compounds

class  gul::AllocError
struct  gul::bounding_box
struct  gul::curve
class  gul::debug_streambuf
class  gul::dump_curve
class  gul::dump_defaults
class  gul::dump_line
class  gul::dump_list
class  gul::dump_matrix
class  gul::dump_point
class  gul::dump_surf
class  gul::dump_vector
class  gul::Error
class  gul::hpoint
class  gul::hpoint1
class  gul::hpoint2
class  gul::InternalError
class  gul::IntervalDivZeroError
struct  gul::itriangle
class  gul::kdarray
struct  gul::kdpoint
struct  gul::knot_vec
struct  gul::line
struct  gul::line2
class  gul::List
class  gul::List2
class  gul::ListNode
struct  gul::ListNodeInfo
struct  gul::Map
struct  gul::mat4x4
struct  gul::Map::Node
class  gul::pool_bytealloc
class  gul::pool_object
class  gul::poolalloc
struct  gul::poolalloc::rebind
class  gul::poolalloc< void >
struct  gul::poolalloc< void >::rebind
struct  gul::RefMap::Node
class  gul::point
class  gul::point1
class  gul::point2
struct  gul::point_net
struct  gul::point_vec
struct  gul::polyline
class  gul::PoolAllocError
class  gul::pooldeque
class  gul::poolmap
class  gul::poolstack
class  gul::Ptr
union  gul::ptr_int_union
struct  gul::Ptr::Ptr_rep
struct  gul::RefMap
struct  gul::rtr
struct  gul::rtr< double >
struct  gul::rtr< float >
struct  gul::rtr< guar::rational >
struct  gul::rtr< int >
struct  gul::rtr< unsigned int >
class  gul::SingularMatrixError
struct  gul::Stack
class  gul::streambufrec
struct  gul::surface
struct  gul::triangle
struct  gul::triangle2
class  gul::vec4

Typedefs

typedef basic_string< char,
char_traits< char >, gul::poolalloc<
char > > 		poolstring
typedef unsigned long long uint64
typedef long long int64
typedef unsigned long uint32
typedef long int32
typedef int sub_range [2]

Enumerations

enum  dump_format { human_readable = 0, gul_format }
enum  dump_point_format { homogeneous = 0, euclidian, mixed }
enum  DomainDirection { u_direction, v_direction }

Functions

template<> int test (const guar::rational &a)
template<> int compare (const guar::rational &A, const guar::rational &B)
std::ostream & operator<< (std::ostream &s, const guar::rational &r)
template<class X, class A> void Assert (A assertion)
template<class T> bool rel_equal (const T &a, const T &b, const T &eps)
template<class T> bool rel_equal (const gul::hpoint< T > &a, const gul::hpoint< T > &b, const T &eps)
template<class T> bool rel_equal (const gul::hpoint2< T > &a, const gul::hpoint2< T > &b, const T &eps)
template<class T> bool rel_equal (const gul::hpoint1< T > &a, const gul::hpoint1< T > &b, const T &eps)
template<class T> bool rel_equal (const gul::point< T > &a, const gul::point< T > &b, const T &eps)
template<class T> bool rel_equal (const gul::point2< T > &a, const gul::point2< T > &b, const T &eps)
template<class T> bool rel_equal (const gul::point1< T > &a, const gul::point1< T > &b, const T &eps)
template<class T> T max_norm (const point< T > &a)
template<class T> T max_norm (const point2< T > &a)
template<class T> bool zero_sine (const point< T > &ina, const point< T > &inb, const T &eps)
template<class T> bool zero_sine (const point2< T > &ina, const point2< T > &inb, const T &eps)
template<class T> bool abs_equal (const T &a, const T &b, const T &eps)
template<class T> bool abs_equal (const gul::hpoint< T > &a, const gul::hpoint< T > &b, const T &eps)
template<class T> bool abs_equal (const gul::hpoint2< T > &a, const gul::hpoint2< T > &b, const T &eps)
template<class T> bool abs_equal (const gul::hpoint1< T > &a, const gul::hpoint1< T > &b, const T &eps)
template<class T> bool abs_equal (const gul::point< T > &a, const gul::point< T > &b, const T &eps)
template<class T> bool abs_equal (const gul::point2< T > &a, const gul::point2< T > &b, const T &eps)
template<class T> bool abs_equal (const gul::point1< T > &a, const gul::point1< T > &b, const T &eps)
template<class EP> std::ostream & operator<< (std::ostream &os, const gul::dump_point< EP > &P)
template<class T> ostream & operator<< (ostream &s, const point1< T > &p)
template<class T> ostream & operator<< (ostream &s, const hpoint1< T > &p)
template<class T> ostream & operator<< (ostream &s, const point2< T > &p)
template<class T> ostream & operator<< (ostream &s, const hpoint2< T > &p)
template<class T> ostream & operator<< (ostream &s, const point< T > &p)
template<class T> ostream & operator<< (ostream &s, const hpoint< T > &p)
template<class EP, class L> ostream & operator<< (ostream &os, const dump_line< EP, L > &l)
template<class T> ostream & operator<< (ostream &os, const line< T > &l)
template<class T> ostream & operator<< (ostream &os, const line2< T > &l)
template<class T> ostream & operator<< (ostream &os, const dump_list< T > &L)
template<class T, class HP> ostream & operator<< (ostream &os, const dump_surf< T, HP > &s)
template<class T, class HP> ostream & operator<< (ostream &os, const dump_curve< T, HP > &c)
template<class HP> ostream & operator<< (ostream &os, const dump_matrix< HP > &m)
template<class HP> ostream & operator<< (ostream &os, const dump_vector< HP > &m)
template<class T> mat4x4< T > operator * (mat4x4< T > a, mat4x4< T > b)
template<class T, class T2> void MCopy (int m, int n, const Ptr< Ptr< T2 > > &A, Ptr< Ptr< T > > &C)
template<class T, class T2> void MCopy (int m, int n, const Ptr< Ptr< T2 > > &A, Ptr< T > &C)
template<class T, class T2> void MCopy (int m, int n, const Ptr< T2 > &A, Ptr< Ptr< T > > &C)
template<class T> void MMProduct (int r, int s, int t, Ptr< Ptr< T > > &A, Ptr< Ptr< T > > &B, Ptr< Ptr< T > > &C)
template<class T> void MMProduct (int r, int s, int t, Ptr< T > &A, Ptr< T > &B, Ptr< T > &C)
template<class T> vec4< T > operator * (mat4x4< T > a, vec4< T > b)
template<class T> void MVProduct (int n, int m, Ptr< Ptr< T > > &A, Ptr< T > &x, Ptr< T > &b)
template<class T> void VMProduct (int n, int m, const Ptr< T > &x, const Ptr< Ptr< T > > &A, Ptr< T > &b)
template<class T> void VMProduct (int n, int m, const Ptr< T > &x, const Ptr< T > &A, Ptr< T > &b)
template<class T> vec4< T > operator * (vec4< T > b, mat4x4< T > a)
template<class T> void CubeVerts (const T &xmin, const T &xmax, const T &ymin, const T &ymax, const T &zmin, const T &zmax, vec4< T > *v)
template<class T> void CubeVerts (const T &xmin, const T &xmax, const T &ymin, const T &ymax, const T &zmin, const T &zmax, point< T > *v)
template<class T> void CubeVerts (const Ptr< T > &bb, Ptr< point< T > > &v)
template<class T> int compare (const T &a, const T &b)
template<class T> int test (const T &a)
template<class T> T Max (const T &a, const T &b)
template<class T> T Min (const T &a, const T &b)
template<class T> T Max (const T &a, const T &b, const T &c)
template<class T> T Min (const T &a, const T &b, const T &c)
template<class T> void Swap (T &a, T &b)
template<class T> T Square (const T &a)
template<class T> T Sign (const T &a, const T &b)
template<class T> bool operator== (const poolalloc< T > &, const poolalloc< T > &) throw ()
template<class T> bool operator!= (const poolalloc< T > &, const poolalloc< T > &) throw ()
template<class T> void set (hpoint< T > &c, T a)
template<class T> hpoint< T > operator+ (const hpoint< T > &a, const hpoint< T > &b)
template<class T> hpoint< T > operator- (const hpoint< T > &a)
template<class T> hpoint< T > operator- (const hpoint< T > &a, const hpoint< T > &b)
template<class T> hpoint< T > operator * (const T op, const hpoint< T > &a)
template<class T> T operator * (const hpoint< T > &a, const hpoint< T > &b)
template<class T> point< T > euclid (const hpoint< T > &a)
template<class T> T weight (const hpoint< T > &a)
template<class T> void set (hpoint2< T > &c, T a)
template<class T> hpoint2< T > operator+ (const hpoint2< T > &a, const hpoint2< T > &b)
template<class T> hpoint2< T > operator- (const hpoint2< T > &a)
template<class T> hpoint2< T > operator- (const hpoint2< T > &a, const hpoint2< T > &b)
template<class T> hpoint2< T > operator * (const T op, const hpoint2< T > &a)
template<class T> T operator * (const hpoint2< T > a, const hpoint2< T > &b)
template<class T> point2< T > euclid (const hpoint2< T > &a)
template<class T> T weight (const hpoint2< T > &a)
template<class T> void set (hpoint1< T > &c, T a)
template<class T> hpoint1< T > operator+ (const hpoint1< T > &a, const hpoint1< T > &b)
template<class T> hpoint1< T > operator- (const hpoint1< T > &a)
template<class T> hpoint1< T > operator- (const hpoint1< T > &a, const hpoint1< T > &b)
template<class T> hpoint1< T > operator * (const T op, const hpoint1< T > &a)
template<class T> T operator * (const hpoint1< T > &a, const hpoint1< T > &b)
template<class T> point1< T > euclid (const hpoint1< T > &a)
template<class T> T weight (const hpoint1< T > &a)
template<class T> void set (point< T > &c, T a)
template<class T> point< T > operator+ (const point< T > &a, const point< T > &b)
template<class T> point< T > operator- (const point< T > &a)
template<class T> point< T > operator- (const point< T > &a, const point< T > &b)
template<class T> point< T > operator * (const T op, const point< T > &a)
template<class T> T operator * (const point< T > &a, const point< T > &b)
template<class T> point< T > euclid (const point< T > &a)
template<class T> T weight (const point< T > &a)
template<class T> bool operator!= (const point2< T > &a, const point2< T > &b)
template<class T> void set (point2< T > &c, T a)
template<class T> point2< T > operator+ (const point2< T > &a, const point2< T > &b)
template<class T> point2< T > operator- (const point2< T > &a)
template<class T> point2< T > operator- (const point2< T > &a, const point2< T > &b)
template<class T> point2< T > operator * (const T op, const point2< T > &a)
template<class T> T operator * (const point2< T > &a, const point2< T > &b)
template<class T> point2< T > euclid (const point2< T > &a)
template<class T> T weight (const point2< T > &a)
template<class T> void set (point1< T > &c, T a)
template<class T> point1< T > operator+ (const point1< T > &a, const point1< T > &b)
template<class T> point1< T > operator- (const point1< T > &a)
template<class T> point1< T > operator- (const point1< T > &a, const point1< T > &b)
template<class T> point1< T > operator * (const T op, const point1< T > &a)
template<class T> T operator * (const point1< T > a, const point1< T > &b)
template<class T> point1< T > euclid (const point1< T > &a)
template<class T> T weight (const point1< T > &a)
template<class T> point< T > ortho (const hpoint< T > &a)
template<class T> point2< T > ortho (const hpoint2< T > &a)
template<class T> point1< T > ortho (const hpoint1< T > &a)
template<class T> point< T > ortho (const point< T > &a)
template<class T> point2< T > ortho (const point2< T > &a)
template<class T> point1< T > ortho (const point1< T > &a)
template<class T> point< T > cross_product (const point< T > &a, const point< T > &b)
template<class T> point< T > cross_product (const point2< T > &a, const point2< T > &b)
template<class T> T length (const point< T > &a)
template<class T> T normalize (point< T > *c, const point< T > &a)
template<class T> T normalize (point2< T > *c, const point2< T > &a)
template<class T> T distance (const point< T > &a, const point< T > &b)
template<class T> T distance (const point2< T > &a, const point2< T > &b)
template<class T> T distance (const point1< T > &a, const point1< T > &b)
template<class T> T euclidian_distance (const hpoint< T > &a, const hpoint< T > &b)
template<class T> T euclidian_distance (const hpoint2< T > &a, const hpoint2< T > &b)
template<class T> T euclidian_distance (const hpoint1< T > &a, const hpoint1< T > &b)
template<class T> T euclidian_distance (const point< T > &a, const point< T > &b)
template<class T> T euclidian_distance (const point2< T > &a, const point2< T > &b)
template<class T> T euclidian_distance (const point1< T > &a, const point1< T > &b)
template<class HP> HP ProjectToLine (const HP &S, const HP &T, const HP &P)
 Project a point onto a line (in 3-D). More...


Variables

const bool ndebug = false

Typedef Documentation

typedef long gul::int32
 

Definition at line 140 of file gul_types.h.

typedef long long gul::int64
 

Definition at line 129 of file gul_types.h.

typedef basic_string<char,char_traits<char>,gul::poolalloc<char> > gul::poolstring
 

Definition at line 53 of file gul_std.h.

typedef int gul::sub_range[2]
 

Definition at line 667 of file gul_types.h.

Referenced by gul::Ptr< EP >::realloc().

typedef unsigned long gul::uint32
 

Definition at line 139 of file gul_types.h.

typedef unsigned long long gul::uint64
 

Definition at line 128 of file gul_types.h.

Enumeration Type Documentation

enum gul::DomainDirection
 

Enumeration values:
u_direction 
v_direction 

Definition at line 661 of file gul_types.h.

Referenced by gul::Ptr< EP >::realloc(). 

00662 {
00663   u_direction,
00664   v_direction
00665 };

enum gul::dump_format
 

Enumeration values:
human_readable 
gul_format 

Definition at line 27 of file gul_io.h.

Referenced by gul::dump_line::dump_line(), gul::dump_point::dump_point(), gul::dump_surf::dump_surf(), and gul::dump_defaults::set_format(). 

00028 {
00029   human_readable = 0,
00030   gul_format
00031 };

enum gul::dump_point_format
 

Enumeration values:
homogeneous 
euclidian 
mixed 

Definition at line 33 of file gul_io.h.

Referenced by gul::dump_line::dump_line(), gul::dump_point::dump_point(), gul::dump_surf::dump_surf(), and gul::dump_defaults::set_point_format(). 

00034 {
00035   homogeneous = 0,
00036   euclidian,
00037   mixed
00038 };

Function Documentation

template<class T>
bool abs_equal (  const gul::point1< T > &    a,
const gul::point1< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 258 of file gul_float.h. 

00260 {
00261   T tol = eps;
00262 
00263   if( !abs_equal(a.x, b.x, tol) ) return false;
00264 
00265   return true;
00266 }

template<class T>
bool abs_equal (  const gul::point2< T > &    a,
const gul::point2< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 246 of file gul_float.h. 

00248 {
00249   T tol = eps / rtr<T>::root2_2();
00250 
00251   if( !abs_equal(a.x, b.x, tol) ) return false;
00252   if( !abs_equal(a.y, b.y, tol) ) return false;
00253 
00254   return true;
00255 }

template<class T>
bool abs_equal (  const gul::point< T > &    a,
const gul::point< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 233 of file gul_float.h. 

00235 {
00236   T tol = eps / rtr<T>::root2_3();
00237 
00238   if( !abs_equal(a.x, b.x, tol) ) return false;
00239   if( !abs_equal(a.y, b.y, tol) ) return false;
00240   if( !abs_equal(a.z, b.z, tol) ) return false;
00241 
00242   return true;
00243 }

template<class T>
bool abs_equal (  const gul::hpoint1< T > &    a,
const gul::hpoint1< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 221 of file gul_float.h. 

00223 {
00224   T tol = eps / rtr<T>::root2_2();
00225 
00226   if( !abs_equal(a.x, b.x, tol) ) return false;
00227   if( !abs_equal(a.w, b.w, tol) ) return false;
00228 
00229   return true;
00230 }

template<class T>
bool abs_equal (  const gul::hpoint2< T > &    a,
const gul::hpoint2< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 208 of file gul_float.h. 

00210 {
00211   T tol = eps / rtr<T>::root2_3();
00212 
00213   if( !abs_equal(a.x, b.x, tol) ) return false;
00214   if( !abs_equal(a.y, b.y, tol) ) return false;
00215   if( !abs_equal(a.w, b.w, tol) ) return false;
00216 
00217   return true;
00218 }

template<class T>
bool abs_equal (  const gul::hpoint< T > &    a,
const gul::hpoint< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 194 of file gul_float.h. 

00196 {
00197   T tol = eps / (T)2;
00198 
00199   if( !abs_equal(a.x, b.x, tol) ) return false;
00200   if( !abs_equal(a.y, b.y, tol) ) return false;
00201   if( !abs_equal(a.z, b.z, tol) ) return false;
00202   if( !abs_equal(a.w, b.w, tol) ) return false;
00203 
00204   return true;
00205 }

template<class T>
bool abs_equal (  const T &    a,
const T &    b,
const T &    eps
)  [inline]
 

Definition at line 180 of file gul_float.h. 

00181 {
00182   return rtr<T>::fabs(a-b) <= eps; 
00183 }

template<class X, class A>
void Assert (  A    assertion )  [inline]
 

Definition at line 72 of file gul_error.h. 

00073 {
00074  if(!assertion) throw X();
00075 }

template<class T>
int compare (  const T &    a,
const T &    b
)  [inline]
 

Definition at line 143 of file gul_types.h. 

00144 {
00145   if( a < b ) 
00146     return -1;
00147   else if( a == b )
00148     return 0;
00149   return 1;
00150 }

template<>
int compare (  const guar::rational &    A,
const guar::rational &    B
)  [inline]
 

Definition at line 626 of file guar_exact.h. 

00627 {
00628   guar::Interval i;
00629   
00630   if( A.m == B.m )
00631     return 0;
00632 
00633   if( !A.m->m_bounds ) A.calc_bounds();
00634   if( !B.m->m_bounds ) B.calc_bounds();  
00635   i = A.m->m_i - B.m->m_i;
00636   if( i.m_high < 0.0 ) return(-1); 
00637   else if( i.m_low > 0.0 ) return(1); 
00638 
00639   guar::rational c = A - B;
00640   if( c.m->m_sign ) return(-1);
00641   if( c.m->m_na == 0 ) return(0);
00642 
00643   return(1);
00644 }

template<class T>
point<T> cross_product (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 399 of file gul_vector.h. 

00400 {
00401   return point<T>((T)0,
00402                   (T)0,
00403                   a.x*b.y-b.x*a.y);
00404 }

template<class T>
point<T> cross_product (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 392 of file gul_vector.h. 

00393 {
00394   return point<T>(a.y*b.z-b.y*a.z,
00395                   b.x*a.z-a.x*b.z,
00396                   a.x*b.y-b.x*a.y);
00397 }

template<class T>
void CubeVerts (  const Ptr< T > &    bb,
Ptr< point< T > > &    v
) 
 

Definition at line 296 of file gul_matrix.h. 

00297 {
00298   CubeVerts<T>( bb[0], bb[1], bb[2], bb[3], bb[4], bb[5], &v[0] );
00299 }

template<class T>
void CubeVerts (  const T &    xmin,
const T &    xmax,
const T &    ymin,
const T &    ymax,
const T &    zmin,
const T &    zmax,
point< T > *    v
) 
 

Definition at line 257 of file gul_matrix.h. 

00261 {
00262   v[0].x = xmin;
00263   v[0].y = ymin;
00264   v[0].z = zmin;
00265 
00266   v[1].x = xmax;
00267   v[1].y = ymin;
00268   v[1].z = zmin;
00269 
00270   v[2].x = xmax;
00271   v[2].y = ymax;
00272   v[2].z = zmin;
00273 
00274   v[3].x = xmin;
00275   v[3].y = ymax;
00276   v[3].z = zmin;
00277 
00278   v[4].x = xmin;
00279   v[4].y = ymin;
00280   v[4].z = zmax;
00281 
00282   v[5].x = xmax;
00283   v[5].y = ymin;
00284   v[5].z = zmax;
00285 
00286   v[6].x = xmax;
00287   v[6].y = ymax;
00288   v[6].z = zmax;
00289 
00290   v[7].x = xmin;
00291   v[7].y = ymax;
00292   v[7].z = zmax;
00293 }

template<class T>
void CubeVerts (  const T &    xmin,
const T &    xmax,
const T &    ymin,
const T &    ymax,
const T &    zmin,
const T &    zmax,
vec4< T > *    v
) 
 

Definition at line 209 of file gul_matrix.h. 

00213 {
00214   v[0][0] = xmin;
00215   v[0][1] = ymin;
00216   v[0][2] = zmin;
00217   v[0][3] = (T)1.0;
00218 
00219   v[1][0] = xmax;
00220   v[1][1] = ymin;
00221   v[1][2] = zmin;
00222   v[1][3] = (T)1.0;
00223 
00224   v[2][0] = xmax;
00225   v[2][1] = ymax;
00226   v[2][2] = zmin;
00227   v[2][3] = (T)1.0;
00228 
00229   v[3][0] = xmin;
00230   v[3][1] = ymax;
00231   v[3][2] = zmin;
00232   v[3][3] = (T)1.0;
00233 
00234 
00235   v[4][0] = xmin;
00236   v[4][1] = ymin;
00237   v[4][2] = zmax;
00238   v[4][3] = (T)1.0;
00239 
00240   v[5][0] = xmax;
00241   v[5][1] = ymin;
00242   v[5][2] = zmax;
00243   v[5][3] = (T)1.0;
00244 
00245   v[6][0] = xmax;
00246   v[6][1] = ymax;
00247   v[6][2] = zmax;
00248   v[6][3] = (T)1.0;
00249 
00250   v[7][0] = xmin;
00251   v[7][1] = ymax;
00252   v[7][2] = zmax;
00253   v[7][3] = (T)1.0;
00254 }

template<class T>
T distance (  const point1< T > &    a,
const point1< T > &    b
)  [inline]
 

Definition at line 459 of file gul_vector.h. 

00460 {
00461   T x = a.x-b.x, d;
00462   
00463   d = rtr<T>::fabs( x );
00464   return d;
00465 }

template<class T>
T distance (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 451 of file gul_vector.h. 

00452 {
00453   T x = a.x-b.x, y = a.y-b.y, d;
00454   
00455   d = rtr<T>::sqrt( x*x + y*y );
00456   return d;
00457 }

template<class T>
T distance (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 443 of file gul_vector.h. 

00444 {
00445   T x = a.x-b.x, y = a.y-b.y, z = a.z-b.z, d;
00446   
00447   d = rtr<T>::sqrt( x*x + y*y + z*z );
00448   return d;
00449 }

template<class T>
point1<T> euclid (  const point1< T > &    a )  [inline]
 

Definition at line 344 of file gul_vector.h. 

00345 {
00346   return a;
00347 }

template<class T>
point2<T> euclid (  const point2< T > &    a )  [inline]
 

Definition at line 292 of file gul_vector.h. 

00293 {
00294   return a;
00295 }

template<class T>
point<T> euclid (  const point< T > &    a )  [inline]
 

Definition at line 225 of file gul_vector.h. 

00226 {
00227   return a;
00228 }

template<class T>
point1<T> euclid (  const hpoint1< T > &    a )  [inline]
 

Definition at line 173 of file gul_vector.h. 

00174 {
00175   return point1<T>(a.x/a.w);
00176 }

template<class T>
point2<T> euclid (  const hpoint2< T > &    a )  [inline]
 

Definition at line 121 of file gul_vector.h. 

00122 {
00123   return point2<T>(a.x/a.w, a.y/a.w);
00124 }

template<class T>
point<T> euclid (  const hpoint< T > &    a )  [inline]
 

Definition at line 69 of file gul_vector.h. 

00070 {
00071   return point<T>(a.x/a.w, a.y/a.w, a.z/a.w);
00072 }

template<class T>
T euclidian_distance (  const point1< T > &    a,
const point1< T > &    b
)  [inline]
 

Definition at line 510 of file gul_vector.h. 

00511 {
00512   return distance(a,b);
00513 }

template<class T>
T euclidian_distance (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 504 of file gul_vector.h. 

00505 {
00506   return distance(a,b);
00507 }

template<class T>
T euclidian_distance (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 498 of file gul_vector.h. 

00499 {
00500   return distance(a,b);
00501 }

template<class T>
T euclidian_distance (  const hpoint1< T > &    a,
const hpoint1< T > &    b
)  [inline]
 

Definition at line 486 of file gul_vector.h. 

00487 {
00488   point1<T> ea = euclid(a);
00489   point1<T> eb = euclid(b);
00490 
00491   return distance(ea,eb);
00492 }

template<class T>
T euclidian_distance (  const hpoint2< T > &    a,
const hpoint2< T > &    b
)  [inline]
 

Definition at line 477 of file gul_vector.h. 

00478 {
00479   point2<T> ea = euclid(a);
00480   point2<T> eb = euclid(b);
00481 
00482   return distance(ea,eb);
00483 }

template<class T>
T euclidian_distance (  const hpoint< T > &    a,
const hpoint< T > &    b
)  [inline]
 

Definition at line 468 of file gul_vector.h. 

00469 {
00470   point<T> ea = euclid(a);
00471   point<T> eb = euclid(b);
00472 
00473   return distance(ea,eb);
00474 }

template<class T>
T length (  const point< T > &    a )  [inline]
 

Definition at line 407 of file gul_vector.h. 

00408 {
00409   return rtr<T>::sqrt(a.x*a.x + a.y*a.y + a.z*a.z);
00410 }

template<class T>
T Max (  const T &    a,
const T &    b,
const T &    c
)  [inline]
 

Definition at line 355 of file gul_types.h. 

00356 { if((a > b) && (a > c)) return a; 
00357   else if(b > c) return b;
00358   return c; 
00359 }

template<class T>
T Max (  const T &    a,
const T &    b
)  [inline]
 

Definition at line 350 of file gul_types.h. 

00350 { return a > b ? a : b; }

template<class T>
T max_norm (  const point2< T > &    a ) 
 

Definition at line 120 of file gul_float.h. 

00121 {
00122   T m;
00123 
00124   m = rtr<T>::fabs(a.x);
00125   if( rtr<T>::fabs(a.y) > m ) m = rtr<T>::fabs(a.y); 
00126   return m;
00127 }

template<class T>
T max_norm (  const point< T > &    a ) 
 

Definition at line 109 of file gul_float.h. 

00110 {
00111   T m;
00112 
00113   m = rtr<T>::fabs(a.x);
00114   if( rtr<T>::fabs(a.y) > m ) m = rtr<T>::fabs(a.y);
00115   if( rtr<T>::fabs(a.z) > m ) m = rtr<T>::fabs(a.z); 
00116   return m;
00117 }

template<class T, class T2>
void MCopy (  int    m,
int    n,
const Ptr< T2 > &    A,
Ptr< Ptr< T > > &    C
) 
 

Definition at line 66 of file gul_matrix.h. 

00067 {
00068   int i,j;
00069   
00070   for( i = 0; i < m; i++)
00071     for( j =0; j < n; j++)
00072       C[i][j] = (T)A[i*n+j];  
00073 }

template<class T, class T2>
void MCopy (  int    m,
int    n,
const Ptr< Ptr< T2 > > &    A,
Ptr< T > &    C
) 
 

Definition at line 57 of file gul_matrix.h. 

00058 {
00059   int i,j;
00060   
00061   for( i = 0; i < m; i++)
00062     for( j =0; j < n; j++)
00063       C[i*n+j] = (T)A[i][j];  
00064 }

template<class T, class T2>
void MCopy (  int    m,
int    n,
const Ptr< Ptr< T2 > > &    A,
Ptr< Ptr< T > > &    C
) 
 

Definition at line 48 of file gul_matrix.h. 

00049 {
00050   int i,j;
00051   
00052   for( i = 0; i < m; i++)
00053     for( j =0; j < n; j++)
00054       C[i][j] = (T)A[i][j];  
00055 }

template<class T>
T Min (  const T &    a,
const T &    b,
const T &    c
)  [inline]
 

Definition at line 361 of file gul_types.h. 

00362 { if((a < b) && (a < c)) return a; 
00363   else if(b < c) return b;
00364   return c; 
00365 }

template<class T>
T Min (  const T &    a,
const T &    b
)  [inline]
 

Definition at line 352 of file gul_types.h. 

00352 { return a < b ? a : b; }

template<class T>
void MMProduct (  int    r,
int    s,
int    t,
Ptr< T > &    A,
Ptr< T > &    B,
Ptr< T > &    C
) 
 

Definition at line 98 of file gul_matrix.h. 

00099 {
00100   int i,j,k;
00101   T sum;
00102   
00103   for( i = 0; i < r; i++)
00104   {
00105     for( j =0; j < t; j++)
00106     {
00107       sum = (T)0.0;
00108 
00109       for( k = 0; k < s; k++)
00110         sum += A[i*s+k]*B[k*t+j];
00111 
00112       C[i*t+j] = sum;
00113     }
00114   }    
00115 }

template<class T>
void MMProduct (  int    r,
int    s,
int    t,
Ptr< Ptr< T > > &    A,
Ptr< Ptr< T > > &    B,
Ptr< Ptr< T > > &    C
) 
 

Definition at line 77 of file gul_matrix.h. 

00079 {
00080   int i,j,k;
00081   T sum;
00082   
00083   for( i = 0; i < r; i++)
00084   {
00085     for( j =0; j < t; j++)
00086     {
00087       sum = (T)0.0;
00088 
00089       for( k = 0; k < s; k++)
00090         sum += A[i][k]*B[k][j];
00091 
00092       C[i][j] = sum;
00093     }
00094   }    
00095 }

template<class T>
void MVProduct (  int    n,
int    m,
Ptr< Ptr< T > > &    A,
Ptr< T > &    x,
Ptr< T > &    b
) 
 

Definition at line 138 of file gul_matrix.h. 

00139 {
00140   int i,k;
00141   T sum;
00142   
00143   for( i = 0; i < n; i++)
00144   {
00145     sum = (T)0.0;
00146 
00147     for( k = 0; k < m; k++)
00148       sum += A[i][k]*x[k];
00149 
00150     b[i] = sum;
00151   }
00152 }

template<class T>
T normalize (  point2< T > *    c,
const point2< T > &    a
)  [inline]
 

Definition at line 428 of file gul_vector.h. 

00429 {
00430   T d;
00431   
00432   d = rtr<T>::sqrt( a.x*a.x + a.y*a.y );
00433   if( d != (T)0 )    
00434   {
00435     c->x = a.x / d;
00436     c->y = a.y / d;
00437   }
00438   return d;
00439 }

template<class T>
T normalize (  point< T > *    c,
const point< T > &    a
)  [inline]
 

Definition at line 414 of file gul_vector.h. 

00415 {
00416   T d;
00417   
00418   d = rtr<T>::sqrt( a.x*a.x + a.y*a.y + a.z*a.z );
00419   if( d != (T)0 )    
00420   {
00421     c->x = a.x / d;
00422     c->y = a.y / d;
00423     c->z = a.z / d;
00424   }
00425   return d;
00426 }

template<class T>
T operator * (  const point1< T >    a,
const point1< T > &    b
)  [inline]
 

Definition at line 338 of file gul_vector.h. 

00339 {
00340   return a.x*b.x;
00341 }

template<class T>
point1<T> operator * (  const T    op,
const point1< T > &    a
)  [inline]
 

Definition at line 332 of file gul_vector.h. 

00333 {
00334   return point1<T>(op*a.x);
00335 }

template<class T>
T operator * (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 286 of file gul_vector.h. 

00287 {
00288   return a.x*b.x + a.y*b.y;
00289 }

template<class T>
point2<T> operator * (  const T    op,
const point2< T > &    a
)  [inline]
 

Definition at line 280 of file gul_vector.h. 

00281 {
00282   return point2<T>(op*a.x, op*a.y);
00283 }

template<class T>
T operator * (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 219 of file gul_vector.h. 

00220 {
00221   return a.x*b.x + a.y*b.y + a.z*b.z;
00222 }

template<class T>
point<T> operator * (  const T    op,
const point< T > &    a
)  [inline]
 

Definition at line 213 of file gul_vector.h. 

00214 {
00215   return point<T>(op*a.x, op*a.y, op*a.z);
00216 }

template<class T>
T operator * (  const hpoint1< T > &    a,
const hpoint1< T > &    b
)  [inline]
 

Definition at line 167 of file gul_vector.h. 

00168 {
00169   return a.x*b.x + a.w*b.w;
00170 }

template<class T>
hpoint1<T> operator * (  const T    op,
const hpoint1< T > &    a
)  [inline]
 

Definition at line 161 of file gul_vector.h. 

00162 {
00163   return hpoint1<T>(op*a.x, op*a.w);
00164 }

template<class T>
T operator * (  const hpoint2< T >    a,
const hpoint2< T > &    b
)  [inline]
 

Definition at line 115 of file gul_vector.h. 

00116 {
00117   return a.x*b.x + a.y*b.y + a.w*b.w;
00118 }

template<class T>
hpoint2<T> operator * (  const T    op,
const hpoint2< T > &    a
)  [inline]
 

Definition at line 109 of file gul_vector.h. 

00110 {
00111   return hpoint2<T>(op*a.x, op*a.y, op*a.w);
00112 }

template<class T>
T operator * (  const hpoint< T > &    a,
const hpoint< T > &    b
)  [inline]
 

Definition at line 63 of file gul_vector.h. 

00064 {
00065   return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
00066 }

template<class T>
hpoint<T> operator * (  const T    op,
const hpoint< T > &    a
)  [inline]
 

Definition at line 57 of file gul_vector.h. 

00058 {
00059   return hpoint<T>(op*a.x, op*a.y, op*a.z, op*a.w);
00060 }

template<class T>
vec4<T> operator * (  vec4< T >    b,
mat4x4< T >    a
) 
 

Definition at line 190 of file gul_matrix.h. 

00191 {
00192   int i,k;
00193   vec4<T> c;
00194   T sum;
00195   
00196   for( i = 0; i < 4; i++)
00197   {
00198     sum = (T)0.0;
00199 
00200     for( k = 0; k < 4; k++)
00201       sum += b[k] * a[k][i];
00202 
00203     c[i] = sum;
00204   }
00205   return c;
00206 }

template<class T>
vec4<T> operator * (  mat4x4< T >    a,
vec4< T >    b
) 
 

Definition at line 119 of file gul_matrix.h. 

00120 {
00121   int i,k;
00122   vec4<T> c;
00123   T sum;
00124   
00125   for( i = 0; i < 4; i++)
00126   {
00127     sum = (T)0.0;
00128 
00129     for( k = 0; k < 4; k++)
00130       sum += a[i][k]*b[k];
00131 
00132     c[i] = sum;
00133   }
00134   return c;
00135 }

template<class T>
mat4x4<T> operator * (  mat4x4< T >    a,
mat4x4< T >    b
) 
 

Definition at line 26 of file gul_matrix.h. 

00027 {
00028   int i,j,k;
00029   mat4x4<T> c;
00030   T sum;
00031   
00032   for( i = 0; i < 4; i++)
00033   {
00034     for( j =0; j < 4; j++)
00035     {
00036       sum = (T)0.0;
00037 
00038       for( k = 0; k < 4; k++)
00039         sum += a[i][k]*b[k][j];
00040 
00041       c[i][j] = sum;
00042     }
00043   }    
00044   return c;
00045 }

template<class T>
bool operator!= (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 241 of file gul_vector.h. 

00242 {
00243   if( (a.x != b.x) || (a.y != b.y) ) return true;
00244   return false;
00245 }

template<class T>
bool operator!= (  const poolalloc< T > &   ,
const poolalloc< T > &   
)  throw () [inline]
 

Definition at line 1906 of file gul_types.h. 

01907 { return false; }

template<class T>
point1<T> operator+ (  const point1< T > &    a,
const point1< T > &    b
)  [inline]
 

Definition at line 314 of file gul_vector.h. 

00315 {
00316   return point1<T>(a.x+b.x);
00317 }

template<class T>
point2<T> operator+ (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 262 of file gul_vector.h. 

00263 {
00264   return point2<T>(a.x+b.x, a.y+b.y);
00265 }

template<class T>
point<T> operator+ (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 195 of file gul_vector.h. 

00196 {
00197   return point<T>(a.x+b.x, a.y+b.y, a.z+b.z);
00198 }

template<class T>
hpoint1<T> operator+ (  const hpoint1< T > &    a,
const hpoint1< T > &    b
)  [inline]
 

Definition at line 143 of file gul_vector.h. 

00144 {
00145   return hpoint1<T>(a.x+b.x, a.w+b.w);
00146 }

template<class T>
hpoint2<T> operator+ (  const hpoint2< T > &    a,
const hpoint2< T > &    b
)  [inline]
 

Definition at line 91 of file gul_vector.h. 

00092 {
00093   return hpoint2<T>(a.x+b.x, a.y+b.y, a.w+b.w);
00094 }

template<class T>
hpoint<T> operator+ (  const hpoint< T > &    a,
const hpoint< T > &    b
)  [inline]
 

Definition at line 38 of file gul_vector.h. 

00039 {
00040   return hpoint<T>(a.x+b.x, a.y+b.y, a.z+b.z, a.w+b.w);
00041 }

template<class T>
point1<T> operator- (  const point1< T > &    a,
const point1< T > &    b
)  [inline]
 

Definition at line 326 of file gul_vector.h. 

00327 {
00328   return point1<T>(a.x-b.x);
00329 }

template<class T>
point1<T> operator- (  const point1< T > &    a )  [inline]
 

Definition at line 320 of file gul_vector.h. 

00321 {
00322   return point1<T>(-a.x);
00323 }

template<class T>
point2<T> operator- (  const point2< T > &    a,
const point2< T > &    b
)  [inline]
 

Definition at line 274 of file gul_vector.h. 

00275 {
00276   return point2<T>(a.x-b.x, a.y-b.y);
00277 }

template<class T>
point2<T> operator- (  const point2< T > &    a )  [inline]
 

Definition at line 268 of file gul_vector.h. 

00269 {
00270   return point2<T>(-a.x, -a.y);
00271 }

template<class T>
point<T> operator- (  const point< T > &    a,
const point< T > &    b
)  [inline]
 

Definition at line 207 of file gul_vector.h. 

00208 {
00209   return point<T>(a.x-b.x, a.y-b.y, a.z-b.z);
00210 }

template<class T>
point<T> operator- (  const point< T > &    a )  [inline]
 

Definition at line 201 of file gul_vector.h. 

00202 {
00203   return point<T>(-a.x, -a.y, -a.z);
00204 }

template<class T>
hpoint1<T> operator- (  const hpoint1< T > &    a,
const hpoint1< T > &    b
)  [inline]
 

Definition at line 155 of file gul_vector.h. 

00156 {
00157   return hpoint1<T>(a.x-b.x, a.w-b.w);
00158 }

template<class T>
hpoint1<T> operator- (  const hpoint1< T > &    a )  [inline]
 

Definition at line 149 of file gul_vector.h. 

00150 {
00151   return hpoint1<T>(-a.x, -a.w);
00152 }

template<class T>
hpoint2<T> operator- (  const hpoint2< T > &    a,
const hpoint2< T > &    b
)  [inline]
 

Definition at line 103 of file gul_vector.h. 

00104 {
00105   return hpoint2<T>(a.x-b.x, a.y-b.y, a.w-b.w);
00106 }

template<class T>
hpoint2<T> operator- (  const hpoint2< T > &    a )  [inline]
 

Definition at line 97 of file gul_vector.h. 

00098 {
00099   return hpoint2<T>(-a.x, -a.y, -a.w);
00100 }

template<class T>
hpoint<T> operator- (  const hpoint< T > &    a,
const hpoint< T > &    b
)  [inline]
 

Definition at line 51 of file gul_vector.h. 

00052 {
00053   return hpoint<T>(a.x-b.x, a.y-b.y, a.z-b.z, a.w-b.w);
00054 }

template<class T>
hpoint<T> operator- (  const hpoint< T > &    a )  [inline]
 

Definition at line 44 of file gul_vector.h. 

00045 {
00046   return hpoint(-a.x, -a.y, -a.z, -a.w);
00047 }

template<class HP>
ostream& operator<< (  ostream &    os,
const dump_vector< HP > &    m
)  [inline]
 

Definition at line 520 of file gul_io.h. 

00521 {
00522   int i;
00523 
00524   os << "Vector:\n";
00525   for( i = 0; i < m.m_nV; i++ )
00526   {
00527     os << "(" << m.m_V[i] << ") ";
00528     os << "\n";
00529   }
00530   os.flush();
00531 
00532   return os;
00533 }

template<class HP>
ostream& operator<< (  ostream &    os,
const dump_matrix< HP > &    m
)  [inline]
 

Definition at line 490 of file gul_io.h. 

00491 {
00492   int i,j;
00493 
00494   os << "Matrix:\n";
00495   for( i = 0; i < m.m_nRows; i++ )
00496   {
00497     for( j = 0; j < m.m_nCols; j++ )
00498       os << "(" << m.m_M[i][j] << ") ";
00499     os << "\n";
00500   }
00501   os.flush();
00502 
00503   return os;
00504 }

template<class T, class HP>
ostream& operator<< (  ostream &    os,
const dump_curve< T, HP > &    c
)  [inline]
 

Definition at line 454 of file gul_io.h. 

00455 {
00456   int i;
00457 
00458   os << "Knot Vector U\n";
00459   for( i = 0; i < c.m_n+c.m_p+2; i++ )
00460     cout << c.m_U[i] << " ";
00461   os << "\n";
00462   os.flush();
00463 
00464   os << "Control Points:\n";
00465   for( i = 0; i < c.m_n+1; i++ )
00466   {
00467     os << "(" << c.m_Pw[i] << ") ";
00468   }
00469   os.flush();
00470 
00471   return os;
00472 }

template<class T, class HP>
ostream& operator<< (  ostream &    os,
const dump_surf< T, HP > &    s
)  [inline]
 

Definition at line 423 of file gul_io.h. 

00424 {
00425   if( s.m_f == human_readable )
00426     s.out_human(os);
00427   else if( s.m_f == gul_format )
00428     s.out_gul(os);
00429 
00430   return os;
00431 }

template<class T>
ostream& operator<< (  ostream &    os,
const dump_list< T > &    L
)  [inline]
 

Definition at line 287 of file gul_io.h. 

00288 {
00289   L.out_gul(os);
00290 
00291   return os;
00292 }

template<class T>
ostream& operator<< (  ostream &    os,
const line2< T > &    l
)  [inline]
 

Definition at line 247 of file gul_io.h. 

00248 {
00249   os << dump_line<point2<T>,line2<T> >(l);
00250   return os;
00251 }

template<class T>
ostream& operator<< (  ostream &    os,
const line< T > &    l
)  [inline]
 

Definition at line 240 of file gul_io.h. 

00241 {
00242   os << dump_line<point<T>,line<T> >(l);
00243   return os;
00244 }

template<class EP, class L>
ostream& operator<< (  ostream &    os,
const dump_line< EP, L > &    l
)  [inline]
 

Definition at line 229 of file gul_io.h. 

00230 {
00231   if( l.m_f == human_readable )
00232     l.out_human(os);
00233   else if( l.m_f == gul_format )
00234     l.out_gul(os);
00235 
00236   return os;
00237 }

template<class T>
ostream& operator<< (  ostream &    s,
const hpoint< T > &    p
)  [inline]
 

Definition at line 187 of file gul_io.h. 

00188 {
00189   return s << gul::dump_point<gul::hpoint<T> >(p);
00190 }

template<class T>
ostream& operator<< (  ostream &    s,
const point< T > &    p
)  [inline]
 

Definition at line 182 of file gul_io.h. 

00183 {
00184   return s << gul::dump_point<gul::point<T> >(p);
00185 }

template<class T>
ostream& operator<< (  ostream &    s,
const hpoint2< T > &    p
)  [inline]
 

Definition at line 176 of file gul_io.h. 

00177 {
00178   return s << gul::dump_point<gul::hpoint2<T> >(p);
00179 }

template<class T>
ostream& operator<< (  ostream &    s,
const point2< T > &    p
)  [inline]
 

Definition at line 171 of file gul_io.h. 

00172 {
00173   return s << gul::dump_point<gul::point2<T> >(p);
00174 }

template<class T>
ostream& operator<< (  ostream &    s,
const hpoint1< T > &    p
)  [inline]
 

Definition at line 165 of file gul_io.h. 

00166 {
00167   return s << gul::dump_point<gul::hpoint1<T> >(p);
00168 }

template<class T>
ostream& operator<< (  ostream &    s,
const point1< T > &    p
)  [inline]
 

Definition at line 160 of file gul_io.h. 

00161 {
00162   return s << gul::dump_point<gul::point1<T> >(p);
00163 }

template<class EP>
std::ostream& operator<< (  std::ostream &    os,
const gul::dump_point< EP > &    P
)  [inline]
 

Definition at line 148 of file gul_io.h. 

00149 {
00150   if( P.m_f == human_readable )
00151     P.out_human(os);
00152   else if( P.m_f == gul_format )
00153     P.out_gul(os);
00154 
00155   return os;
00156 }

std::ostream& operator<< (  std::ostream &    s,
const guar::rational &    r
)  [inline]
 

Definition at line 646 of file guar_exact.h. 

00647 {
00648   return s << r.dump();
00649 }

template<class T>
bool operator== (  const poolalloc< T > &   ,
const poolalloc< T > &   
)  throw () [inline]
 

Definition at line 1903 of file gul_types.h. 

01904 { return true; }

template<class T>
point1<T> ortho (  const point1< T > &    a )  [inline]
 

Definition at line 385 of file gul_vector.h. 

00386 {
00387   return point1<T>(a.x);
00388 }

template<class T>
point2<T> ortho (  const point2< T > &    a )  [inline]
 

Definition at line 380 of file gul_vector.h. 

00381 {
00382   return point2<T>(a.x, a.y);
00383 }

template<class T>
point<T> ortho (  const point< T > &    a )  [inline]
 

Definition at line 375 of file gul_vector.h. 

00376 {
00377   return point<T>(a.x, a.y, a.z);
00378 }

template<class T>
point1<T> ortho (  const hpoint1< T > &    a )  [inline]
 

Definition at line 369 of file gul_vector.h. 

00370 {
00371   return point1<T>(a.x);
00372 }

template<class T>
point2<T> ortho (  const hpoint2< T > &    a )  [inline]
 

Definition at line 364 of file gul_vector.h. 

00365 {
00366   return point2<T>(a.x, a.y);
00367 }

template<class T>
point<T> ortho (  const hpoint< T > &    a )  [inline]
 

Definition at line 359 of file gul_vector.h. 

00360 {
00361   return point<T>(a.x, a.y, a.z);
00362 }

template<class HP>
HP ProjectToLine (  const HP &    S,
const HP &    T,
const HP &    P
)  [inline]
 

Project a point onto a line (in 3-D).

S = a point on the line T = direction vector of the line ( |T| = 1 !!!! )

Definition at line 521 of file gul_vector.h. 

00522 {
00523   return S + ((P-S)*T)*T;
00524 }

template<class T>
bool rel_equal (  const gul::point1< T > &    a,
const gul::point1< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 95 of file gul_float.h. 

00097 {
00098   T tol = eps;
00099 
00100   if( !rel_equal(a.x, b.x, tol) ) return false;
00101 
00102   return true;
00103 }

template<class T>
bool rel_equal (  const gul::point2< T > &    a,
const gul::point2< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 83 of file gul_float.h. 

00085 {
00086   T tol = eps / rtr<T>::root2_2();
00087 
00088   if( !rel_equal(a.x, b.x, tol) ) return false;
00089   if( !rel_equal(a.y, b.y, tol) ) return false;
00090 
00091   return true;
00092 }

template<class T>
bool rel_equal (  const gul::point< T > &    a,
const gul::point< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 70 of file gul_float.h. 

00072 {
00073   T tol = eps / rtr<T>::root2_3();
00074 
00075   if( !rel_equal(a.x, b.x, tol) ) return false;
00076   if( !rel_equal(a.y, b.y, tol) ) return false;
00077   if( !rel_equal(a.z, b.z, tol) ) return false;
00078 
00079   return true;
00080 }

template<class T>
bool rel_equal (  const gul::hpoint1< T > &    a,
const gul::hpoint1< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 58 of file gul_float.h. 

00060 {
00061   T tol = eps / rtr<T>::root2_2();
00062 
00063   if( !rel_equal(a.x, b.x, tol) ) return false;
00064   if( !rel_equal(a.w, b.w, tol) ) return false;
00065 
00066   return true;
00067 }

template<class T>
bool rel_equal (  const gul::hpoint2< T > &    a,
const gul::hpoint2< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 45 of file gul_float.h. 

00047 {
00048   T tol = eps / rtr<T>::root2_3();
00049 
00050   if( !rel_equal(a.x, b.x, tol) ) return false;
00051   if( !rel_equal(a.y, b.y, tol) ) return false;
00052   if( !rel_equal(a.w, b.w, tol) ) return false;
00053 
00054   return true;
00055 }

template<class T>
bool rel_equal (  const gul::hpoint< T > &    a,
const gul::hpoint< T > &    b,
const T &    eps
)  [inline]
 

Definition at line 31 of file gul_float.h. 

00033 {
00034   T tol = eps / (T)2;
00035 
00036   if( !rel_equal(a.x, b.x, tol) ) return false;
00037   if( !rel_equal(a.y, b.y, tol) ) return false;
00038   if( !rel_equal(a.z, b.z, tol) ) return false;
00039   if( !rel_equal(a.w, b.w, tol) ) return false;
00040 
00041   return true;
00042 }

template<class T>
bool rel_equal (  const T &    a,
const T &    b,
const T &    eps
)  [inline]
 

Definition at line 17 of file gul_float.h. 

00018 {
00019   return rtr<T>::fabs(a-b) <= rtr<T>::fabs(b) * eps; 
00020 }

template<class T>
void set (  point1< T > &    c,
T    a
)  [inline]
 

Definition at line 308 of file gul_vector.h. 

00309 {
00310   c.x = a;
00311 }

template<class T>
void set (  point2< T > &    c,
T    a
)  [inline]
 

Definition at line 256 of file gul_vector.h. 

00257 {
00258   c.x = a; c.y = a;
00259 }

template<class T>
void set (  point< T > &    c,
T    a
)  [inline]
 

Definition at line 189 of file gul_vector.h. 

00190 {
00191   c.x = a; c.y = a; c.z = a;
00192 }

template<class T>
void set (  hpoint1< T > &    c,
T    a
)  [inline]
 

Definition at line 137 of file gul_vector.h. 

00138 {
00139   c.x = a; c.w = a;
00140 }

template<class T>
void set (  hpoint2< T > &    c,
T    a
)  [inline]
 

Definition at line 85 of file gul_vector.h. 

00086 {
00087   c.x = a; c.y = a; c.w = a;
00088 }

template<class T>
void set (  hpoint< T > &    c,
T    a
)  [inline]
 

Definition at line 32 of file gul_vector.h. 

00033 {
00034   c.x = a; c.y = a; c.z = a; c.w = a;
00035 }

template<class T>
T Sign (  const T &    a,
const T &    b
)  [inline]
 

Definition at line 372 of file gul_types.h. 

00373 { return (b < 0.0 ? -rtr<T>::fabs(a) : rtr<T>::fabs(a)); }

template<class T>
T Square (  const T &    a )  [inline]
 

Definition at line 370 of file gul_types.h. 

00370 { return a*a; }

template<class T>
void Swap (  T &    a,
T &    b
)  [inline]
 

Definition at line 368 of file gul_types.h.

Referenced by guma::rkdtree_base::nearest_neighbors(). 

00368 { T tmp=a; a=b; b=tmp; }

template<class T>
int test (  const T &    a )  [inline]
 

Definition at line 152 of file gul_types.h. 

00153 {
00154   if( a < 0 ) return -1;
00155   else if( a == 0 ) return 0;
00156   return 1;
00157 }

template<>
int test (  const guar::rational &    a )  [inline]
 

Definition at line 610 of file guar_exact.h. 

00611 {
00612   return a.test();
00613 }

template<class T>
void VMProduct (  int    n,
int    m,
const Ptr< T > &    x,
const Ptr< T > &    A,
Ptr< T > &    b
) 
 

Definition at line 172 of file gul_matrix.h. 

00173 {
00174   int i,k;
00175   T sum;
00176   
00177   for( i = 0; i < m; i++)
00178   {
00179     sum = (T)0.0;
00180 
00181     for( k = 0; k < n; k++)
00182       sum += x[k]*A[k*m+i];
00183 
00184     b[i] = sum;
00185   }
00186 }

template<class T>
void VMProduct (  int    n,
int    m,
const Ptr< T > &    x,
const Ptr< Ptr< T > > &    A,
Ptr< T > &    b
) 
 

Definition at line 155 of file gul_matrix.h. 

00156 {
00157   int i,k;
00158   T sum;
00159   
00160   for( i = 0; i < m; i++)
00161   {
00162     sum = (T)0.0;
00163 
00164     for( k = 0; k < n; k++)
00165       sum += x[k]*A[k][i];
00166 
00167     b[i] = sum;
00168   }
00169 }

template<class T>
T weight (  const point1< T > &    a )  [inline]
 

Definition at line 349 of file gul_vector.h. 

00350 {
00351   return (T)1;
00352 }

template<class T>
T weight (  const point2< T > &    a )  [inline]
 

Definition at line 297 of file gul_vector.h. 

00298 {
00299   return (T)1;
00300 }

template<class T>
T weight (  const point< T > &    a )  [inline]
 

Definition at line 230 of file gul_vector.h. 

00231 {
00232   return (T)1;
00233 }

template<class T>
T weight (  const hpoint1< T > &    a )  [inline]
 

Definition at line 178 of file gul_vector.h. 

00179 {
00180   return a.w;
00181 }

template<class T>
T weight (  const hpoint2< T > &    a )  [inline]
 

Definition at line 126 of file gul_vector.h. 

00127 {
00128   return a.w;
00129 }

template<class T>
T weight (  const hpoint< T > &    a )  [inline]
 

Definition at line 74 of file gul_vector.h. 

00075 {
00076   return a.w;
00077 }

template<class T>
bool zero_sine (  const point2< T > &    ina,
const point2< T > &    inb,
const T &    eps
) 
 

Definition at line 156 of file gul_float.h. 

00157 {
00158   T la,lb;
00159 
00160   // normalize a,b (approximately)
00161   la = max_norm(a);
00162   if( !la ) return true;
00163   a = ((T)1/la)*ina;
00164 
00165   lb = max_norm(b);
00166   if( !lb ) return true;
00167   b = ((T)1/lb)*inb;
00168 
00169   if( rel_equal(a.x*b.y-b.x*a.y,eps) )
00170     return true;
00171 
00172   return false;
00173 }

template<class T>
bool zero_sine (  const point< T > &    ina,
const point< T > &    inb,
const T &    eps
) 
 

Definition at line 133 of file gul_float.h. 

00134 {
00135   T la,lb;
00136   point<T> a,b;
00137 
00138   // normalize a,b (approximately)
00139   la = max_norm(ina);
00140   if( !la ) return true;
00141   a = ((T)1/la)*ina;
00142 
00143   lb = max_norm(inb);
00144   if( !lb ) return true;
00145   b = ((T)1/lb)*inb;
00146 
00147   if( rel_equal(a.y*b.z,b.y*a.z,eps) &&
00148       rel_equal(b.x*a.z,a.x*b.z,eps) &&
00149       rel_equal(a.x*b.y,b.x*a.y,eps) )
00150     return true;
00151 
00152   return false;
00153 }

Variable Documentation

const bool gul::ndebug = false
 

Definition at line 109 of file gul_types.h.

Referenced by gugr::monpoly_info::AppendRight(), gugr::edge_interval_tree::dump_edge_interval(), and gugr::segnode::insert().

Generated on Mon Jan 21 04:17:56 2002 for GUL 0.6 - Geometry Utility Library by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001