imath.h

Go to the documentation of this file.

#ifndef _IMATH_H_
#define _IMATH_H_

// types, exported (class, enum, struct, union, typedef)

// variables, exported (extern)

// functions, inlined (inline)

namespace math {

  template<class T>
  inline const T&
  min( const T& lhs, const T& rhs) {

    return (lhs < rhs) ? lhs : rhs;
  }

  template<class T>
  inline const T&
  max( const T& lhs, const T& rhs) {

    return (lhs > rhs) ? lhs : rhs;
  }

  template<class T, class S>
  inline T
  sum3( const S& vec) {
 
    return vec[0] + vec[1] + vec[2];
  }

  template<class T, class S>
  inline T
  sum4( const S& vec) {
 
    return vec[0] + vec[1] + vec[2] + vec[3];
  }

  template<class T>
  inline T
  mul3( const T& lhs, const T& rhs) {

    return T( lhs[0]*rhs[0], lhs[1]*rhs[1], lhs[2]*rhs[2]);
  }

  template<class T>
  inline T
  mul4( const T& lhs, const T& rhs) {

    return T( lhs[0]*rhs[0], lhs[1]*rhs[1], lhs[2]*rhs[2], lhs[3]*rhs[3]);
  }

  template<class T, class S>
  inline S
  dot3( const T& lhs, const T& rhs) {

    return sum3( mul3( lhs, rhs));
  }

  template<class T, class S>
  inline S
  dot4( const T& lhs, const T& rhs) {

    return sum4( mul4( lhs, rhs));
  }

  template<class T>
  inline double
  dp4( const T& lhs, const T& rhs) {

    return ((lhs.x * rhs.x) + (lhs.y * rhs.y) + (lhs.z * rhs.z) + (lhs.w * rhs.w));
  }

  template<class T>
  inline bool
  check_epsilon( const T& val, const T& epsilon) {

    return ((val < epsilon) && (val > -epsilon));
  }

  template<class T>
  inline bool
  check_std_epsilon( const T& val) {

    return ((val < std::numeric_limits<T>::epsilon()) 
             && (val > (-1.0 * std::numeric_limits<T>::epsilon() )));
  }

  template< class Matrix, class Transform >
  void
  transformQuadric( Matrix& quadric, const Transform& transform) {

    MMatrix adj = transform.adjoint();
    quadric = adj * ( quadric * adj.transpose());
  }
}
  
// functions, exported (extern)

#endif // #ifndef _IMATH_H_

---