SimplexModCondNum.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_SimplexModCondNum_h__)
#define __geom_SimplexModCondNum_h__

#if defined(DEBUG_geom) && !defined(DEBUG_SimplexModCondNum)
#define DEBUG_SimplexModCondNum
#endif

#include "SimplexCondNum.h"
#include "SimplexModDet.h"

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class SimplexModCondNum :
  public SimplexCondNum<N,T> {
private:

  typedef SimplexCondNum<N,T> Base;

public:

  //
  // public typedefs
  //

  typedef T Number;

  typedef typename Base::Vertex Vertex;

  typedef typename Base::Simplex Simplex;

  typedef typename Base::Matrix Matrix;

public:

  //--------------------------------------------------------------------------

  SimplexModCondNum() :
    Base()
  {}

  SimplexModCondNum(const SimplexModCondNum& other) :
    Base(other)
  {}


  SimplexModCondNum(const Simplex& s) :
    Base(s)
  {}

  SimplexModCondNum& 
  operator=(const SimplexModCondNum& other) {
    if (&other != this) {
      Base::operator=(other);
    }
    return *this;
  }
  
  ~SimplexModCondNum()
  {}

  //--------------------------------------------------------------------------


  using Base::getMatrix;

  using Base::getGradientMatrix;

  using Base::getDeterminant;

  using Base::getGradientDeterminant;

  using Base::computeContent;

  using Base::computeGradientContent;

  using Base::getDimension;

  using Base::getAdjointMatrix;

  using Base::getAdjointGradientMatrix;

  //--------------------------------------------------------------------------

  using Base::setFunction;

  using Base::set;

  //--------------------------------------------------------------------------


  Number
  operator()() const {
    return operator()(getDeterminant());
  }


  Number
  operator()(const Simplex& simplex) const {
    setFunction(simplex);
    return operator()(getDeterminant());
  }


  Number
  operator()(Number minDeterminant) const;


  void
  computeGradient(Vertex* gradient) const {
    return computeGradient(getDeterminant(), gradient);
  }


  void
  computeGradient(Number minDeterminant, Vertex* gradient) const;


protected:

  Number
  computeFunction(const Number snj, const Number sna) const {
    return computeFunction(getDeterminant(), snj, sna);
  }

  Number
  computeFunction(Number minDeterminant, Number snj, Number sna) const;
  
private:

  Number
  getH(const Number minDeterminant) const {
    return SimplexModDet<T>::getH(getDeterminant(), minDeterminant);
  }

};

END_NAMESPACE_GEOM

#define __geom_SimplexModCondNum_ipp__
#include "SimplexModCondNum.ipp"
#undef __geom_SimplexModCondNum_ipp__

#endif

---