dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/constraint/BallJointConstraint.hpp

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_CONSTRAINT_BALLJOINTCONSTRAINT_HPP_
+#define DART_CONSTRAINT_BALLJOINTCONSTRAINT_HPP_
+
+#include <dart/constraint/DynamicJointConstraint.hpp>
+
+#include <dart/math/MathTypes.hpp>
+
+#include <Eigen/Dense>
+
+namespace dart {
+namespace constraint {
+
+/// BallJointConstraint represents ball joint constraint between a body and the
+/// world or between two bodies
+class BallJointConstraint : public DynamicJointConstraint
+{
+public:
+  /// Constructor that takes one body and the joint position in the world frame
+  /// \param[in] _body
+  /// \param[in] _jointPos Joint position expressed in world frame
+  BallJointConstraint(
+      dynamics::BodyNode* _body, const Eigen::Vector3d& _jointPos);
+
+  /// Constructor that takes two bodies and the joint position in the frame of
+  /// _body1
+  /// \param[in] _body1
+  /// \param[in] _body2
+  /// \param[in] _jointPos Joint position expressed in world frame
+  BallJointConstraint(
+      dynamics::BodyNode* _body1,
+      dynamics::BodyNode* _body2,
+      const Eigen::Vector3d& _jointPos);
+
+  /// Destructor
+  virtual ~BallJointConstraint();
+
+  // Documentation inherited
+  const std::string& getType() const override;
+
+  /// Returns constraint type for this class.
+  static const std::string& getStaticType();
+
+protected:
+  //----------------------------------------------------------------------------
+  // Constraint virtual functions
+  //----------------------------------------------------------------------------
+
+  // Documentation inherited
+  void update() override;
+
+  // Documentation inherited
+  void getInformation(ConstraintInfo* _lcp) override;
+
+  // Documentation inherited
+  void applyUnitImpulse(std::size_t _index) override;
+
+  // Documentation inherited
+  void getVelocityChange(double* _vel, bool _withCfm) override;
+
+  // Documentation inherited
+  void excite() override;
+
+  // Documentation inherited
+  void unexcite() override;
+
+  // Documentation inherited
+  void applyImpulse(double* _lambda) override;
+
+  // Documentation inherited
+  bool isActive() const override;
+
+  // Documentation inherited
+  dynamics::SkeletonPtr getRootSkeleton() const override;
+
+  // Documentation inherited
+  void uniteSkeletons() override;
+
+private:
+  /// Offset from the origin of body frame 1 to the ball joint position where
+  /// the offset is expressed in body frame 1
+  Eigen::Vector3d mOffset1;
+
+  /// Offset from the origin of body frame 2 to the ball joint position where
+  /// the offset is expressed in body frame 2
+  Eigen::Vector3d mOffset2;
+
+  /// Position constraint violation expressed in body frame 1
+  Eigen::Vector3d mViolation;
+
+  /// Linear map between constraint space and Cartesian space for body1
+  Eigen::Matrix<double, 3, 6> mJacobian1;
+
+  /// Linear map between constraint space and Cartesian space for body2
+  Eigen::Matrix<double, 3, 6> mJacobian2;
+
+  ///
+  double mOldX[3];
+
+  /// Index of applied impulse
+  std::size_t mAppliedImpulseIndex;
+
+public:
+  // To get byte-aligned Eigen vectors
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+};
+
+} // namespace constraint
+} // namespace dart
+
+#endif // DART_CONSTRAINT_BALLJOINTCONSTRAINT_HPP_

include/dart/constraint/BoxedLcpConstraintSolver.hpp

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_CONSTRAINT_BOXEDLCPCONSTRAINTSOLVER_HPP_
+#define DART_CONSTRAINT_BOXEDLCPCONSTRAINTSOLVER_HPP_
+
+#include <dart/constraint/ConstraintSolver.hpp>
+#include <dart/constraint/SmartPointer.hpp>
+
+namespace dart {
+namespace constraint {
+
+class BoxedLcpConstraintSolver : public ConstraintSolver
+{
+public:
+  /// Constructor
+  ///
+  /// \param[in] timeStep Simulation time step
+  /// \param[in] boxedLcpSolver The primary boxed LCP solver. When nullptr is
+  /// passed, Dantzig solver will be used.
+  /// \param[in] secondaryBoxedLcpSolver The secondary boxed-LCP solver. When
+  /// nullptr is passed, PGS solver will be used. This is to make the default
+  /// solver setting to be Dantzig + PGS. In order to disable use of secondary
+  /// solver, call setSecondaryBoxedLcpSolver(nullptr) explicitly.
+  ///
+  /// \deprecated Deprecated in DART 6.8. Please use other constructors that
+  /// doesn't take timespte. Timestep should be set by the owner of this solver
+  /// such as dart::simulation::World when the solver added.
+  DART_DEPRECATED(6.8)
+  BoxedLcpConstraintSolver(
+      double timeStep,
+      BoxedLcpSolverPtr boxedLcpSolver = nullptr,
+      BoxedLcpSolverPtr secondaryBoxedLcpSolver = nullptr);
+
+  /// Constructs with default primary and secondary LCP solvers, which are
+  /// Dantzig and PGS, respectively.
+  BoxedLcpConstraintSolver();
+
+  /// Constructors with specific primary LCP solver.
+  ///
+  /// \param[in] boxedLcpSolver The primary boxed LCP solver. When nullptr is
+  /// passed, which is discouraged, Dantzig solver will be used.
+  BoxedLcpConstraintSolver(BoxedLcpSolverPtr boxedLcpSolver);
+
+  /// Constructs with specific primary and secondary LCP solvers.
+  ///
+  /// \param[in] boxedLcpSolver The primary boxed LCP solver. When nullptr is
+  /// passed, which is discouraged, Dantzig solver will be used.
+  /// \param[in] secondaryBoxedLcpSolver The secondary boxed-LCP solver. Pass
+  /// nullptr to disable using secondary LCP solver.
+  BoxedLcpConstraintSolver(
+      BoxedLcpSolverPtr boxedLcpSolver,
+      BoxedLcpSolverPtr secondaryBoxedLcpSolver);
+
+  /// Sets boxed LCP (BLCP) solver
+  ///
+  /// \param[in] lcpSolver The primary boxed LCP solver. When nullptr is
+  /// passed, Dantzig solver will be used.
+  void setBoxedLcpSolver(BoxedLcpSolverPtr lcpSolver);
+
+  /// Returns boxed LCP (BLCP) solver
+  ConstBoxedLcpSolverPtr getBoxedLcpSolver() const;
+
+  /// Sets boxed LCP (BLCP) solver that is used when the primary solver failed
+  void setSecondaryBoxedLcpSolver(BoxedLcpSolverPtr lcpSolver);
+
+  /// Returns boxed LCP (BLCP) solver that is used when the primary solver
+  /// failed
+  ConstBoxedLcpSolverPtr getSecondaryBoxedLcpSolver() const;
+
+protected:
+  // Documentation inherited.
+  void solveConstrainedGroup(ConstrainedGroup& group) override;
+
+  /// Boxed LCP solver
+  BoxedLcpSolverPtr mBoxedLcpSolver;
+  // TODO(JS): Hold as unique_ptr because there is no reason to share. Make this
+  // change in DART 7 because it's API breaking change.
+
+  /// Boxed LCP solver to be used when the primary solver failed
+  BoxedLcpSolverPtr mSecondaryBoxedLcpSolver;
+  // TODO(JS): Hold as unique_ptr because there is no reason to share. Make this
+  // change in DART 7 because it's API breaking change.
+
+  /// Cache data for boxed LCP formulation
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> mA;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
+      mABackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mX;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mXBackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mB;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mBBackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mW;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mLo;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mLoBackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mHi;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXd mHiBackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXi mFIndex;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXi mFIndexBackup;
+
+  /// Cache data for boxed LCP formulation
+  Eigen::VectorXi mOffset;
+
+#if DART_BUILD_MODE_DEBUG
+private:
+  /// Return true if the matrix is symmetric
+  bool isSymmetric(std::size_t n, double* A);
+
+  /// Return true if the diagonal block of matrix is symmetric
+  bool isSymmetric(
+      std::size_t n, double* A, std::size_t begin, std::size_t end);
+
+  /// Print debug information
+  void print(
+      std::size_t n,
+      double* A,
+      double* x,
+      double* lo,
+      double* hi,
+      double* b,
+      double* w,
+      int* findex);
+#endif
+};
+
+} // namespace constraint
+} // namespace dart
+
+#endif // DART_CONSTRAINT_BOXEDLCPCONSTRAINTSOLVER_HPP_

include/dart/constraint/BoxedLcpSolver.hpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_CONSTRAINT_BOXEDLCPSOLVER_HPP_
+#define DART_CONSTRAINT_BOXEDLCPSOLVER_HPP_
+
+#include <dart/config.hpp>
+
+#include <dart/common/Castable.hpp>
+
+#include <Eigen/Core>
+
+#include <string>
+
+namespace dart {
+namespace constraint {
+
+class BoxedLcpSolver : public common::Castable<BoxedLcpSolver>
+{
+public:
+  /// Destructor
+  virtual ~BoxedLcpSolver() = default;
+
+  /// Returns the type
+  virtual const std::string& getType() const = 0;
+
+  /// Solves constriant impulses for a constrained group. The LCP formulation
+  /// setting that this function solve is A*x = b + w where each x[i], w[i]
+  /// satisfies one of
+  ///   (1) x = lo, w >= 0
+  ///   (2) x = hi, w <= 0
+  ///   (3) lo < x < hi, w = 0
+  ///
+  /// \param[in] n Dimension of constraints.
+  /// \param[in] A A term of the LCP formulation.
+  /// \param[in] x x term of the LCP formulation.
+  /// \param[in] b b term of the LCP formulation.
+  /// \param[in] nub Number of the first unbounded constraints.
+  /// \param[in] lo Lower bound of x where it's restricted to be lo <= 0.
+  /// \param[in] hi Upper bound of x where it's enforced to be hi >= 0.
+  /// \param[in] findex Indices to corresponding normal contact constraint. Set
+  /// the index to itself (e.g., findex[k] = k) for normal contacts or
+  /// non-contact constraints. For friction constraint, set the cooresponding
+  /// normal contact constraint.
+  /// \param[in] earlyTermination Set true to return false as soon as the solver
+  /// find the solution doesn't exist. Otherwise, the solver will continue to
+  /// push hard to solve the problem using some hacks.
+  ///
+  /// \return Success.
+  // Note: The function signature is ODE specific for now. Consider changing
+  // this to Eigen friendly version once own Dantzig LCP solver is available.
+  virtual bool solve(
+      int n,
+      double* A,
+      double* x,
+      double* b,
+      int nub,
+      double* lo,
+      double* hi,
+      int* findex,
+      bool earlyTermination = false)
+      = 0;
+
+#if DART_BUILD_MODE_DEBUG
+  virtual bool canSolve(int n, const double* A) = 0;
+#endif
+};
+
+} // namespace constraint
+} // namespace dart
+
+#endif // DART_CONSTRAINT_BOXEDLCPSOLVER_HPP_

include/dart/constraint/ConstrainedGroup.hpp

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_CONSTRAINT_CONSTRAINEDGROUP_HPP_
+#define DART_CONSTRAINT_CONSTRAINEDGROUP_HPP_
+
+#include <dart/config.hpp>
+
+#include <dart/constraint/SmartPointer.hpp>
+
+#include <Eigen/Dense>
+
+#include <memory>
+#include <vector>
+
+namespace dart {
+
+namespace dynamics {
+class Skeleton;
+} // namespace dynamics
+
+namespace constraint {
+
+struct ConstraintInfo;
+class ConstraintBase;
+class ConstraintSolver;
+
+/// ConstrainedGroup is a group of skeletons that interact each other with
+/// constraints
+/// \sa class ConstraintSolver
+class ConstrainedGroup
+{
+public:
+  //----------------------------------------------------------------------------
+  // Constructor / Desctructor
+  //----------------------------------------------------------------------------
+
+  /// Default contructor
+  ConstrainedGroup();
+
+  /// Destructor
+  virtual ~ConstrainedGroup();
+
+  //----------------------------------------------------------------------------
+  // Setting
+  //----------------------------------------------------------------------------
+
+  /// Add constraint
+  void addConstraint(const ConstraintBasePtr& _constraint);
+
+  /// Return number of constraints in this constrained group
+  std::size_t getNumConstraints() const;
+
+  /// Return a constraint
+  ConstraintBasePtr getConstraint(std::size_t _index);
+
+  /// Return a constraint
+  ConstConstraintBasePtr getConstraint(std::size_t _index) const;
+
+  /// Remove constraint
+  void removeConstraint(const ConstraintBasePtr& _constraint);
+
+  /// Remove all constraints
+  void removeAllConstraints();
+
+  /// Get total dimension of contraints in this group
+  std::size_t getTotalDimension() const;
+
+  //----------------------------------------------------------------------------
+  // Friendship
+  //----------------------------------------------------------------------------
+
+  friend class ConstraintSolver;
+
+private:
+#if DART_BUILD_MODE_DEBUG
+  /// Return true if _constraint is contained
+  bool containConstraint(const ConstConstraintBasePtr& _constraint) const;
+#endif
+
+  /// List of constraints
+  std::vector<ConstraintBasePtr> mConstraints;
+
+  ///
+  std::shared_ptr<dynamics::Skeleton> mRootSkeleton;
+};
+
+} // namespace constraint
+} // namespace dart
+
+#endif // DART_CONSTRAINT_CONSTRAINEDGROUP_HPP_

include/dart/constraint/ConstraintBase.hpp

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_CONSTRAINT_CONSTRAINTBASE_HPP_
+#define DART_CONSTRAINT_CONSTRAINTBASE_HPP_
+
+#include <dart/dynamics/SmartPointer.hpp>
+
+#include <cstddef>
+
+namespace dart {
+
+namespace dynamics {
+class Skeleton;
+} // namespace dynamics
+
+namespace constraint {
+
+/// ConstraintInfo
+struct ConstraintInfo
+{
+  /// Impulse
+  double* x;
+
+  /// Lower bound of x
+  double* lo;
+
+  /// Upper bound of x
+  double* hi;
+
+  /// Bias term
+  double* b;
+
+  /// Slack variable
+  double* w;
+
+  /// Friction index
+  int* findex;
+
+  /// Inverse of time step
+  double invTimeStep;
+};
+
+/// Constraint is a base class of concrete constraints classes
+class ConstraintBase
+{
+public:
+  /// Returns a string representing the constraint type
+  virtual const std::string& getType() const;
+
+  /// Return dimesion of this constranit
+  std::size_t getDimension() const;
+
+  /// Update constraint using updated Skeleton's states
+  virtual void update() = 0;
+
+  /// Fill LCP variables
+  virtual void getInformation(ConstraintInfo* info) = 0;
+
+  /// Apply unit impulse to constraint space
+  virtual void applyUnitImpulse(std::size_t index) = 0;
+
+  /// Get velocity change due to the uint impulse
+  virtual void getVelocityChange(double* vel, bool withCfm) = 0;
+
+  /// Excite the constraint
+  virtual void excite() = 0;
+
+  /// Unexcite the constraint
+  virtual void unexcite() = 0;
+
+  /// Apply computed constraint impulse to constrained skeletons
+  virtual void applyImpulse(double* lambda) = 0;
+
+  /// Return true if this constraint is active
+  virtual bool isActive() const = 0;
+
+  ///
+  virtual dynamics::SkeletonPtr getRootSkeleton() const = 0;
+
+  ///
+  virtual void uniteSkeletons();
+
+  ///
+  static dynamics::SkeletonPtr compressPath(dynamics::SkeletonPtr skeleton);
+
+  ///
+  static dynamics::SkeletonPtr getRootSkeleton(dynamics::SkeletonPtr skeleton);
+
+  //----------------------------------------------------------------------------
+  // Friendship
+  //----------------------------------------------------------------------------
+
+  friend class ConstraintSolver;
+  friend class ConstrainedGroup;
+
+  /// Destructor
+  virtual ~ConstraintBase();
+
+protected:
+  /// Default contructor
+  ConstraintBase();
+
+protected:
+  /// Dimension of constraint
+  std::size_t mDim;
+};
+
+} // namespace constraint
+} // namespace dart
+
+#endif // DART_CONSTRAINT_CONSTRAINTBASE_HPP_