functor.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplex_functor_h__)
#define __geom_mesh_simplex_functor_h__

#include "SimplexJac.h"


BEGIN_NAMESPACE_GEOM

//---------------------------------------------------------------------------
// Determinant.
//---------------------------------------------------------------------------

template<int N, int M = N, typename T = double>
class SimplexDeterminant : 
  public std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> {
private:

  //
  // Private types.
  //

  typedef std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

private:

  //
  // Member data.
  //

  mutable SimplexJac<N,T> _simplexJacobian;

  //
  // Constructors.
  //

public:

  // Since the member data is mutable, the constructor, copy constructor,
  // and assignment operator are trivial.

  SimplexDeterminant()
  {}
  
  SimplexDeterminant(const SimplexDeterminant& x)
  {}

  SimplexDeterminant&
  operator=(const SimplexDeterminant& other) {
    return *this;
  }

  ~SimplexDeterminant()
  {}

  //
  // Functor.
  //

  result_type
  operator()(const argument_type& x) const {
    _simplexJacobian.setFunction(x);
    return _simplexJacobian.getDeterminant();
  }

};


template<int N, int M, typename T>
inline
SimplexDeterminant<N,M,T>
simplexDeterminant() {
  return SimplexDeterminant<N,M,T>();
}




//---------------------------------------------------------------------------
// Content.
//---------------------------------------------------------------------------

template<int N, int M = N, typename T = double>
class SimplexContent : 
  public std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> {
private:

  //
  // Private types.
  //

  typedef std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

private:

  //
  // Member data.
  //

  mutable SimplexJac<N,T> _simplexJacobian;

  //
  // Constructors.
  //

public:

  // Since the member data is mutable, the constructor, copy constructor,
  // and assignment operator are trivial.

  SimplexContent()
  {}
  
  SimplexContent(const SimplexContent& x)
  {}

  SimplexContent&
  operator=(const SimplexContent& other) {
    return *this;
  }

  ~SimplexContent()
  {}

  //
  // Functor.
  //

  result_type
  operator()(const argument_type& x) const {
    _simplexJacobian.setFunction(x);
    return _simplexJacobian.computeContent();
  }

};


template<int N, int M, typename T>
inline
SimplexContent<N,M,T>
simplexContent() {
  return SimplexContent<N,M,T>();
}




//---------------------------------------------------------------------------
// Minimum edge length.
//---------------------------------------------------------------------------

template<int N, int M = N, typename T = double>
class SimplexMinimumEdgeLength : 
  public std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> {
private:

  //
  // Private types.
  //

  typedef std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

  //
  // Constructors.
  //

public:

  // Since there is no member data, the default constructor, destructor, 
  // copy constructor, and assignment operator are sufficient.

  //
  // Functor.
  //

  result_type
  operator()(const argument_type& x) const {
    result_type d, minimum = std::numeric_limits<result_type>::max();
    // For each edge (pair of vertices).
    for (int i = 0; i != M; ++i) {
      for (int j = i + 1; j != M + 1; ++j) {
        d = geom::computeDistance(x[i], x[j]);
        if (d < minimum) {
          minimum = d;
        }
      }
    }
    return minimum;
  }

};


template<int N, int M, typename T>
inline
SimplexMinimumEdgeLength<N,M,T>
simplexMinimumEdgeLength() {
  return SimplexMinimumEdgeLength<N,M,T>();
}




//---------------------------------------------------------------------------
// Maximum edge length.
//---------------------------------------------------------------------------

template<int N, int M = N, typename T = double>
class SimplexMaximumEdgeLength : 
  public std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> {
private:

  //
  // Private types.
  //

  typedef std::unary_function<geom::Simplex<M, ads::FixedArray<N,T> >, T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

  //
  // Constructors.
  //

public:

  // Since there is no member data, the default constructor, destructor, 
  // copy constructor, and assignment operator are sufficient.

  //
  // Functor.
  //

  result_type
  operator()(const argument_type& x) const {
    result_type d, maximum = -std::numeric_limits<result_type>::max();
    // For each edge (pair of vertices).
    for (int i = 0; i != M; ++i) {
      for (int j = i + 1; j != M + 1; ++j) {
        d = geom::computeDistance(x[i], x[j]);
        if (d > maximum) {
          maximum = d;
        }
      }
    }
    return maximum;
  }

};


template<int N, int M, typename T>
inline
SimplexMaximumEdgeLength<N,M,T>
simplexMaximumEdgeLength() {
  return SimplexMaximumEdgeLength<N,M,T>();
}

END_NAMESPACE_GEOM

#define __geom_mesh_simplex_functor_ipp__
#include "functor.ipp"
#undef __geom_mesh_simplex_functor_ipp__

#endif

---