ComplexWithFreeVertexOnManifold.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_ComplexWithFreeVertexOnManifold_h__)
#define __geom_ComplexWithFreeVertexOnManifold_h__

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

#include "ComplexWithFreeVertex.h"

BEGIN_NAMESPACE_GEOM



template<template<int,typename> class QF,
         int N, int M,
         class _Manifold,
         typename T = double>
class ComplexWithFreeVertexOnManifoldBase :
  public ComplexWithFreeVertex<QF,N,T> {
private:

  //
  // Private types.
  //

  typedef ComplexWithFreeVertex<QF,N,T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Number Number;

  typedef typename Base::Vertex Vertex;

  typedef _Manifold Manifold;

  typedef ads::FixedArray<M,Number> ManifoldPoint;

  typedef typename Base::Face Face;

protected:

  //
  // Data
  //

  const Manifold* _manifold;

private:

  //
  // Not implemented.
  //

  // Copy constructor not implemented.
  ComplexWithFreeVertexOnManifoldBase
  (const ComplexWithFreeVertexOnManifoldBase&);

  // Assignment operator not implemented.
  ComplexWithFreeVertexOnManifoldBase& 
  operator=(const ComplexWithFreeVertexOnManifoldBase&);
  
protected:

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

  ComplexWithFreeVertexOnManifoldBase() :
    Base()
  {}

  template<typename FaceIterator>
  ComplexWithFreeVertexOnManifoldBase(FaceIterator beginning, 
                                      FaceIterator end) :
    Base(beginning, end),
    _manifold(0)
  {}

  ~ComplexWithFreeVertexOnManifoldBase()
  {}

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

  using Base::getFreeVertex;

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

  using Base::set;

  void
  setManifold(const Manifold* manifold) {
    assert(manifold != 0);
    _manifold = manifold;
  }

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

  void
  computeBBox(const ManifoldPoint& point, BBox<N,T>* bb) {
    Base::computeBBox(computePosition(point), bb);
  }

  Number
  computeContent(const ManifoldPoint& point) {
    return Base::computeContent(computePosition(point));
  }

  void
  computeGradientOfContent(const Vertex& v, Vertex* gradient) {
    Base::computeGradientOfContent(v, gradient);
  }

  Number
  computeNorm2(const Vertex& v) {
    return Base::computeNorm2(v);
  }

  Number
  computeNorm2(const ManifoldPoint& point) {
    return Base::computeNorm2(computePosition(point));
  }

  void
  computeGradientOfNorm2(const Vertex& v, Vertex* gradient) {
    Base::computeGradientOfNorm2(v, gradient);
  }

  Number
  computeNorm2Modified(const Vertex& v) {
    return Base::computeNorm2Modified(v);
  }

  Number
  computeNorm2Modified(const ManifoldPoint& point) {
    return Base::computeNorm2Modified(computePosition(point));
  }

  void
  computeGradientOfNorm2Modified(const Vertex& v, Vertex* gradient) {
    Base::computeGradientOfNorm2Modified(v, gradient);
  }

  // Compute a Euclidean position from parameter coordinates.
  Vertex
  computePosition(const ManifoldPoint& point) {
    assert(_manifold != 0);
    return _manifold->computePosition(point);
  }

};










template<template<int,typename> class QF,
         int N, int M,
         class _Manifold,
         typename T = double>
class ComplexWithFreeVertexOnManifold;







template<template<int,typename> class QF,
         int N,
         class _Manifold,
         typename T>
class ComplexWithFreeVertexOnManifold<QF,N,1,_Manifold,T> :
  public ComplexWithFreeVertexOnManifoldBase<QF,N,1,_Manifold,T> {
private:

  //
  // Private types.
  //

  typedef ComplexWithFreeVertexOnManifoldBase<QF,N,1,_Manifold,T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Number Number;

  typedef typename Base::Vertex Vertex;

  typedef typename Base::Manifold Manifold;

  typedef typename Base::ManifoldPoint ManifoldPoint;

  typedef typename Base::Face Face;

private:

  //
  // Member data.
  //

  using Base::_manifold;

  //
  // Not implemented.
  //

  // Copy constructor not implemented.
  ComplexWithFreeVertexOnManifold(const ComplexWithFreeVertexOnManifold&);

  // Assignment operator not implemented.
  ComplexWithFreeVertexOnManifold& 
  operator=(const ComplexWithFreeVertexOnManifold&);
  
public:

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

  ComplexWithFreeVertexOnManifold()
  {}

  template<typename FaceIterator>
  ComplexWithFreeVertexOnManifold(FaceIterator beginning, FaceIterator end) :
    Base(beginning, end)
  {}

  ~ComplexWithFreeVertexOnManifold()
  {}

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

  using Base::getFreeVertex;

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

  using Base::set;

  using Base::setManifold;

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

  using Base::computeBBox;

  using Base::computeContent;

  void
  computeGradientOfContent(const ManifoldPoint& point, 
                           ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfContent(computePosition(point), &spaceGradient);
    // Compute the gradient in parameter space.
    (*gradient)[0] = computeDotProduct(spaceGradient, 
                                       computeDerivative(point));
  }

  using Base::computeNorm2;

  void
  computeGradientOfNorm2(const ManifoldPoint& point, 
                         ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfNorm2(computePosition(point), &spaceGradient);
    // Compute the gradient in parameter space.
    (*gradient)[0] = computeDotProduct(spaceGradient, 
                                       computeDerivative(point));
  }

  using Base::computeNorm2Modified;

  void
  computeGradientOfNorm2Modified(const ManifoldPoint& point, 
                                 ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfNorm2Modified(computePosition(point), 
                                         &spaceGradient);
    // Compute the gradient in parameter space.
    (*gradient)[0] = computeDotProduct(spaceGradient, 
                                       computeDerivative(point));
  }


private:

  // Compute a Euclidean position from parameter coordinates.
  using Base::computePosition;

  // Compute the derivative of position.
  Vertex
  computeDerivative(const ManifoldPoint& point) {
    assert(_manifold != 0);
    return _manifold->computeDerivative(point);
  }
};









template<template<int,typename> class QF,
         int N,
         class _Manifold,
         typename T>
class ComplexWithFreeVertexOnManifold<QF,N,2,_Manifold,T> :
  public ComplexWithFreeVertexOnManifoldBase<QF,N,2,_Manifold,T> {
private:

  //
  // Private types.
  //

  typedef ComplexWithFreeVertexOnManifoldBase<QF,N,2,_Manifold,T> Base;

public:

  //
  // Public types.
  //

  typedef typename Base::Number Number;

  typedef typename Base::Vertex Vertex;

  typedef typename Base::Manifold Manifold;

  typedef typename Base::ManifoldPoint ManifoldPoint;

  typedef typename Base::Face Face;

private:

  //
  // Member data.
  //

  using Base::_manifold;

  //
  // Not implemented.
  //

  // Copy constructor not implemented.
  ComplexWithFreeVertexOnManifold(const ComplexWithFreeVertexOnManifold&);

  // Assignment operator not implemented.
  ComplexWithFreeVertexOnManifold& 
  operator=(const ComplexWithFreeVertexOnManifold&);
  
public:

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

  ComplexWithFreeVertexOnManifold()
  {}

  template<typename FaceIterator>
  ComplexWithFreeVertexOnManifold(FaceIterator beginning, FaceIterator end) :
    Base(beginning, end)
  {}

  ~ComplexWithFreeVertexOnManifold()
  {}

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

  using Base::getFreeVertex;

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

  using Base::set;

  using Base::setManifold;

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

  using Base::computeBBox;

  using Base::computeContent;

  void
  computeGradientOfContent(const ManifoldPoint& point, 
                           ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfContent(computePosition(point), &spaceGradient);
    // Compute the gradient in parameter space.
    Vertex dxds, dxdt;
#ifdef __INTEL_COMPILER
    // CONTINUE: For some reason icc does not like the line below.
    // I replaced it with the contents of the function in order get it 
    // to compile.
    assert(_manifold != 0);
    _manifold->computeDerivative(point, &dxds, &dxdt)
#else
    computeDerivative(point, &dxds, &dxdt)
#endif
    (*gradient)[0] = computeDotProduct(spaceGradient, dxds);
    (*gradient)[1] = computeDotProduct(spaceGradient, dxdt);
  }

  using Base::computeNorm2;

  void
  computeGradientOfNorm2(const ManifoldPoint& point, 
                         ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfNorm2(computePosition(point), &spaceGradient);
    // Compute the gradient in parameter space.
    Vertex dxds, dxdt;
#ifdef __INTEL_COMPILER
    // CONTINUE: For some reason icc does not like the line below.
    // I replaced it with the contents of the function in order get it 
    // to compile.
    assert(_manifold != 0);
    _manifold->computeDerivative(point, &dxds, &dxdt)
#else
    computeDerivative(point, &dxds, &dxdt)
#endif
    (*gradient)[0] = computeDotProduct(spaceGradient, dxds);
    (*gradient)[1] = computeDotProduct(spaceGradient, dxdt);
  }

  using Base::computeNorm2Modified;

  void
  computeGradientOfNorm2Modified(const ManifoldPoint& point, 
                                 ManifoldPoint* gradient) {
    // Compute the gradient in Euclidean space.
    Vertex spaceGradient;
    Base::computeGradientOfNorm2Modified(computePosition(point), 
                                         &spaceGradient);
    // Compute the gradient in parameter space.
    Vertex dxds, dxdt;
    computeDerivative(point, &dxds, &dxdt);
    (*gradient)[0] = computeDotProduct(spaceGradient, dxds);
    (*gradient)[1] = computeDotProduct(spaceGradient, dxdt);
  }


private:

  // Compute a Euclidean position from parameter coordinates.
  using Base::computePosition;

  // Compute the derivative of position.
  void
  computeDerivative(const ManifoldPoint& point, Vertex* dxds, Vertex* dxdt) {
    assert(_manifold != 0);
    _manifold->computeDerivative(point, dxds, dxdt);
  }
};








template<class Complex>
class ComplexManifoldNorm2 :
  public std::unary_function<typename Complex::ManifoldPoint, 
                             typename Complex::Number> {
private:

  typedef std::unary_function<typename Complex::ManifoldPoint, 
                              typename Complex::Number> Base;

public:

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

private:

  mutable Complex& _sc;

  // Default constructor not implemented.
  ComplexManifoldNorm2();

  // Assignment operator not implemented.
  ComplexManifoldNorm2&
  operator=(const ComplexManifoldNorm2&);

public:

  ComplexManifoldNorm2(Complex& sc) :
    _sc(sc)
  {}

  ComplexManifoldNorm2(const ComplexManifoldNorm2& other) :
    _sc(other._sc)
  {}

  Complex&
  getComplex() const {
    return _sc;
  }

  result_type
  operator()(const argument_type& x) const {
    return _sc.computeNorm2(x);
  }

  void
  gradient(const argument_type& x, argument_type& grad) const {
    _sc.computeGradientOfNorm2(x, &grad);
  }
};




template<class Complex>
class ComplexManifoldNorm2Mod :
  public std::unary_function<typename Complex::ManifoldPoint, 
                             typename Complex::Number> {
private:

  typedef std::unary_function<typename Complex::ManifoldPoint, 
                              typename Complex::Number> Base;

public:

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

private:

  mutable Complex& _sc;

  // Default constructor not implemented.
  ComplexManifoldNorm2Mod();

  // Assignment operator not implemented.
  ComplexManifoldNorm2Mod&
  operator=(const ComplexManifoldNorm2Mod&);

public:

  ComplexManifoldNorm2Mod(Complex& sc) :
    _sc(sc)
  {}

  ComplexManifoldNorm2Mod(const ComplexManifoldNorm2Mod& x) :
    _sc(x._sc)
  {}

  Complex&
  getComplex() const {
    return _sc;
  }

  result_type
  operator()(const argument_type& x) const {
    return _sc.computeNorm2Modified(x);
  }

  void
  gradient(const argument_type& x, argument_type& grad) const {
    _sc.computeGradientOfNorm2Modified(x, &grad);
  }
};

END_NAMESPACE_GEOM

#define __geom_ComplexWithFreeVertexOnManifold_ipp__
#include "ComplexWithFreeVertexOnManifold.ipp"
#undef __geom_ComplexWithFreeVertexOnManifold_ipp__

#endif

---