content.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_content_h__)
#define __geom_content_h__

// If we are debugging the whole geom namespace.
#if defined(DEBUG_geom) && !defined(DEBUG_content)
#define DEBUG_content
#endif

#ifdef DEBUG_content
#ifndef DEBUG_FixedArray
#define DEBUG_FixedArray
#endif
#endif

#include "../defs.h"

#include "Point.h"

#include "../../ads/tensor/SquareMatrix.h"

BEGIN_NAMESPACE_GEOM


//-----------------------------------------------------------------------------
// @{



template<int N, typename T>
T
computeDistance(const ads::FixedArray<N,T>& x, const ads::FixedArray<N,T>& y);


template<int N, typename T>
T
computeDistance(const ads::FixedArray<2, ads::FixedArray<N,T> >& x);




template<int N, typename T>
T
computeContent(const ads::FixedArray<N,T>& x, const ads::FixedArray<N,T>& y);


template<int N, typename T>
T
computeContent(const ads::FixedArray<2, ads::FixedArray<N,T> >& x);



template<int N, typename T>
void
computeGradientOfDistance(const ads::FixedArray<N,T>& x, 
                          const ads::FixedArray<N,T>& y,
                          ads::FixedArray<N,T>* gradient);


template<int N, typename T>
void
computeGradientOfDistance(const ads::FixedArray<2, ads::FixedArray<N,T> >& x,
                          ads::FixedArray<N,T>* gradient);



template<int N, typename T>
void
computeGradientOfContent(const ads::FixedArray<N,T>& x, 
                         const ads::FixedArray<N,T>& y,
                         ads::FixedArray<N,T>* gradient);


template<int N, typename T>
void
computeGradientOfContent(const ads::FixedArray<2, ads::FixedArray<N,T> >& x,
                         ads::FixedArray<N,T>* gradient);


// @}
//-----------------------------------------------------------------------------
// @{



template<typename T>
T
computeArea(const ads::FixedArray<2,T>& a, const ads::FixedArray<2,T>& b,
            const ads::FixedArray<2,T>& c);



template<typename T>
T
computeArea(const ads::FixedArray<3, ads::FixedArray<2,T> >& p);



template<typename T>
T
computeArea(const ads::FixedArray<3,T>& a, const ads::FixedArray<3,T>& b,
            const ads::FixedArray<3,T>& c);



template<typename T>
T
computeArea(const ads::FixedArray<3, ads::FixedArray<3,T> >& p);




template<int N, typename T>
T
computeContent(const ads::FixedArray<N,T>& a, const ads::FixedArray<N,T>& b,
               const ads::FixedArray<N,T>& c);


template<int N, typename T>
T
computeContent(const ads::FixedArray<3, ads::FixedArray<N,T> >& p);



template<typename T>
void
computeGradientOfArea(const ads::FixedArray<2,T>& a, 
                      const ads::FixedArray<2,T>& b,
                      const ads::FixedArray<2,T>& c, 
                      ads::FixedArray<2,T>* gradient);


template<typename T>
void
computeGradientOfArea(const ads::FixedArray<3,T>& a, 
                      const ads::FixedArray<3,T>& b,
                      const ads::FixedArray<3,T>& c, 
                      ads::FixedArray<3,T>* gradient);


template<int N, typename T>
void
computeGradientOfArea(const ads::FixedArray<3, ads::FixedArray<N,T> >& p, 
                      ads::FixedArray<N,T>* gradient);



template<int N, typename T>
inline
void
computeGradientOfContent(const ads::FixedArray<N,T>& a, 
                         const ads::FixedArray<N,T>& b,
                         const ads::FixedArray<N,T>& c, 
                         ads::FixedArray<N,T>* gradient) {
  computeGradientOfArea(a, b, c, gradient);
}



template<int N, typename T>
inline
void
computeGradientOfContent(const ads::FixedArray<3, ads::FixedArray<N,T> >& p, 
                         ads::FixedArray<N,T>* gradient) {
  computeGradientOfArea(p, gradient);
}


// @}
//-----------------------------------------------------------------------------
// @{



template<int N, typename T>
T
computeVolume(const ads::FixedArray<N,T>& a, const ads::FixedArray<N,T>& b,
              const ads::FixedArray<N,T>& c, const ads::FixedArray<N,T>& d);


template<int N, typename T>
T
computeVolume(const ads::FixedArray<4, ads::FixedArray<N,T> >& p);




template<int N, typename T>
inline
T
computeContent(const ads::FixedArray<N,T>& a, const ads::FixedArray<N,T>& b,
               const ads::FixedArray<N,T>& c, const ads::FixedArray<N,T>& d) {
  return computeVolume(a, b, c, d);
}



template<int N, typename T>
inline
T
computeContent(const ads::FixedArray<4, ads::FixedArray<N,T> >& p) {
  return computeVolume(p);
}



template<typename T>
void
computeGradientOfVolume(const ads::FixedArray<3,T>& a, 
                        const ads::FixedArray<3,T>& b,
                        const ads::FixedArray<3,T>& c, 
                        const ads::FixedArray<3,T>& d,
                        ads::FixedArray<3,T>* gradient);


template<int N, typename T>
inline
void
computeGradientOfVolume(const ads::FixedArray<4, ads::FixedArray<N,T> >& p,
                        ads::FixedArray<N,T>* gradient) {
  computeGradientOfVolume(p[0], p[1], p[2], p[3], gradient);
}




template<int N, typename T>
inline
void
computeGradientOfContent(const ads::FixedArray<N,T>& a, 
                         const ads::FixedArray<N,T>& b,
                         const ads::FixedArray<N,T>& c, 
                         const ads::FixedArray<N,T>& d,
                         ads::FixedArray<N,T>* gradient) {
  computeGradientOfVolume(a, b, c, d, gradient);
}



template<int N, typename T>
inline
void
computeGradientOfContent(const ads::FixedArray<4, ads::FixedArray<N,T> >& p,
                         ads::FixedArray<N,T>* gradient) {
  computeGradientOfVolume(p, gradient);
}


// @}

END_NAMESPACE_GEOM

#define __geom_content_ipp__
#include "content.ipp"
#undef __geom_content_ipp__

#endif

---