/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/core/math/optimization/optimization_make_mbd_bounds.h

Go to the documentation of this file.

#ifndef OPENTISSUE_CORE_MATH_OPTIMIZATION_MAKE_MBD_BOUNDS_H
#define OPENTISSUE_CORE_MATH_OPTIMIZATION_MAKE_MBD_BOUNDS_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/core/math/big/big_types.h>
#include <OpenTissue/core/math/math_value_traits.h>
#include <cmath>

namespace OpenTissue
{
  namespace math
  {
    namespace optimization
    {

      namespace detail
      {


        template <typename T>
        class MultibodyDynamicsBoundFunctor
        {
        public:

          typedef T value_type;
          typedef OpenTissue::math::ValueTraits<T> value_traits;

        protected:

          bool                          m_is_lower;  
          ublas::vector<size_t> const & m_pi;        
          ublas::vector<T>      const & m_mu;        
          ublas::vector<T>      const & m_val;       
          size_t                        m_n;         

        public:

          class vector_iterator
          {
          protected:

            bool   m_end;   
            size_t m_idx;   
            T      m_mu;    

          public:

            vector_iterator()
              : m_end(true)
              , m_idx(0)
              , m_mu(value_traits::zero())
            {}

            vector_iterator(vector_iterator const & i) { *this = i; }

            vector_iterator(size_t const & idx, T const & mu)
              : m_end(false)
              , m_idx(idx)
              , m_mu(mu)
            {}

            bool const operator==(vector_iterator const & i) const     {      return this->m_end == i.m_end;     }
            bool const operator!=(vector_iterator const & i) const {  return !( (*this) == i); }

            size_t const index() const { return m_idx; }

            T operator*() const { return m_mu; }

            vector_iterator & operator=(vector_iterator const & i) 
            {
              this->m_end = i.m_end;
              this->m_idx = i.m_idx;
              this->m_mu  = i.m_mu;
              return *this;
            }

            vector_iterator const & operator++() 
            {
              m_end = true;
              return *this; 
            }
          };

        public:

          MultibodyDynamicsBoundFunctor(
            bool const & is_lower
            , ublas::vector<size_t> const & pi
            , ublas::vector<T> const & mu
            , ublas::vector<T> const & val
            )
            : m_is_lower(is_lower)
            , m_pi(pi)
            , m_mu(mu)
            , m_val(val)
            , m_n( pi.size() )
          {}

          template<typename vector_type>
          T operator()(vector_type const & x, size_t const & i) const
          {
            size_t const j = m_pi(i);

            if(j<m_n)
            {
              T  const mu_i = m_mu(i);
              return m_is_lower ? -mu_i*x(j) : mu_i*x(j);
            }

            return m_val(i);
          }

          vector_iterator partial_begin(size_t const & i) const 
          {
            size_t const j = m_pi(i);
            if(j<m_n)
            {
              T const  mu_i = m_mu(i);
              return m_is_lower ? vector_iterator(j,-mu_i) :  vector_iterator(j, mu_i);
            }
            return vector_iterator();
          }

          vector_iterator partial_end(size_t const & i) const {  return vector_iterator(); }

          size_t size() const { return m_n; }

        };

      } // namespace detail

      template<typename T>
      inline detail::MultibodyDynamicsBoundFunctor<T> make_lower_mbd_bounds( 
          ublas::vector<size_t> const & pi
        , ublas::vector<T> const & mu
        , ublas::vector<T> const & val
        )
      {
        return detail::MultibodyDynamicsBoundFunctor<T>(true, pi, mu, val );
      }

      template<typename T>
      inline detail::MultibodyDynamicsBoundFunctor<T> make_upper_mbd_bounds( 
        ublas::vector<size_t> const & pi
        , ublas::vector<T> const & mu
        , ublas::vector<T> const & val
        )
      {
        return detail::MultibodyDynamicsBoundFunctor<T>(false, pi, mu, val );
      }

    } // namespace optimization
  } // namespace math
} // namespace OpenTissue

// OPENTISSUE_CORE_MATH_OPTIMIZATION_MAKE_MBD_BOUNDS_H
#endif