joint-revolute.hpp
Go to the documentation of this file.
1 //
2 // Copyright (c) 2015-2020 CNRS INRIA
3 // Copyright (c) 2015-2016 Wandercraft, 86 rue de Paris 91400 Orsay, France.
4 //
5 
6 #ifndef __pinocchio_multibody_joint_revolute_hpp__
7 #define __pinocchio_multibody_joint_revolute_hpp__
8 
15 
16 namespace pinocchio
17 {
18 
19  template<typename Scalar, int Options, int axis>
21 
22  template<typename Scalar, int Options, int axis>
24  {
26  };
27 
28  template<typename Scalar, int Options, int axis, typename MotionDerived>
30  {
32  };
33 
34  template<typename _Scalar, int _Options, int axis>
35  struct traits<MotionRevoluteTpl<_Scalar, _Options, axis>>
36  {
37  typedef _Scalar Scalar;
38  enum
39  {
40  Options = _Options
41  };
42  typedef Eigen::Matrix<Scalar, 3, 1, Options> Vector3;
43  typedef Eigen::Matrix<Scalar, 6, 1, Options> Vector6;
44  typedef Eigen::Matrix<Scalar, 4, 4, Options> Matrix4;
45  typedef Eigen::Matrix<Scalar, 6, 6, Options> Matrix6;
46  typedef typename PINOCCHIO_EIGEN_REF_CONST_TYPE(Vector6) ToVectorConstReturnType;
47  typedef typename PINOCCHIO_EIGEN_REF_TYPE(Vector6) ToVectorReturnType;
50  typedef const Vector3 ConstAngularType;
51  typedef const Vector3 ConstLinearType;
56  enum
57  {
58  LINEAR = 0,
59  ANGULAR = 3
60  };
61  }; // traits MotionRevoluteTpl
62 
63  template<typename Scalar, int Options, int axis>
65 
66  template<typename _Scalar, int _Options, int _axis>
67  struct traits<TransformRevoluteTpl<_Scalar, _Options, _axis>>
68  {
69  enum
70  {
71  axis = _axis,
72  Options = _Options,
73  LINEAR = 0,
74  ANGULAR = 3
75  };
76  typedef _Scalar Scalar;
78  typedef Eigen::Matrix<Scalar, 3, 1, Options> Vector3;
79  typedef Eigen::Matrix<Scalar, 3, 3, Options> Matrix3;
83  typedef typename Vector3::ConstantReturnType LinearType;
84  typedef typename Vector3::ConstantReturnType LinearRef;
85  typedef const typename Vector3::ConstantReturnType ConstLinearRef;
88  }; // traits TransformRevoluteTpl
89 
90  template<typename Scalar, int Options, int axis>
92  {
94  };
95 
96  template<typename _Scalar, int _Options, int axis>
97  struct TransformRevoluteTpl : SE3Base<TransformRevoluteTpl<_Scalar, _Options, axis>>
98  {
99  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
101 
103  {
104  }
106  : m_sin(sin)
107  , m_cos(cos)
108  {
109  }
110 
111  PlainType plain() const
112  {
113  PlainType res(PlainType::Identity());
114  _setRotation(res.rotation());
115  return res;
116  }
117 
118  operator PlainType() const
119  {
120  return plain();
121  }
122 
123  template<typename S2, int O2>
125  se3action(const SE3Tpl<S2, O2> & m) const
126  {
127  typedef typename SE3GroupAction<TransformRevoluteTpl>::ReturnType ReturnType;
128  ReturnType res;
129  switch (axis)
130  {
131  case 0: {
132  res.rotation().col(0) = m.rotation().col(0);
133  res.rotation().col(1).noalias() = m_cos * m.rotation().col(1) + m_sin * m.rotation().col(2);
134  res.rotation().col(2).noalias() = res.rotation().col(0).cross(res.rotation().col(1));
135  break;
136  }
137  case 1: {
138  res.rotation().col(2).noalias() = m_cos * m.rotation().col(2) + m_sin * m.rotation().col(0);
139  res.rotation().col(1) = m.rotation().col(1);
140  res.rotation().col(0).noalias() = res.rotation().col(1).cross(res.rotation().col(2));
141  break;
142  }
143  case 2: {
144  res.rotation().col(0).noalias() = m_cos * m.rotation().col(0) + m_sin * m.rotation().col(1);
145  res.rotation().col(1).noalias() = res.rotation().col(2).cross(res.rotation().col(0));
146  res.rotation().col(2) = m.rotation().col(2);
147  break;
148  }
149  default: {
150  assert(false && "must never happened");
151  break;
152  }
153  }
154  res.translation() = m.translation();
155  return res;
156  }
157 
158  const Scalar & sin() const
159  {
160  return m_sin;
161  }
163  {
164  return m_sin;
165  }
166 
167  const Scalar & cos() const
168  {
169  return m_cos;
170  }
172  {
173  return m_cos;
174  }
175 
176  template<typename OtherScalar>
177  void setValues(const OtherScalar & sin, const OtherScalar & cos)
178  {
179  m_sin = sin;
180  m_cos = cos;
181  }
182 
183  LinearType translation() const
184  {
185  return LinearType::PlainObject::Zero(3);
186  }
187  AngularType rotation() const
188  {
189  AngularType m(AngularType::Identity());
190  _setRotation(m);
191  return m;
192  }
193 
194  bool isEqual(const TransformRevoluteTpl & other) const
195  {
196  return internal::comparison_eq(m_cos, other.m_cos)
198  }
199 
200  protected:
202  inline void _setRotation(typename PlainType::AngularRef & rot) const
203  {
204  switch (axis)
205  {
206  case 0: {
207  rot.coeffRef(1, 1) = m_cos;
208  rot.coeffRef(1, 2) = -m_sin;
209  rot.coeffRef(2, 1) = m_sin;
210  rot.coeffRef(2, 2) = m_cos;
211  break;
212  }
213  case 1: {
214  rot.coeffRef(0, 0) = m_cos;
215  rot.coeffRef(0, 2) = m_sin;
216  rot.coeffRef(2, 0) = -m_sin;
217  rot.coeffRef(2, 2) = m_cos;
218  break;
219  }
220  case 2: {
221  rot.coeffRef(0, 0) = m_cos;
222  rot.coeffRef(0, 1) = -m_sin;
223  rot.coeffRef(1, 0) = m_sin;
224  rot.coeffRef(1, 1) = m_cos;
225  break;
226  }
227  default: {
228  assert(false && "must never happened");
229  break;
230  }
231  }
232  }
233  };
234 
235  template<typename _Scalar, int _Options, int axis>
236  struct MotionRevoluteTpl : MotionBase<MotionRevoluteTpl<_Scalar, _Options, axis>>
237  {
238  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
239 
243 
245  {
246  }
247 
249  : m_w(w)
250  {
251  }
252 
253  template<typename Vector1Like>
254  MotionRevoluteTpl(const Eigen::MatrixBase<Vector1Like> & v)
255  : m_w(v[0])
256  {
257  using namespace Eigen;
258  EIGEN_STATIC_ASSERT_SIZE_1x1(Vector1Like);
259  }
260 
261  inline PlainReturnType plain() const
262  {
263  return Axis() * m_w;
264  }
265 
266  template<typename OtherScalar>
267  MotionRevoluteTpl __mult__(const OtherScalar & alpha) const
268  {
269  return MotionRevoluteTpl(alpha * m_w);
270  }
271 
272  template<typename MotionDerived>
274  {
275  m.linear().setZero();
276  for (Eigen::DenseIndex k = 0; k < 3; ++k)
277  {
278  m.angular()[k] = k == axis ? m_w : Scalar(0);
279  }
280  }
281 
282  template<typename MotionDerived>
283  inline void addTo(MotionDense<MotionDerived> & v) const
284  {
285  typedef typename MotionDense<MotionDerived>::Scalar OtherScalar;
286  v.angular()[axis] += (OtherScalar)m_w;
287  }
288 
289  template<typename S2, int O2, typename D2>
290  inline void se3Action_impl(const SE3Tpl<S2, O2> & m, MotionDense<D2> & v) const
291  {
292  v.angular().noalias() = m.rotation().col(axis) * m_w;
293  v.linear().noalias() = m.translation().cross(v.angular());
294  }
295 
296  template<typename S2, int O2>
297  MotionPlain se3Action_impl(const SE3Tpl<S2, O2> & m) const
298  {
299  MotionPlain res;
300  se3Action_impl(m, res);
301  return res;
302  }
303 
304  template<typename S2, int O2, typename D2>
306  {
307  // Linear
308  CartesianAxis3::alphaCross(m_w, m.translation(), v.angular());
309  v.linear().noalias() = m.rotation().transpose() * v.angular();
310 
311  // Angular
312  v.angular().noalias() = m.rotation().transpose().col(axis) * m_w;
313  }
314 
315  template<typename S2, int O2>
316  MotionPlain se3ActionInverse_impl(const SE3Tpl<S2, O2> & m) const
317  {
318  MotionPlain res;
320  return res;
321  }
322 
323  template<typename M1, typename M2>
324  EIGEN_STRONG_INLINE void motionAction(const MotionDense<M1> & v, MotionDense<M2> & mout) const
325  {
326  // Linear
327  CartesianAxis3::alphaCross(-m_w, v.linear(), mout.linear());
328 
329  // Angular
330  CartesianAxis3::alphaCross(-m_w, v.angular(), mout.angular());
331  }
332 
333  template<typename M1>
334  MotionPlain motionAction(const MotionDense<M1> & v) const
335  {
336  MotionPlain res;
337  motionAction(v, res);
338  return res;
339  }
340 
342  {
343  return m_w;
344  }
345  const Scalar & angularRate() const
346  {
347  return m_w;
348  }
349 
350  bool isEqual_impl(const MotionRevoluteTpl & other) const
351  {
352  return internal::comparison_eq(m_w, other.m_w);
353  }
354 
355  protected:
357  }; // struct MotionRevoluteTpl
358 
359  template<typename S1, int O1, int axis, typename MotionDerived>
360  typename MotionDerived::MotionPlain
362  {
363  typename MotionDerived::MotionPlain res(m2);
364  res += m1;
365  return res;
366  }
367 
368  template<typename MotionDerived, typename S2, int O2, int axis>
369  EIGEN_STRONG_INLINE typename MotionDerived::MotionPlain
371  {
372  return m2.motionAction(m1);
373  }
374 
375  template<typename Scalar, int Options, int axis>
377 
378  template<typename Scalar, int Options, int axis>
380  {
381  typedef Eigen::Matrix<Scalar, 6, 1, Options> ReturnType;
382  };
383 
384  template<typename Scalar, int Options, int axis, typename MotionDerived>
386  {
387  typedef Eigen::Matrix<Scalar, 6, 1, Options> ReturnType;
388  };
389 
390  template<typename Scalar, int Options, int axis, typename ForceDerived>
392  {
393  typedef typename ForceDense<
394  ForceDerived>::ConstAngularType::template ConstFixedSegmentReturnType<1>::Type ReturnType;
395  };
396 
397  template<typename Scalar, int Options, int axis, typename ForceSet>
399  {
400  typedef typename Eigen::MatrixBase<ForceSet>::ConstRowXpr ReturnType;
401  };
402 
403  template<typename _Scalar, int _Options, int axis>
404  struct traits<JointMotionSubspaceRevoluteTpl<_Scalar, _Options, axis>>
405  {
406  typedef _Scalar Scalar;
407  enum
408  {
409  Options = _Options
410  };
411  enum
412  {
413  LINEAR = 0,
414  ANGULAR = 3
415  };
416 
418  typedef Eigen::Matrix<Scalar, 1, 1, Options> JointForce;
419  typedef Eigen::Matrix<Scalar, 6, 1, Options> DenseBase;
420  typedef Eigen::Matrix<Scalar, 1, 1, Options> ReducedSquaredMatrix;
421 
424 
425  typedef typename ReducedSquaredMatrix::IdentityReturnType StDiagonalMatrixSOperationReturnType;
426  }; // traits JointMotionSubspaceRevoluteTpl
427 
428  template<typename _Scalar, int _Options, int axis>
430  : JointMotionSubspaceBase<JointMotionSubspaceRevoluteTpl<_Scalar, _Options, axis>>
431  {
432  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
433 
435  enum
436  {
437  NV = 1
438  };
439 
441 
443  {
444  }
445 
446  template<typename Vector1Like>
447  JointMotion __mult__(const Eigen::MatrixBase<Vector1Like> & v) const
448  {
449  return JointMotion(v[0]);
450  }
451 
452  template<typename S1, int O1>
454  se3Action(const SE3Tpl<S1, O1> & m) const
455  {
457  ReturnType res;
458  res.template segment<3>(LINEAR) = m.translation().cross(m.rotation().col(axis));
459  res.template segment<3>(ANGULAR) = m.rotation().col(axis);
460  return res;
461  }
462 
463  template<typename S1, int O1>
466  {
468  typedef typename Axis::CartesianAxis3 CartesianAxis3;
469  ReturnType res;
470  res.template segment<3>(LINEAR).noalias() =
471  m.rotation().transpose() * CartesianAxis3::cross(m.translation());
472  res.template segment<3>(ANGULAR) = m.rotation().transpose().col(axis);
473  return res;
474  }
475 
476  int nv_impl() const
477  {
478  return NV;
479  }
480 
481  struct TransposeConst : JointMotionSubspaceTransposeBase<JointMotionSubspaceRevoluteTpl>
482  {
485  : ref(ref)
486  {
487  }
488 
489  template<typename ForceDerived>
492  {
493  return f.angular().template segment<1>(axis);
494  }
495 
497  template<typename Derived>
499  operator*(const Eigen::MatrixBase<Derived> & F) const
500  {
501  assert(F.rows() == 6);
502  return F.row(ANGULAR + axis);
503  }
504  }; // struct TransposeConst
505 
507  {
508  return TransposeConst(*this);
509  }
510 
511  /* CRBA joint operators
512  * - ForceSet::Block = ForceSet
513  * - ForceSet operator* (Inertia Y,Constraint S)
514  * - MatrixBase operator* (Constraint::Transpose S, ForceSet::Block)
515  * - SE3::act(ForceSet::Block)
516  */
517  DenseBase matrix_impl() const
518  {
519  DenseBase S;
521  v << Axis();
522  return S;
523  }
524 
525  template<typename MotionDerived>
528  {
529  typedef
531  ReturnType;
532  ReturnType res;
534  v = m.cross(Axis());
535  return res;
536  }
537 
539  {
540  return true;
541  }
542 
543  }; // struct JointMotionSubspaceRevoluteTpl
544 
545  template<typename _Scalar, int _Options, int _axis>
547  {
548  typedef _Scalar Scalar;
549 
550  enum
551  {
552  Options = _Options,
553  axis = _axis
554  };
555  };
556 
557  template<typename S1, int O1, typename S2, int O2, int axis>
559  {
560  typedef Eigen::Matrix<S2, 6, 1, O2> ReturnType;
561  };
562 
563  /* [CRBA] ForceSet operator* (Inertia Y,Constraint S) */
564  namespace impl
565  {
566  template<typename S1, int O1, typename S2, int O2>
568  {
572  static inline ReturnType run(const Inertia & Y, const Constraint & /*constraint*/)
573  {
574  ReturnType res;
575 
576  /* Y(:,3) = ( 0,-z, y, I00+yy+zz, I01-xy , I02-xz ) */
577  const S1 &m = Y.mass(), &x = Y.lever()[0], &y = Y.lever()[1], &z = Y.lever()[2];
578  const typename Inertia::Symmetric3 & I = Y.inertia();
579 
580  res << (S2)0, -m * z, m * y, I(0, 0) + m * (y * y + z * z), I(0, 1) - m * x * y,
581  I(0, 2) - m * x * z;
582 
583  return res;
584  }
585  };
586 
587  template<typename S1, int O1, typename S2, int O2>
589  {
593  static inline ReturnType run(const Inertia & Y, const Constraint & /*constraint*/)
594  {
595  ReturnType res;
596 
597  /* Y(:,4) = ( z, 0,-x, I10-xy , I11+xx+zz, I12-yz ) */
598  const S1 &m = Y.mass(), &x = Y.lever()[0], &y = Y.lever()[1], &z = Y.lever()[2];
599  const typename Inertia::Symmetric3 & I = Y.inertia();
600 
601  res << m * z, (S2)0, -m * x, I(1, 0) - m * x * y, I(1, 1) + m * (x * x + z * z),
602  I(1, 2) - m * y * z;
603 
604  return res;
605  }
606  };
607 
608  template<typename S1, int O1, typename S2, int O2>
610  {
614  static inline ReturnType run(const Inertia & Y, const Constraint & /*constraint*/)
615  {
616  ReturnType res;
617 
618  /* Y(:,5) = (-y, x, 0, I20-xz , I21-yz , I22+xx+yy) */
619  const S1 &m = Y.mass(), &x = Y.lever()[0], &y = Y.lever()[1], &z = Y.lever()[2];
620  const typename Inertia::Symmetric3 & I = Y.inertia();
621 
622  res << -m * y, m * x, (S2)0, I(2, 0) - m * x * z, I(2, 1) - m * y * z,
623  I(2, 2) + m * (x * x + y * y);
624 
625  return res;
626  }
627  };
628  } // namespace impl
629 
630  template<typename M6Like, typename S2, int O2, int axis>
631  struct MultiplicationOp<Eigen::MatrixBase<M6Like>, JointMotionSubspaceRevoluteTpl<S2, O2, axis>>
632  {
633  typedef typename M6Like::ConstColXpr ReturnType;
634  };
635 
636  /* [ABA] operator* (Inertia Y,Constraint S) */
637  namespace impl
638  {
639  template<typename M6Like, typename Scalar, int Options, int axis>
641  Eigen::MatrixBase<M6Like>,
642  JointMotionSubspaceRevoluteTpl<Scalar, Options, axis>>
643  {
645  typedef
647  static inline ReturnType
648  run(const Eigen::MatrixBase<M6Like> & Y, const Constraint & /*constraint*/)
649  {
650  EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(M6Like, 6, 6);
651  return Y.col(Inertia::ANGULAR + axis);
652  }
653  };
654  } // namespace impl
655 
656  template<typename _Scalar, int _Options, int axis>
657  struct traits<JointRevoluteTpl<_Scalar, _Options, axis>>
658  {
659  enum
660  {
661  NQ = 1,
662  NV = 1
663  };
664  typedef _Scalar Scalar;
665  enum
666  {
667  Options = _Options
668  };
675 
676  // [ABA]
677  typedef Eigen::Matrix<Scalar, 6, NV, Options> U_t;
678  typedef Eigen::Matrix<Scalar, NV, NV, Options> D_t;
679  typedef Eigen::Matrix<Scalar, 6, NV, Options> UD_t;
680 
681  typedef Eigen::Matrix<Scalar, NQ, 1, Options> ConfigVector_t;
682  typedef Eigen::Matrix<Scalar, NV, 1, Options> TangentVector_t;
683 
685  };
686 
687  template<typename _Scalar, int _Options, int axis>
688  struct traits<JointDataRevoluteTpl<_Scalar, _Options, axis>>
689  {
691  typedef _Scalar Scalar;
692  };
693 
694  template<typename _Scalar, int _Options, int axis>
695  struct traits<JointModelRevoluteTpl<_Scalar, _Options, axis>>
696  {
698  typedef _Scalar Scalar;
699  };
700 
701  template<typename _Scalar, int _Options, int axis>
702  struct JointDataRevoluteTpl : public JointDataBase<JointDataRevoluteTpl<_Scalar, _Options, axis>>
703  {
704  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
708 
709  ConfigVector_t joint_q;
710  TangentVector_t joint_v;
711 
712  Constraint_t S;
713  Transformation_t M;
714  Motion_t v;
715  Bias_t c;
716 
717  // [ABA] specific data
718  U_t U;
719  D_t Dinv;
720  UD_t UDinv;
721  D_t StU;
722 
724  : joint_q(ConfigVector_t::Zero())
725  , joint_v(TangentVector_t::Zero())
726  , M((Scalar)0, (Scalar)1)
727  , v((Scalar)0)
728  , U(U_t::Zero())
729  , Dinv(D_t::Zero())
730  , UDinv(UD_t::Zero())
731  , StU(D_t::Zero())
732  {
733  }
734 
735  static std::string classname()
736  {
737  return std::string("JointDataR") + axisLabel<axis>();
738  }
739  std::string shortname() const
740  {
741  return classname();
742  }
743 
744  }; // struct JointDataRevoluteTpl
745 
746  template<typename NewScalar, typename Scalar, int Options, int axis>
748  {
750  };
751 
752  template<typename _Scalar, int _Options, int axis>
753  struct JointModelRevoluteTpl
754  : public JointModelBase<JointModelRevoluteTpl<_Scalar, _Options, axis>>
755  {
756  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
758  PINOCCHIO_JOINT_TYPEDEF_TEMPLATE(JointDerived);
759 
761  using Base::id;
762  using Base::idx_q;
763  using Base::idx_v;
764  using Base::setIndexes;
765 
766  typedef Eigen::Matrix<Scalar, 3, 1, _Options> Vector3;
767 
768  JointDataDerived createData() const
769  {
770  return JointDataDerived();
771  }
772 
774  {
775  }
776 
777  const std::vector<bool> hasConfigurationLimit() const
778  {
779  return {true};
780  }
781 
782  const std::vector<bool> hasConfigurationLimitInTangent() const
783  {
784  return {true};
785  }
786 
787  template<typename ConfigVector>
788  EIGEN_DONT_INLINE void
789  calc(JointDataDerived & data, const typename Eigen::MatrixBase<ConfigVector> & qs) const
790  {
791  data.joint_q[0] = qs[idx_q()];
792  Scalar ca, sa;
793  SINCOS(data.joint_q[0], &sa, &ca);
794  data.M.setValues(sa, ca);
795  }
796 
797  template<typename TangentVector>
798  EIGEN_DONT_INLINE void
799  calc(JointDataDerived & data, const Blank, const typename Eigen::MatrixBase<TangentVector> & vs)
800  const
801  {
802  data.joint_v[0] = vs[idx_v()];
803  data.v.angularRate() = data.joint_v[0];
804  }
805 
806  template<typename ConfigVector, typename TangentVector>
807  EIGEN_DONT_INLINE void calc(
808  JointDataDerived & data,
809  const typename Eigen::MatrixBase<ConfigVector> & qs,
810  const typename Eigen::MatrixBase<TangentVector> & vs) const
811  {
812  calc(data, qs.derived());
813 
814  data.joint_v[0] = vs[idx_v()];
815  data.v.angularRate() = data.joint_v[0];
816  }
817 
818  template<typename VectorLike, typename Matrix6Like>
819  void calc_aba(
820  JointDataDerived & data,
821  const Eigen::MatrixBase<VectorLike> & armature,
822  const Eigen::MatrixBase<Matrix6Like> & I,
823  const bool update_I) const
824  {
825  data.U = I.col(Inertia::ANGULAR + axis);
826  data.Dinv[0] =
827  Scalar(1) / (I(Inertia::ANGULAR + axis, Inertia::ANGULAR + axis) + armature[0]);
828  data.UDinv.noalias() = data.U * data.Dinv[0];
829 
830  if (update_I)
831  PINOCCHIO_EIGEN_CONST_CAST(Matrix6Like, I).noalias() -= data.UDinv * data.U.transpose();
832  }
833 
834  static std::string classname()
835  {
836  return std::string("JointModelR") + axisLabel<axis>();
837  }
838  std::string shortname() const
839  {
840  return classname();
841  }
842 
844  {
845  switch (axis)
846  {
847  case 0:
848  return Vector3::UnitX();
849  case 1:
850  return Vector3::UnitY();
851  case 2:
852  return Vector3::UnitZ();
853  default:
854  assert(false && "must never happen");
855  break;
856  }
857  }
858 
860  template<typename NewScalar>
862  {
864  ReturnType res;
865  res.setIndexes(id(), idx_q(), idx_v());
866  return res;
867  }
868 
869  }; // struct JointModelRevoluteTpl
870 
874 
878 
882 
883 } // namespace pinocchio
884 
885 #include <boost/type_traits.hpp>
886 
887 namespace boost
888 {
889  template<typename Scalar, int Options, int axis>
890  struct has_nothrow_constructor<::pinocchio::JointModelRevoluteTpl<Scalar, Options, axis>>
891  : public integral_constant<bool, true>
892  {
893  };
894 
895  template<typename Scalar, int Options, int axis>
896  struct has_nothrow_copy<::pinocchio::JointModelRevoluteTpl<Scalar, Options, axis>>
897  : public integral_constant<bool, true>
898  {
899  };
900 
901  template<typename Scalar, int Options, int axis>
902  struct has_nothrow_constructor<::pinocchio::JointDataRevoluteTpl<Scalar, Options, axis>>
903  : public integral_constant<bool, true>
904  {
905  };
906 
907  template<typename Scalar, int Options, int axis>
908  struct has_nothrow_copy<::pinocchio::JointDataRevoluteTpl<Scalar, Options, axis>>
909  : public integral_constant<bool, true>
910  {
911  };
912 } // namespace boost
913 
914 #endif // ifndef __pinocchio_multibody_joint_revolute_hpp__
pinocchio::traits< JointModelRevoluteTpl< _Scalar, _Options, axis > >::JointDerived
JointRevoluteTpl< _Scalar, _Options, axis > JointDerived
Definition: joint-revolute.hpp:697
pinocchio::InertiaTpl
Definition: spatial/fwd.hpp:58
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 0 > >::run
static ReturnType run(const Inertia &Y, const Constraint &)
Definition: joint-revolute.hpp:572
pinocchio::JointMotionSubspaceRevoluteTpl::matrix_impl
DenseBase matrix_impl() const
Definition: joint-revolute.hpp:517
pinocchio::joint_q
JointDataTpl< Scalar, Options, JointCollectionTpl >::ConfigVector_t joint_q(const JointDataTpl< Scalar, Options, JointCollectionTpl > &jdata)
Visit a JointDataVariant through JointConfigVisitor to get the joint configuration vector.
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:664
PINOCCHIO_JOINT_DATA_BASE_ACCESSOR_DEFAULT_RETURN_TYPE
#define PINOCCHIO_JOINT_DATA_BASE_ACCESSOR_DEFAULT_RETURN_TYPE
Definition: joint-data-base.hpp:137
sincos.hpp
pinocchio::JointModelRevoluteTpl::calc
EIGEN_DONT_INLINE void calc(JointDataDerived &data, const Blank, const typename Eigen::MatrixBase< TangentVector > &vs) const
Definition: joint-revolute.hpp:799
Eigen
pinocchio::MultiplicationOp
Forward declaration of the multiplication operation return type. Should be overloaded,...
Definition: binary-op.hpp:15
test-cpp2pybind11.m
m
Definition: test-cpp2pybind11.py:25
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::ConfigVector_t
Eigen::Matrix< Scalar, NQ, 1, Options > ConfigVector_t
Definition: joint-revolute.hpp:681
pinocchio::TransformRevoluteTpl::isEqual
bool isEqual(const TransformRevoluteTpl &other) const
Definition: joint-revolute.hpp:194
pinocchio::TransformRevoluteTpl::translation
LinearType translation() const
Definition: joint-revolute.hpp:183
pinocchio::TransformRevoluteTpl::rotation
AngularType rotation() const
Definition: joint-revolute.hpp:187
pinocchio::JointModelRevoluteTpl::Base
JointModelBase< JointModelRevoluteTpl > Base
Definition: joint-revolute.hpp:760
pinocchio::JointDataRevoluteTpl::classname
static std::string classname()
Definition: joint-revolute.hpp:735
pinocchio::JointMotionSubspaceRevoluteTpl::transpose
TransposeConst transpose() const
Definition: joint-revolute.hpp:506
pinocchio::MotionRevoluteTpl::__mult__
MotionRevoluteTpl __mult__(const OtherScalar &alpha) const
Definition: joint-revolute.hpp:267
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::Vector6
Eigen::Matrix< Scalar, 6, 1, Options > Vector6
Definition: joint-revolute.hpp:43
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::Matrix3
Eigen::Matrix< Scalar, 3, 3, Options > Matrix3
Definition: joint-revolute.hpp:79
pinocchio::JointModelRevoluteTpl::hasConfigurationLimit
const std::vector< bool > hasConfigurationLimit() const
Definition: joint-revolute.hpp:777
pinocchio::MotionRevoluteTpl
Definition: joint-revolute.hpp:20
pinocchio::CartesianAxis::cross
static void cross(const Eigen::MatrixBase< V3_in > &vin, const Eigen::MatrixBase< V3_out > &vout)
pinocchio::JointMotionSubspaceRevoluteTpl::motionAction
MotionAlgebraAction< JointMotionSubspaceRevoluteTpl, MotionDerived >::ReturnType motionAction(const MotionDense< MotionDerived > &m) const
Definition: joint-revolute.hpp:527
pinocchio::MotionRevoluteTpl::Axis
SpatialAxis< axis+ANGULAR > Axis
Definition: joint-revolute.hpp:241
pinocchio::traits< JointDataRevoluteTpl< _Scalar, _Options, axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:691
pinocchio::JointRX
JointRevoluteTpl< context::Scalar, context::Options, 0 > JointRX
Definition: joint-revolute.hpp:871
pinocchio::idx_q
int idx_q(const JointModelTpl< Scalar, Options, JointCollectionTpl > &jmodel)
Visit a JointModelTpl through JointIdxQVisitor to get the index in the full model configuration space...
pinocchio::JointModelRevoluteTpl::classname
static std::string classname()
Definition: joint-revolute.hpp:834
pinocchio::JointDataRevoluteTpl::U
U_t U
Definition: joint-revolute.hpp:718
pinocchio::JointRZ
JointRevoluteTpl< context::Scalar, context::Options, 2 > JointRZ
Definition: joint-revolute.hpp:879
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 2 > >::Constraint
JointMotionSubspaceRevoluteTpl< S2, O2, 2 > Constraint
Definition: joint-revolute.hpp:612
pinocchio::JointModelRevoluteTpl::hasConfigurationLimitInTangent
const std::vector< bool > hasConfigurationLimitInTangent() const
Definition: joint-revolute.hpp:782
pinocchio::MotionRevoluteTpl::plain
PlainReturnType plain() const
Definition: joint-revolute.hpp:261
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::ActionMatrixType
traits< PlainType >::ActionMatrixType ActionMatrixType
Definition: joint-revolute.hpp:86
pinocchio::JointModelBase
Definition: joint-model-base.hpp:75
pinocchio::JointDataRevoluteTpl::joint_v
TangentVector_t joint_v
Definition: joint-revolute.hpp:710
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 1 > >::Inertia
InertiaTpl< S1, O1 > Inertia
Definition: joint-revolute.hpp:590
pinocchio::MultiplicationOp< Eigen::MatrixBase< M6Like >, JointMotionSubspaceRevoluteTpl< S2, O2, axis > >::ReturnType
M6Like::ConstColXpr ReturnType
Definition: joint-revolute.hpp:633
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::StDiagonalMatrixSOperationReturnType
ReducedSquaredMatrix::IdentityReturnType StDiagonalMatrixSOperationReturnType
Definition: joint-revolute.hpp:425
pinocchio::ConstraintForceOp
Return type of the Constraint::Transpose * Force operation.
Definition: joint-motion-subspace-base.hpp:46
pinocchio::idx_v
int idx_v(const JointModelTpl< Scalar, Options, JointCollectionTpl > &jmodel)
Visit a JointModelTpl through JointIdxVVisitor to get the index in the full model tangent space corre...
pinocchio::Options
Options
Definition: joint-configuration.hpp:1082
y
y
pinocchio::JointMotionSubspaceBase
Definition: joint-motion-subspace-base.hpp:59
pinocchio::MotionRevoluteTpl::m_w
Scalar m_w
Definition: joint-revolute.hpp:356
pinocchio::SE3GroupAction< JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > >::ReturnType
Eigen::Matrix< Scalar, 6, 1, Options > ReturnType
Definition: joint-revolute.hpp:381
pinocchio::id
JointIndex id(const JointModelTpl< Scalar, Options, JointCollectionTpl > &jmodel)
Visit a JointModelTpl through JointIdVisitor to get the index of the joint in the kinematic chain.
PINOCCHIO_EIGEN_CONST_CAST
#define PINOCCHIO_EIGEN_CONST_CAST(TYPE, OBJ)
Macro for an automatic const_cast.
Definition: eigen-macros.hpp:51
pinocchio::SE3Tpl< Scalar, Options >
pinocchio::SE3GroupAction::ReturnType
D ReturnType
Definition: spatial/se3.hpp:41
pinocchio::JointDataBase
Definition: joint-data-base.hpp:161
pinocchio::MotionAlgebraAction< JointMotionSubspaceRevoluteTpl< Scalar, Options, axis >, MotionDerived >::ReturnType
Eigen::Matrix< Scalar, 6, 1, Options > ReturnType
Definition: joint-revolute.hpp:387
pinocchio::ConstraintForceSetOp< JointMotionSubspaceRevoluteTpl< Scalar, Options, axis >, ForceSet >::ReturnType
Eigen::MatrixBase< ForceSet >::ConstRowXpr ReturnType
Definition: joint-revolute.hpp:400
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::HomogeneousMatrixType
traits< PlainType >::HomogeneousMatrixType HomogeneousMatrixType
Definition: joint-revolute.hpp:87
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 1 > >::run
static ReturnType run(const Inertia &Y, const Constraint &)
Definition: joint-revolute.hpp:593
pinocchio::impl::LhsMultiplicationOp< Eigen::MatrixBase< M6Like >, JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > >::ReturnType
MultiplicationOp< Eigen::MatrixBase< M6Like >, Constraint >::ReturnType ReturnType
Definition: joint-revolute.hpp:646
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::JointModelDerived
JointModelRevoluteTpl< Scalar, Options, axis > JointModelDerived
Definition: joint-revolute.hpp:670
pinocchio::JointDataRevoluteTpl::StU
D_t StU
Definition: joint-revolute.hpp:721
pinocchio::TransformRevoluteTpl::cos
Scalar & cos()
Definition: joint-revolute.hpp:171
pinocchio::PINOCCHIO_EIGEN_REF_CONST_TYPE
PINOCCHIO_EIGEN_REF_CONST_TYPE(Matrix6Like) operator*(const Eigen
Definition: joint-free-flyer.hpp:144
ref
list ref
pinocchio::JointDataRX
JointDataRevoluteTpl< context::Scalar, context::Options, 0 > JointDataRX
Definition: joint-revolute.hpp:872
pinocchio::JointModelRX
JointModelRevoluteTpl< context::Scalar, context::Options, 0 > JointModelRX
Definition: joint-revolute.hpp:873
setup.data
data
Definition: cmake/cython/setup.in.py:48
inertia.hpp
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::AngularRef
Matrix3 AngularRef
Definition: joint-revolute.hpp:81
pinocchio::JointMotionSubspaceRevoluteTpl::TransposeConst::operator*
ConstraintForceOp< JointMotionSubspaceRevoluteTpl, ForceDerived >::ReturnType operator*(const ForceDense< ForceDerived > &f) const
Definition: joint-revolute.hpp:491
pinocchio::MotionRevoluteTpl::angularRate
const Scalar & angularRate() const
Definition: joint-revolute.hpp:345
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::Matrix4
Eigen::Matrix< Scalar, 4, 4, Options > Matrix4
Definition: joint-revolute.hpp:44
pinocchio::MotionDense
Definition: context/casadi.hpp:36
pinocchio::MotionRevoluteTpl::motionAction
EIGEN_STRONG_INLINE void motionAction(const MotionDense< M1 > &v, MotionDense< M2 > &mout) const
Definition: joint-revolute.hpp:324
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::HomogeneousMatrixType
Matrix4 HomogeneousMatrixType
Definition: joint-revolute.hpp:53
pinocchio::python::Scalar
context::Scalar Scalar
Definition: admm-solver.cpp:29
pinocchio::operator+
MotionDerived::MotionPlain operator+(const MotionHelicalUnalignedTpl< S1, O1 > &m1, const MotionDense< MotionDerived > &m2)
Definition: joint-helical-unaligned.hpp:211
boost
pinocchio::JointDataRevoluteTpl::Dinv
D_t Dinv
Definition: joint-revolute.hpp:719
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::JointDataDerived
JointDataRevoluteTpl< Scalar, Options, axis > JointDataDerived
Definition: joint-revolute.hpp:669
PINOCCHIO_JOINT_TYPEDEF_TEMPLATE
#define PINOCCHIO_JOINT_TYPEDEF_TEMPLATE(Joint)
Definition: joint-model-base.hpp:54
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::ConstLinearRef
const typedef Vector3::ConstantReturnType ConstLinearRef
Definition: joint-revolute.hpp:85
pinocchio::ConstraintForceOp::ReturnType
ReturnTypeNotDefined ReturnType
Definition: joint-motion-subspace-base.hpp:48
pinocchio::traits< JointDataRevoluteTpl< _Scalar, _Options, axis > >::JointDerived
JointRevoluteTpl< _Scalar, _Options, axis > JointDerived
Definition: joint-revolute.hpp:690
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::U_t
Eigen::Matrix< Scalar, 6, NV, Options > U_t
Definition: joint-revolute.hpp:677
pinocchio::JointDataRevoluteTpl::shortname
std::string shortname() const
Definition: joint-revolute.hpp:739
pinocchio::JointModelRevoluteTpl::createData
JointDataDerived createData() const
Definition: joint-revolute.hpp:768
pinocchio::res
ReturnType res
Definition: spatial/classic-acceleration.hpp:57
pinocchio::JointModelRevoluteTpl::calc_aba
void calc_aba(JointDataDerived &data, const Eigen::MatrixBase< VectorLike > &armature, const Eigen::MatrixBase< Matrix6Like > &I, const bool update_I) const
Definition: joint-revolute.hpp:819
pinocchio::JointDataRevoluteTpl::v
Motion_t v
Definition: joint-revolute.hpp:714
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:76
pinocchio::SINCOS
void SINCOS(const S1 &a, S2 *sa, S3 *ca)
Computes sin/cos values of a given input scalar.
Definition: sincos.hpp:27
pinocchio::SE3GroupAction< MotionRevoluteTpl< Scalar, Options, axis > >::ReturnType
MotionTpl< Scalar, Options > ReturnType
Definition: joint-revolute.hpp:25
pinocchio::MotionAlgebraAction
Return type of the ation of a Motion onto an object of type D.
Definition: spatial/motion.hpp:45
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 2 > >::Inertia
InertiaTpl< S1, O1 > Inertia
Definition: joint-revolute.hpp:611
pinocchio::JointModelRevoluteTpl::getMotionAxis
Vector3 getMotionAxis() const
Definition: joint-revolute.hpp:843
pinocchio::MotionRevoluteTpl::MOTION_TYPEDEF_TPL
EIGEN_MAKE_ALIGNED_OPERATOR_NEW MOTION_TYPEDEF_TPL(MotionRevoluteTpl)
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::AngularType
Vector3 AngularType
Definition: joint-revolute.hpp:48
pinocchio::impl::LhsMultiplicationOp
Definition: binary-op.hpp:20
autodiff-rnea.f
f
Definition: autodiff-rnea.py:24
pinocchio::Blank
Blank type.
Definition: fwd.hpp:76
pinocchio::MotionRevoluteTpl::MotionRevoluteTpl
MotionRevoluteTpl(const Eigen::MatrixBase< Vector1Like > &v)
Definition: joint-revolute.hpp:254
pinocchio::MotionDense::linear
ConstLinearType linear() const
Definition: motion-base.hpp:36
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::ActionMatrixType
Matrix6 ActionMatrixType
Definition: joint-revolute.hpp:52
pinocchio::JointRevoluteTpl
Definition: joint-revolute.hpp:546
pinocchio::SE3GroupAction
Definition: spatial/se3.hpp:39
pinocchio::MotionZeroTpl
Definition: context/casadi.hpp:23
PINOCCHIO_JOINT_DATA_BASE_DEFAULT_ACCESSOR
#define PINOCCHIO_JOINT_DATA_BASE_DEFAULT_ACCESSOR
Definition: joint-data-base.hpp:55
pinocchio::MotionAlgebraAction::ReturnType
D ReturnType
Definition: spatial/motion.hpp:47
pinocchio::JointModelRY
JointModelRevoluteTpl< context::Scalar, context::Options, 1 > JointModelRY
Definition: joint-revolute.hpp:877
pinocchio::JointModelRevoluteTpl::calc
EIGEN_DONT_INLINE void calc(JointDataDerived &data, const typename Eigen::MatrixBase< ConfigVector > &qs, const typename Eigen::MatrixBase< TangentVector > &vs) const
Definition: joint-revolute.hpp:807
pinocchio::TransformRevoluteTpl::TransformRevoluteTpl
TransformRevoluteTpl(const Scalar &sin, const Scalar &cos)
Definition: joint-revolute.hpp:105
pinocchio::python::context::Symmetric3
Symmetric3Tpl< Scalar, Options > Symmetric3
Definition: bindings/python/context/generic.hpp:59
pinocchio::JointDataRZ
JointDataRevoluteTpl< context::Scalar, context::Options, 2 > JointDataRZ
Definition: joint-revolute.hpp:880
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::Vector3
Eigen::Matrix< Scalar, 3, 1, Options > Vector3
Definition: joint-revolute.hpp:78
pinocchio::JointDataRevoluteTpl::joint_q
PINOCCHIO_JOINT_DATA_BASE_DEFAULT_ACCESSOR ConfigVector_t joint_q
Definition: joint-revolute.hpp:709
pinocchio::TransformRevoluteTpl::sin
Scalar & sin()
Definition: joint-revolute.hpp:162
pinocchio::JointMotionSubspaceRevoluteTpl::TransposeConst::operator*
ConstraintForceSetOp< JointMotionSubspaceRevoluteTpl, Derived >::ReturnType operator*(const Eigen::MatrixBase< Derived > &F) const
[CRBA] MatrixBase operator* (Constraint::Transpose S, ForceSet::Block)
Definition: joint-revolute.hpp:499
pinocchio::ConstraintForceSetOp::ReturnType
ReturnTypeNotDefined ReturnType
Definition: joint-motion-subspace-base.hpp:55
simulation-contact-dynamics.S
S
Definition: simulation-contact-dynamics.py:80
pinocchio::MotionRevoluteTpl::se3Action_impl
void se3Action_impl(const SE3Tpl< S2, O2 > &m, MotionDense< D2 > &v) const
Definition: joint-revolute.hpp:290
reachable-workspace-with-collisions.alpha
float alpha
Definition: reachable-workspace-with-collisions.py:162
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 0 > >::Constraint
JointMotionSubspaceRevoluteTpl< S2, O2, 0 > Constraint
Definition: joint-revolute.hpp:570
pinocchio::JointMotionSubspaceRevoluteTpl::TransposeConst
Definition: joint-revolute.hpp:481
pinocchio::JointDataRevoluteTpl::UDinv
UD_t UDinv
Definition: joint-revolute.hpp:720
pinocchio::MotionRevoluteTpl::CartesianAxis3
Axis::CartesianAxis3 CartesianAxis3
Definition: joint-revolute.hpp:242
pinocchio::JointDataRY
JointDataRevoluteTpl< context::Scalar, context::Options, 1 > JointDataRY
Definition: joint-revolute.hpp:876
pinocchio::TransformRevoluteTpl::_setRotation
void _setRotation(typename PlainType::AngularRef &rot) const
Definition: joint-revolute.hpp:202
pinocchio::MotionAlgebraAction< MotionRevoluteTpl< Scalar, Options, axis >, MotionDerived >::ReturnType
MotionTpl< Scalar, Options > ReturnType
Definition: joint-revolute.hpp:31
pinocchio::traits< JointModelRevoluteTpl< _Scalar, _Options, axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:698
pinocchio::JointMotionSubspaceRevoluteTpl::nv_impl
int nv_impl() const
Definition: joint-revolute.hpp:476
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::D_t
Eigen::Matrix< Scalar, NV, NV, Options > D_t
Definition: joint-revolute.hpp:678
pinocchio::TransformRevoluteTpl::cos
const Scalar & cos() const
Definition: joint-revolute.hpp:167
pinocchio::MotionRevoluteTpl::motionAction
MotionPlain motionAction(const MotionDense< M1 > &v) const
Definition: joint-revolute.hpp:334
pinocchio::joint_v
JointDataTpl< Scalar, Options, JointCollectionTpl >::TangentVector_t joint_v(const JointDataTpl< Scalar, Options, JointCollectionTpl > &jdata)
Visit a JointDataVariant through JointConfigVisitor to get the joint velocity vector.
pinocchio::JointRY
JointRevoluteTpl< context::Scalar, context::Options, 1 > JointRY
Definition: joint-revolute.hpp:875
pinocchio::TransformRevoluteTpl::TransformRevoluteTpl
TransformRevoluteTpl()
Definition: joint-revolute.hpp:102
pinocchio::JointModelRevoluteTpl::calc
EIGEN_DONT_INLINE void calc(JointDataDerived &data, const typename Eigen::MatrixBase< ConfigVector > &qs) const
Definition: joint-revolute.hpp:789
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::PlainReturnType
MotionPlain PlainReturnType
Definition: joint-revolute.hpp:55
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::JointMotion
MotionRevoluteTpl< Scalar, Options, axis > JointMotion
Definition: joint-revolute.hpp:417
pinocchio::JointMotionSubspaceRevoluteTpl::Axis
SpatialAxis< ANGULAR+axis > Axis
Definition: joint-revolute.hpp:440
pinocchio::JointDataRevoluteTpl
Definition: multibody/joint/fwd.hpp:35
pinocchio::TransformRevoluteTpl::setValues
void setValues(const OtherScalar &sin, const OtherScalar &cos)
Definition: joint-revolute.hpp:177
pinocchio::JointMotionSubspaceRevoluteTpl::se3ActionInverse
SE3GroupAction< JointMotionSubspaceRevoluteTpl >::ReturnType se3ActionInverse(const SE3Tpl< S1, O1 > &m) const
Definition: joint-revolute.hpp:465
axis-label.hpp
pinocchio::TransformRevoluteTpl
Definition: joint-revolute.hpp:64
pinocchio::JointModelRZ
JointModelRevoluteTpl< context::Scalar, context::Options, 2 > JointModelRZ
Definition: joint-revolute.hpp:881
joint-base.hpp
x
x
pinocchio::calc
void calc(const ConstraintModelTpl< Scalar, Options, ConstraintCollectionTpl > &cmodel, ConstraintDataTpl< Scalar, Options, ConstraintCollectionTpl > &cdata, const ModelTpl< Scalar, Options, JointCollectionTpl > &model, const DataTpl< Scalar, Options, JointCollectionTpl > &data)
Definition: constraint-model-visitor.hpp:155
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::Vector3
Eigen::Matrix< Scalar, 3, 1, Options > Vector3
Definition: joint-revolute.hpp:42
pinocchio::JointMotionSubspaceRevoluteTpl::TransposeConst::ref
const JointMotionSubspaceRevoluteTpl & ref
Definition: joint-revolute.hpp:483
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::JointForce
Eigen::Matrix< Scalar, 1, 1, Options > JointForce
Definition: joint-revolute.hpp:418
pinocchio::TransformRevoluteTpl::plain
PlainType plain() const
Definition: joint-revolute.hpp:111
pinocchio::SE3GroupAction< TransformRevoluteTpl< Scalar, Options, axis > >::ReturnType
traits< TransformRevoluteTpl< Scalar, Options, axis > >::PlainType ReturnType
Definition: joint-revolute.hpp:93
pinocchio::TransformRevoluteTpl::sin
const Scalar & sin() const
Definition: joint-revolute.hpp:158
pinocchio::JointMotionSubspaceRevoluteTpl::se3Action
SE3GroupAction< JointMotionSubspaceRevoluteTpl >::ReturnType se3Action(const SE3Tpl< S1, O1 > &m) const
Definition: joint-revolute.hpp:454
pinocchio::setIndexes
void setIndexes(JointModelTpl< Scalar, Options, JointCollectionTpl > &jmodel, JointIndex id, int q, int v)
Visit a JointModelTpl through JointSetIndexesVisitor to set the indexes of the joint in the kinematic...
M
M
axis
axis
ur5x4.w
w
Definition: ur5x4.py:50
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::MotionPlain
MotionTpl< Scalar, Options > MotionPlain
Definition: joint-revolute.hpp:54
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 1 > >::Constraint
JointMotionSubspaceRevoluteTpl< S2, O2, 1 > Constraint
Definition: joint-revolute.hpp:591
pinocchio::JointDataRevoluteTpl::JointDataRevoluteTpl
JointDataRevoluteTpl()
Definition: joint-revolute.hpp:723
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::PlainType
SE3Tpl< Scalar, Options > PlainType
Definition: joint-revolute.hpp:77
pinocchio::JointModelRevoluteTpl::JointModelRevoluteTpl
JointModelRevoluteTpl()
Definition: joint-revolute.hpp:773
PINOCCHIO_JOINT_DATA_TYPEDEF_TEMPLATE
#define PINOCCHIO_JOINT_DATA_TYPEDEF_TEMPLATE(Joint)
Definition: joint-data-base.hpp:50
pinocchio::JointDataRevoluteTpl::M
Transformation_t M
Definition: joint-revolute.hpp:713
pinocchio::JointModelRevoluteTpl
Definition: multibody/joint/fwd.hpp:33
pinocchio::MotionRevoluteTpl::MotionRevoluteTpl
MotionRevoluteTpl(const Scalar &w)
Definition: joint-revolute.hpp:248
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::TangentVector_t
Eigen::Matrix< Scalar, NV, 1, Options > TangentVector_t
Definition: joint-revolute.hpp:682
pinocchio::MotionRevoluteTpl::isEqual_impl
bool isEqual_impl(const MotionRevoluteTpl &other) const
Definition: joint-revolute.hpp:350
pinocchio::JointMotionSubspaceRevoluteTpl::isEqual
bool isEqual(const JointMotionSubspaceRevoluteTpl &) const
Definition: joint-revolute.hpp:538
pinocchio::ForceSetTpl
Definition: force-set.hpp:14
pinocchio::v
JointCollectionTpl const Eigen::MatrixBase< ConfigVectorType > const Eigen::MatrixBase< TangentVectorType > & v
Definition: joint-configuration.hpp:1084
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::Transformation_t
TransformRevoluteTpl< Scalar, Options, axis > Transformation_t
Definition: joint-revolute.hpp:672
pinocchio::internal::comparison_eq
bool comparison_eq(const LhsType &lhs_value, const RhsType &rhs_value)
Definition: utils/static-if.hpp:120
pinocchio::TransformRevoluteTpl::se3action
SE3GroupAction< TransformRevoluteTpl >::ReturnType se3action(const SE3Tpl< S2, O2 > &m) const
Definition: joint-revolute.hpp:125
pinocchio::ConstraintForceSetOp
Return type of the Constraint::Transpose * ForceSet operation.
Definition: joint-motion-subspace-base.hpp:53
pinocchio::TransformRevoluteTpl::PINOCCHIO_SE3_TYPEDEF_TPL
EIGEN_MAKE_ALIGNED_OPERATOR_NEW PINOCCHIO_SE3_TYPEDEF_TPL(TransformRevoluteTpl)
pinocchio::ConstraintForceOp< JointMotionSubspaceRevoluteTpl< Scalar, Options, axis >, ForceDerived >::ReturnType
ForceDense< ForceDerived >::ConstAngularType::template ConstFixedSegmentReturnType< 1 >::Type ReturnType
Definition: joint-revolute.hpp:394
pinocchio::JointModelRevoluteTpl::JointDerived
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef JointRevoluteTpl< _Scalar, _Options, axis > JointDerived
Definition: joint-revolute.hpp:757
joint-motion-subspace.hpp
pinocchio::JointDataRevoluteTpl::c
Bias_t c
Definition: joint-revolute.hpp:715
pinocchio::SE3Base
Base class for rigid transformation.
Definition: se3-base.hpp:30
pinocchio::JointMotionSubspaceRevoluteTpl::JointMotionSubspaceRevoluteTpl
JointMotionSubspaceRevoluteTpl()
Definition: joint-revolute.hpp:442
ocp.U
U
Definition: ocp.py:80
pinocchio::JointDataRevoluteTpl::JointDerived
EIGEN_MAKE_ALIGNED_OPERATOR_NEW typedef JointRevoluteTpl< _Scalar, _Options, axis > JointDerived
Definition: joint-revolute.hpp:705
pinocchio::JointDataRevoluteTpl::S
Constraint_t S
Definition: joint-revolute.hpp:712
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::LinearRef
Vector3::ConstantReturnType LinearRef
Definition: joint-revolute.hpp:84
pinocchio::JointRevoluteTpl::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:548
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::ConstLinearType
const typedef Vector3 ConstLinearType
Definition: joint-revolute.hpp:51
pinocchio::ForceDense
Definition: context/casadi.hpp:34
spatial-axis.hpp
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::Motion_t
MotionRevoluteTpl< Scalar, Options, axis > Motion_t
Definition: joint-revolute.hpp:673
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 2 > >::ReturnType
MultiplicationOp< Inertia, Constraint >::ReturnType ReturnType
Definition: joint-revolute.hpp:613
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::Constraint_t
JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > Constraint_t
Definition: joint-revolute.hpp:671
pinocchio::JointMotionSubspaceRevoluteTpl
Definition: joint-revolute.hpp:376
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::DenseBase
Eigen::Matrix< Scalar, 6, 1, Options > DenseBase
Definition: joint-revolute.hpp:419
pinocchio::MotionRevoluteTpl::MotionRevoluteTpl
MotionRevoluteTpl()
Definition: joint-revolute.hpp:244
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:37
pinocchio::operator^
EIGEN_STRONG_INLINE MotionDerived::MotionPlain operator^(const MotionDense< MotionDerived > &m1, const MotionHelicalUnalignedTpl< S2, O2 > &m2)
Definition: joint-helical-unaligned.hpp:220
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::Scalar
_Scalar Scalar
Definition: joint-revolute.hpp:406
pinocchio::MotionRevoluteTpl::se3Action_impl
MotionPlain se3Action_impl(const SE3Tpl< S2, O2 > &m) const
Definition: joint-revolute.hpp:297
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 0 > >::Inertia
InertiaTpl< S1, O1 > Inertia
Definition: joint-revolute.hpp:569
pinocchio::impl::LhsMultiplicationOp< Eigen::MatrixBase< M6Like >, JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > >::Constraint
JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > Constraint
Definition: joint-revolute.hpp:644
PINOCCHIO_CONSTRAINT_TYPEDEF_TPL
#define PINOCCHIO_CONSTRAINT_TYPEDEF_TPL(DERIVED)
Definition: joint-motion-subspace-base.hpp:36
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::AngularType
Matrix3 AngularType
Definition: joint-revolute.hpp:80
pinocchio::JointMotionSubspaceRevoluteTpl::TransposeConst::TransposeConst
TransposeConst(const JointMotionSubspaceRevoluteTpl &ref)
Definition: joint-revolute.hpp:484
Y
Y
pinocchio::MotionRevoluteTpl::angularRate
Scalar & angularRate()
Definition: joint-revolute.hpp:341
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::LinearType
Vector3::ConstantReturnType LinearType
Definition: joint-revolute.hpp:83
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::ConstAngularType
const typedef Vector3 ConstAngularType
Definition: joint-revolute.hpp:50
pinocchio::impl::LhsMultiplicationOp< Eigen::MatrixBase< M6Like >, JointMotionSubspaceRevoluteTpl< Scalar, Options, axis > >::run
static ReturnType run(const Eigen::MatrixBase< M6Like > &Y, const Constraint &)
Definition: joint-revolute.hpp:648
pinocchio::MultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, axis > >::ReturnType
Eigen::Matrix< S2, 6, 1, O2 > ReturnType
Definition: joint-revolute.hpp:560
pinocchio::TransformRevoluteTpl::m_cos
Scalar m_cos
Definition: joint-revolute.hpp:201
pinocchio::MotionRevoluteTpl::se3ActionInverse_impl
MotionPlain se3ActionInverse_impl(const SE3Tpl< S2, O2 > &m) const
Definition: joint-revolute.hpp:316
pinocchio::traits
Common traits structure to fully define base classes for CRTP.
Definition: fwd.hpp:71
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::Bias_t
MotionZeroTpl< Scalar, Options > Bias_t
Definition: joint-revolute.hpp:674
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 0 > >::ReturnType
MultiplicationOp< Inertia, Constraint >::ReturnType ReturnType
Definition: joint-revolute.hpp:571
pinocchio::MotionRevoluteTpl::se3ActionInverse_impl
void se3ActionInverse_impl(const SE3Tpl< S2, O2 > &m, MotionDense< D2 > &v) const
Definition: joint-revolute.hpp:305
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::ReducedSquaredMatrix
Eigen::Matrix< Scalar, 1, 1, Options > ReducedSquaredMatrix
Definition: joint-revolute.hpp:420
pinocchio::MotionRevoluteTpl::setTo
void setTo(MotionDense< MotionDerived > &m) const
Definition: joint-revolute.hpp:273
PINOCCHIO_EIGEN_REF_TYPE
#define PINOCCHIO_EIGEN_REF_TYPE(D)
Definition: eigen-macros.hpp:32
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::MatrixReturnType
DenseBase MatrixReturnType
Definition: joint-revolute.hpp:422
pinocchio::JointModelRevoluteTpl::shortname
std::string shortname() const
Definition: joint-revolute.hpp:838
pinocchio::JointMotionSubspaceTransposeBase
Definition: joint-motion-subspace-base.hpp:185
pinocchio::MotionTpl< Scalar, Options >
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 2 > >::run
static ReturnType run(const Inertia &Y, const Constraint &)
Definition: joint-revolute.hpp:614
pinocchio::CastType
Type of the cast of a class C templated by Scalar and Options, to a new NewScalar type....
Definition: fwd.hpp:99
dcrba.NV
NV
Definition: dcrba.py:536
pinocchio::TransformRevoluteTpl::m_sin
Scalar m_sin
Definition: joint-revolute.hpp:201
dpendulum.NQ
int NQ
Definition: dpendulum.py:9
pinocchio::traits< JointRevoluteTpl< _Scalar, _Options, axis > >::UD_t
Eigen::Matrix< Scalar, 6, NV, Options > UD_t
Definition: joint-revolute.hpp:679
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::LinearType
Vector3 LinearType
Definition: joint-revolute.hpp:49
pinocchio::impl::LhsMultiplicationOp< InertiaTpl< S1, O1 >, JointMotionSubspaceRevoluteTpl< S2, O2, 1 > >::ReturnType
MultiplicationOp< Inertia, Constraint >::ReturnType ReturnType
Definition: joint-revolute.hpp:592
meshcat-viewer.qs
qs
Definition: meshcat-viewer.py:128
pinocchio::traits< MotionRevoluteTpl< _Scalar, _Options, axis > >::Matrix6
Eigen::Matrix< Scalar, 6, 6, Options > Matrix6
Definition: joint-revolute.hpp:45
pinocchio::MotionRef
Definition: context/casadi.hpp:38
pinocchio::SpatialAxis
Definition: spatial-axis.hpp:16
pinocchio::traits< TransformRevoluteTpl< _Scalar, _Options, _axis > >::ConstAngularRef
Matrix3 ConstAngularRef
Definition: joint-revolute.hpp:82
pinocchio::JointMotionSubspaceRevoluteTpl::__mult__
JointMotion __mult__(const Eigen::MatrixBase< Vector1Like > &v) const
Definition: joint-revolute.hpp:447
pinocchio::MotionRevoluteTpl::addTo
void addTo(MotionDense< MotionDerived > &v) const
Definition: joint-revolute.hpp:283
pinocchio::MotionDense::angular
ConstAngularType angular() const
Definition: motion-base.hpp:32
pinocchio::JointModelRevoluteTpl::Vector3
Eigen::Matrix< Scalar, 3, 1, _Options > Vector3
Definition: joint-revolute.hpp:766
pinocchio::CastType< NewScalar, JointModelRevoluteTpl< Scalar, Options, axis > >::type
JointModelRevoluteTpl< NewScalar, Options, axis > type
Definition: joint-revolute.hpp:749
pinocchio::CartesianAxis::alphaCross
static void alphaCross(const Scalar &s, const Eigen::MatrixBase< V3_in > &vin, const Eigen::MatrixBase< V3_out > &vout)
pinocchio
Main pinocchio namespace.
Definition: timings.cpp:27
pinocchio::JointModelRevoluteTpl::cast
JointModelRevoluteTpl< NewScalar, Options, axis > cast() const
Definition: joint-revolute.hpp:861
pinocchio::traits< JointMotionSubspaceRevoluteTpl< _Scalar, _Options, axis > >::ConstMatrixReturnType
const typedef DenseBase ConstMatrixReturnType
Definition: joint-revolute.hpp:423
pinocchio::CartesianAxis
Definition: cartesian-axis.hpp:14


pinocchio
Author(s):
autogenerated on Sun Dec 22 2024 03:41:11