explicit.hh

Go to the documentation of this file.

// Copyright (c) 2015, LAAS-CNRS
// Authors: Florent Lamiraux
//
// This file is part of hpp-constraints.
// hpp-constraints is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-constraints is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-constraints. If not, see <http://www.gnu.org/licenses/>.

#ifndef HPP_CONSTRAINTS_EXPLICIT_HH
# define HPP_CONSTRAINTS_EXPLICIT_HH

# include <hpp/constraints/implicit.hh>

namespace hpp {
  namespace constraints {

    class HPP_CONSTRAINTS_DLLAPI Explicit : public virtual Implicit
    {
    public:
      virtual ImplicitPtr_t copy () const;

      static ExplicitPtr_t create
        (const DevicePtr_t& robot,
         const DifferentiableFunctionPtr_t& function,
     const segments_t& inputConf,
     const segments_t& outputConf,
     const segments_t& inputVelocity,
     const segments_t& outputVelocity,
         const ComparisonTypes_t& comp = ComparisonTypes_t())
        HPP_CONSTRAINTS_DEPRECATED;

      static ExplicitPtr_t create
        (const LiegroupSpacePtr_t& configSpace,
         const DifferentiableFunctionPtr_t& function,
     const segments_t& inputConf,
     const segments_t& outputConf,
     const segments_t& inputVelocity,
     const segments_t& outputVelocity,
         const ComparisonTypes_t& comp = ComparisonTypes_t());

      static ExplicitPtr_t createCopy (const ExplicitPtr_t& other);

      virtual DifferentiableFunctionPtr_t explicitFunction() const
      {
        return inputToOutput_;
      }

      const segments_t& outputConf () const
      {
    return outputConf_;
      }
      const segments_t& outputVelocity () const
      {
    return outputVelocity_;
      }
      const segments_t& inputConf () const
      {
    return inputConf_;
      }
      const segments_t& inputVelocity () const
      {
    return inputVelocity_;
      }
      virtual void implicitToExplicitRhs (vectorIn_t implicitRhs,
                                          vectorOut_t explicitRhs) const
      {
        explicitRhs = implicitRhs;
      }

      virtual void explicitToImplicitRhs (vectorIn_t explicitRhs,
                                          vectorOut_t implicitRhs) const
      {
        implicitRhs = explicitRhs;
      }

    protected:
      Explicit
    (const DevicePtr_t& robot, const DifferentiableFunctionPtr_t& function,
     const segments_t& inputConf,
     const segments_t& outputConf,
     const segments_t& inputVelocity,
     const segments_t& outputVelocity,
         const ComparisonTypes_t& comp) HPP_CONSTRAINTS_DEPRECATED;

      Explicit
    (const LiegroupSpacePtr_t& configSpace,
         const DifferentiableFunctionPtr_t& function,
     const segments_t& inputConf,
     const segments_t& outputConf,
     const segments_t& inputVelocity,
     const segments_t& outputVelocity,
         const ComparisonTypes_t& comp);

      Explicit (const Explicit& other);

      // Store weak pointer to itself
      void init (const ExplicitWkPtr_t& weak);
    protected:
      // Relation between input and output configuration variables
      DifferentiableFunctionPtr_t inputToOutput_;
      segments_t inputConf_;
      segments_t outputConf_;
      segments_t inputVelocity_;
      segments_t outputVelocity_;
    private:
      ExplicitWkPtr_t weak_;
    }; // class Explicit
  } // namespace constraints
} // namespace hpp

#endif // HPP_CONSTRAINTS_EXPLICIT_HH