mujoco 3.6.0__tar.gz → 3.7.0__tar.gz

{mujoco-3.6.0/mujoco.egg-info → mujoco-3.7.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: mujoco
-Version: 3.6.0
+Version: 3.7.0
 Summary: MuJoCo Physics Simulator
 Author-email: Google DeepMind <mujoco@deepmind.com>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/google-deepmind/mujoco
-Project-URL: Documentation, https://mujoco.readthedocs.io/en/3.6.0
+Project-URL: Documentation, https://mujoco.readthedocs.io/en/3.7.0
 Project-URL: Repository, https://github.com/google-deepmind/mujoco
-Project-URL: Changelog, https://mujoco.readthedocs.io/en/3.6.0/changelog.html
+Project-URL: Changelog, https://mujoco.readthedocs.io/en/3.7.0/changelog.html
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/CMakeLists.txt

@@ -86,7 +86,7 @@ if(NOT TARGET mujoco)
     if(MUJOCO_FRAMEWORK)
       message("MuJoCo framework is at ${MUJOCO_FRAMEWORK}/mujoco.framework")
       set(MUJOCO_LIBRARY
-          ${MUJOCO_FRAMEWORK}/mujoco.framework/Versions/A/libmujoco.3.6.0.dylib
+          ${MUJOCO_FRAMEWORK}/mujoco.framework/Versions/A/libmujoco.3.7.0.dylib
       )
       target_compile_options(mujoco INTERFACE -F${MUJOCO_FRAMEWORK})
     endif()
@@ -94,7 +94,7 @@ if(NOT TARGET mujoco)
 
   if(NOT MUJOCO_FRAMEWORK)
     find_library(
-      MUJOCO_LIBRARY mujoco mujoco.3.6.0 HINTS ${MUJOCO_LIBRARY_DIR} REQUIRED
+      MUJOCO_LIBRARY mujoco mujoco.3.7.0 HINTS ${MUJOCO_LIBRARY_DIR} REQUIRED
     )
     find_path(MUJOCO_INCLUDE mujoco/mujoco.h HINTS ${MUJOCO_INCLUDE_DIR} REQUIRED)
     message("MuJoCo is at ${MUJOCO_LIBRARY}")
@@ -193,7 +193,7 @@ findorfetch(
   GIT_REPO
   https://github.com/pybind/pybind11
   GIT_TAG
-  e86205cb2ba070755d582856430c0f83c0af6694 # v3.0.1
+  d0f1a2168f3335426f544171a3463c36edbd5cc3 # v3.0.3
   TARGETS
   pybind11::pybind11_headers
   EXCLUDE_FROM_ALL

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/bindings_test.py

@@ -1881,6 +1881,29 @@ Euler integrator, semi-implicit in velocity.
     mujoco.mj_readSensor(model, data, 0, delay, result, interp=0)
     np.testing.assert_array_equal(result, [1, 0, 0, 0])
 
+  def test_poly_stiffness(self):
+    xml = r"""
+<mujoco>
+  <worldbody>
+    <body>
+      <geom type="sphere" size="0.1"/>
+      <joint name="slide" type="slide" stiffness="1 2 3"/>
+    </body>
+  </worldbody>
+</mujoco>
+"""
+    model = mujoco.MjModel.from_xml_string(xml)
+    data = mujoco.MjData(model)
+    self.assertEqual(model.jnt_stiffness[0], 1)
+    np.testing.assert_array_equal(
+        model.jnt_stiffnesspoly[0], [2, 3])
+
+    x = 0.5
+    data.qpos[0] = x
+    mujoco.mj_forward(model, data)
+    expected = -(1*x + 2*x*abs(x) + 3*x**3)
+    np.testing.assert_allclose(data.qfrc_spring[0], expected)
+
   def _assert_attributes_equal(self, actual_obj, expected_obj, attr_to_compare):
     for name in attr_to_compare:
       actual_value = getattr(actual_obj, name)

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/callbacks.cc

@@ -91,8 +91,7 @@ static enable_if_not_const_t<Raw, py::handle> MjWrapperLookup(Raw* ptr) {
   // TODO(stunya): Figure out a way to do this without invoking py::detail.
   {
     py::gil_scoped_acquire gil;
-    const auto [src, type] =
-        py::detail::type_caster_base<MjWrapper<Raw>>::src_and_type(wrapper);
+    auto* type = py::detail::get_type_info(typeid(MjWrapper<Raw>));
     if (type) {
       py::object instance = py::reinterpret_steal<py::object>(
           py::detail::find_registered_python_instance(wrapper, type));

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/cmake/MujocoLinkOptions.cmake

@@ -43,12 +43,12 @@ function(get_mujoco_extra_link_options OUTPUT_VAR)
         endif()
       endif()
 
-      set(CMAKE_REQUIRED_FLAGS ${EXTRA_LINK_OPTIONS} "-Wl,--gc-sections")
+      set(CMAKE_REQUIRED_FLAGS "${EXTRA_LINK_OPTIONS} -Wl,--gc-sections")
       check_c_source_compiles("int main() {}" SUPPORTS_GC_SECTIONS)
       if(SUPPORTS_GC_SECTIONS)
         set(EXTRA_LINK_OPTIONS ${EXTRA_LINK_OPTIONS} -Wl,--gc-sections)
       else()
-        set(CMAKE_REQUIRED_FLAGS ${EXTRA_LINK_OPTIONS} "-Wl,-dead_strip")
+        set(CMAKE_REQUIRED_FLAGS "${EXTRA_LINK_OPTIONS} -Wl,-dead_strip")
         check_c_source_compiles("int main() {}" SUPPORTS_DEAD_STRIP)
         if(SUPPORTS_DEAD_STRIP)
           set(EXTRA_LINK_OPTIONS ${EXTRA_LINK_OPTIONS} -Wl,-dead_strip)

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/cmake/ShellTests.cmake

@@ -38,7 +38,6 @@ function(add_mujoco_shell_test TEST_NAME TARGET_BINARY)
                "CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}"
                "TARGET_BINARY=$<TARGET_FILE:${TARGET_BINARY}>"
                "TEST_TMPDIR=${TEST_TMPDIR}"
-               "MUJOCO_PLUGIN_DIR=$<TARGET_FILE_DIR:obj_decoder>"
     )
     if(WIN32)
       # Define the directory containing the mujoco DLL library so that it can be added to the PATH.

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/constants.cc

@@ -70,6 +70,7 @@ PYBIND11_MODULE(_constants, pymodule) {
   X(mjNSENS);
   X(mjNSOLVER);
   X(mjNISLAND);
+  X(mjNPOLY);
 
   // from mjvisualize.h
   X(mjNGROUP);

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/enum_traits.h

@@ -246,6 +246,7 @@ struct mjtDyn {
     std::make_pair("mjDYN_FILTER", ::mjtDyn::mjDYN_FILTER),
     std::make_pair("mjDYN_FILTEREXACT", ::mjtDyn::mjDYN_FILTEREXACT),
     std::make_pair("mjDYN_MUSCLE", ::mjtDyn::mjDYN_MUSCLE),
+    std::make_pair("mjDYN_DCMOTOR", ::mjtDyn::mjDYN_DCMOTOR),
     std::make_pair("mjDYN_USER", ::mjtDyn::mjDYN_USER)};
 };
 
@@ -256,6 +257,7 @@ struct mjtGain {
     std::make_pair("mjGAIN_FIXED", ::mjtGain::mjGAIN_FIXED),
     std::make_pair("mjGAIN_AFFINE", ::mjtGain::mjGAIN_AFFINE),
     std::make_pair("mjGAIN_MUSCLE", ::mjtGain::mjGAIN_MUSCLE),
+    std::make_pair("mjGAIN_DCMOTOR", ::mjtGain::mjGAIN_DCMOTOR),
     std::make_pair("mjGAIN_USER", ::mjtGain::mjGAIN_USER)};
 };
 
@@ -266,6 +268,7 @@ struct mjtBias {
     std::make_pair("mjBIAS_NONE", ::mjtBias::mjBIAS_NONE),
     std::make_pair("mjBIAS_AFFINE", ::mjtBias::mjBIAS_AFFINE),
     std::make_pair("mjBIAS_MUSCLE", ::mjtBias::mjBIAS_MUSCLE),
+    std::make_pair("mjBIAS_DCMOTOR", ::mjtBias::mjBIAS_DCMOTOR),
     std::make_pair("mjBIAS_USER", ::mjtBias::mjBIAS_USER)};
 };
 
@@ -539,7 +542,6 @@ struct mjtWarning {
     std::make_pair("mjWARN_INERTIA", ::mjtWarning::mjWARN_INERTIA),
     std::make_pair("mjWARN_CONTACTFULL", ::mjtWarning::mjWARN_CONTACTFULL),
     std::make_pair("mjWARN_CNSTRFULL", ::mjtWarning::mjWARN_CNSTRFULL),
-    std::make_pair("mjWARN_VGEOMFULL", ::mjtWarning::mjWARN_VGEOMFULL),
     std::make_pair("mjWARN_BADQPOS", ::mjtWarning::mjWARN_BADQPOS),
     std::make_pair("mjWARN_BADQVEL", ::mjtWarning::mjWARN_BADQVEL),
     std::make_pair("mjWARN_BADQACC", ::mjtWarning::mjWARN_BADQACC),

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/function_traits.h

@@ -198,6 +198,17 @@ struct mj_parse {
   }
 };
 
+struct mj_encode {
+  static constexpr char name[] = "mj_encode";
+  static constexpr char doc[] = "Encode spec/model to a file using a registered encoder. Returns the number of bytes written on success, -1 on failure.";
+  using type = int (const mjSpec *, const mjModel *, const char *, const char *, const mjVFS *, char *, int);
+  static constexpr auto param_names = std::make_tuple("s", "m", "filename", "content_type", "vfs", "error", "error_sz");
+
+  MUJOCO_ALWAYS_INLINE static type& GetFunc() {
+    return ::mj_encode;
+  }
+};
+
 struct mj_compile {
   static constexpr char name[] = "mj_compile";
   static constexpr char doc[] = "Compile spec to model.";
@@ -1642,7 +1653,7 @@ struct mj_objectAcceleration {
 struct mj_geomDistance {
   static constexpr char name[] = "mj_geomDistance";
   static constexpr char doc[] = "Return smallest signed distance between two geoms and optionally segment from geom1 to geom2.";
-  using type = mjtNum (const mjModel *, const mjData *, int, int, mjtNum, mjtNum (*)[6]);
+  using type = mjtNum (const mjModel *, mjData *, int, int, mjtNum, mjtNum (*)[6]);
   static constexpr auto param_names = std::make_tuple("m", "d", "geom1", "geom2", "distmax", "fromto");
 
   MUJOCO_ALWAYS_INLINE static type& GetFunc() {
@@ -4048,6 +4059,39 @@ struct mjp_findDecoder {
   }
 };
 
+struct mjp_registerEncoder {
+  static constexpr char name[] = "mjp_registerEncoder";
+  static constexpr char doc[] = "Globally register an encoder. This function is thread-safe. If an identical mjpEncoder is already registered, this function does nothing. If a non-identical mjpEncoder with the same name is already registered, an mju_error is raised.";
+  using type = void (const mjpEncoder *);
+  static constexpr auto param_names = std::make_tuple("encoder");
+
+  MUJOCO_ALWAYS_INLINE static type& GetFunc() {
+    return ::mjp_registerEncoder;
+  }
+};
+
+struct mjp_defaultEncoder {
+  static constexpr char name[] = "mjp_defaultEncoder";
+  static constexpr char doc[] = "Set default resource encoder definition.";
+  using type = void (mjpEncoder *);
+  static constexpr auto param_names = std::make_tuple("encoder");
+
+  MUJOCO_ALWAYS_INLINE static type& GetFunc() {
+    return ::mjp_defaultEncoder;
+  }
+};
+
+struct mjp_findEncoder {
+  static constexpr char name[] = "mjp_findEncoder";
+  static constexpr char doc[] = "Return the encoder that matches against the content type or filename extension. If no match, return NULL.";
+  using type = const mjpEncoder * (const char *, const char *);
+  static constexpr auto param_names = std::make_tuple("filename", "content_type");
+
+  MUJOCO_ALWAYS_INLINE static type& GetFunc() {
+    return ::mjp_findEncoder;
+  }
+};
+
 struct mju_openResource {
   static constexpr char name[] = "mju_openResource";
   static constexpr char doc[] = "Open a resource; if the name doesn't have a prefix matching a registered resource provider, then the OS filesystem is used.";
@@ -4565,6 +4609,17 @@ struct mjs_setToAdhesion {
   }
 };
 
+struct mjs_setToDCMotor {
+  static constexpr char name[] = "mjs_setToDCMotor";
+  static constexpr char doc[] = "Set actuator to DC motor; return error if any.";
+  using type = const char * (mjsActuator *, double (*)[2], double, double (*)[3], double (*)[3], double (*)[2], double (*)[3], double (*)[6], double (*)[6], double (*)[5], int);
+  static constexpr auto param_names = std::make_tuple("actuator", "motorconst", "resistance", "nominal", "saturation", "inductance", "cogging", "controller", "thermal", "lugre", "input_mode");
+
+  MUJOCO_ALWAYS_INLINE static type& GetFunc() {
+    return *reinterpret_cast<type*>(&::mjs_setToDCMotor);
+  }
+};
+
 struct mjs_addMesh {
   static constexpr char name[] = "mjs_addMesh";
   static constexpr char doc[] = "Add mesh.";

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/functions.cc

@@ -663,7 +663,7 @@ PYBIND11_MODULE(_functions, pymodule) {
   Def<traits::mj_contactForce>(pymodule);
   Def<traits::mj_geomDistance>(
       pymodule,
-      [](const raw::MjModel* m, const raw::MjData* d,
+      [](const raw::MjModel* m, raw::MjData* d,
          int geom1, int geom2, mjtNum distmax,
          std::optional<Eigen::Ref<EigenArrayXX>> fromto) {
         if (fromto.has_value() && fromto->size() != 6) {

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/indexer_xmacro.h

@@ -15,7 +15,7 @@
 #ifndef MUJOCO_PYTHON_INDEXER_XMACRO_H_
 #define MUJOCO_PYTHON_INDEXER_XMACRO_H_
 
-#include <mujoco/mjxmacro.h>
+#include <mujoco/mjxmacro.h>  // IWYU pragma: keep
 
 #define MJMODEL_ACTUATOR                                          \
   X( int,     actuator_, trntype,      nu, 1                    ) \
@@ -132,6 +132,7 @@
   X( mjtNum,  jnt_, pos,          njnt, 3               ) \
   X( mjtNum,  jnt_, axis,         njnt, 3               ) \
   X( mjtNum,  jnt_, stiffness,    njnt, 1               ) \
+  X( mjtNum,  jnt_, stiffnesspoly, njnt, mjNPOLY        ) \
   X( mjtNum,  jnt_, range,        njnt, 2               ) \
   X( mjtNum,  jnt_, margin,       njnt, 1               ) \
   X( mjtNum,  jnt_, user,         njnt, MJ_M(nuser_jnt) ) \
@@ -145,6 +146,7 @@
   X( mjtNum,  dof_, frictionloss, nv,   1               ) \
   X( mjtNum,  dof_, armature,     nv,   1               ) \
   X( mjtNum,  dof_, damping,      nv,   1               ) \
+  X( mjtNum,  dof_, dampingpoly,  nv,   mjNPOLY         ) \
   X( mjtNum,  dof_, invweight0,   nv,   1               ) \
   X( mjtNum,  dof_, M0,           nv,   1               )
 
@@ -253,7 +255,9 @@
   X( mjtNum,  tendon, _range,        ntendon, 2                  ) \
   X( mjtNum,  tendon, _margin,       ntendon, 1                  ) \
   X( mjtNum,  tendon, _stiffness,    ntendon, 1                  ) \
+  X( mjtNum,  tendon, _stiffnesspoly, ntendon, mjNPOLY           ) \
   X( mjtNum,  tendon, _damping,      ntendon, 1                  ) \
+  X( mjtNum,  tendon, _dampingpoly,  ntendon, mjNPOLY            ) \
   X( mjtNum,  tendon, _frictionloss, ntendon, 1                  ) \
   X( mjtNum,  tendon, _lengthspring, ntendon, 1                  ) \
   X( mjtNum,  tendon, _length0,      ntendon, 1                  ) \

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/introspect/codegen/generate_structs.py

@@ -41,6 +41,8 @@ _ANONYMOUS_KEY_PATTERN = re.compile(r'\d+:\d+(?=\))')
 _EXCLUDED = (
     'mjpDecoder',
     'mjpDecoder_',
+    'mjpEncoder',
+    'mjpEncoder_',
     'mjpPlugin',
     'mjpPlugin_',
     'mjpResourceProvider',

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/introspect/enums.py

@@ -263,7 +263,8 @@ ENUMS: Mapping[str, EnumDecl] = dict([
              ('mjDYN_FILTER', 2),
              ('mjDYN_FILTEREXACT', 3),
              ('mjDYN_MUSCLE', 4),
-             ('mjDYN_USER', 5),
+             ('mjDYN_DCMOTOR', 5),
+             ('mjDYN_USER', 6),
          ]),
      )),
     ('mjtGain',
@@ -274,7 +275,8 @@ ENUMS: Mapping[str, EnumDecl] = dict([
              ('mjGAIN_FIXED', 0),
              ('mjGAIN_AFFINE', 1),
              ('mjGAIN_MUSCLE', 2),
-             ('mjGAIN_USER', 3),
+             ('mjGAIN_DCMOTOR', 3),
+             ('mjGAIN_USER', 4),
          ]),
      )),
     ('mjtBias',
@@ -285,7 +287,8 @@ ENUMS: Mapping[str, EnumDecl] = dict([
              ('mjBIAS_NONE', 0),
              ('mjBIAS_AFFINE', 1),
              ('mjBIAS_MUSCLE', 2),
-             ('mjBIAS_USER', 3),
+             ('mjBIAS_DCMOTOR', 3),
+             ('mjBIAS_USER', 4),
          ]),
      )),
     ('mjtObj',
@@ -575,12 +578,11 @@ ENUMS: Mapping[str, EnumDecl] = dict([
              ('mjWARN_INERTIA', 0),
              ('mjWARN_CONTACTFULL', 1),
              ('mjWARN_CNSTRFULL', 2),
-             ('mjWARN_VGEOMFULL', 3),
-             ('mjWARN_BADQPOS', 4),
-             ('mjWARN_BADQVEL', 5),
-             ('mjWARN_BADQACC', 6),
-             ('mjWARN_BADCTRL', 7),
-             ('mjNWARNING', 8),
+             ('mjWARN_BADQPOS', 3),
+             ('mjWARN_BADQVEL', 4),
+             ('mjWARN_BADQACC', 5),
+             ('mjWARN_BADCTRL', 6),
+             ('mjNWARNING', 7),
          ]),
      )),
     ('mjtTimer',

{mujoco-3.6.0 → mujoco-3.7.0}/mujoco/introspect/functions.py

@@ -387,6 +387,57 @@ FUNCTIONS: Mapping[str, FunctionDecl] = dict([
          ),
          doc='Parse spec from a file.',
      )),
+    ('mj_encode',
+     FunctionDecl(
+         name='mj_encode',
+         return_type=ValueType(name='int'),
+         parameters=(
+             FunctionParameterDecl(
+                 name='s',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjSpec', is_const=True),
+                 ),
+             ),
+             FunctionParameterDecl(
+                 name='m',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjModel', is_const=True),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='filename',
+                 type=PointerType(
+                     inner_type=ValueType(name='char', is_const=True),
+                 ),
+             ),
+             FunctionParameterDecl(
+                 name='content_type',
+                 type=PointerType(
+                     inner_type=ValueType(name='char', is_const=True),
+                 ),
+             ),
+             FunctionParameterDecl(
+                 name='vfs',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjVFS', is_const=True),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='error',
+                 type=PointerType(
+                     inner_type=ValueType(name='char'),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='error_sz',
+                 type=ValueType(name='int'),
+             ),
+         ),
+         doc='Encode spec/model to a file using a registered encoder. Returns the number of bytes written on success, -1 on failure.',  # pylint: disable=line-too-long
+     )),
     ('mj_compile',
      FunctionDecl(
          name='mj_compile',
@@ -3626,7 +3677,7 @@ FUNCTIONS: Mapping[str, FunctionDecl] = dict([
              FunctionParameterDecl(
                  name='d',
                  type=PointerType(
-                     inner_type=ValueType(name='mjData', is_const=True),
+                     inner_type=ValueType(name='mjData'),
                  ),
              ),
              FunctionParameterDecl(
@@ -9600,6 +9651,56 @@ FUNCTIONS: Mapping[str, FunctionDecl] = dict([
          ),
          doc='Return the resource provider with the prefix that matches against the resource name. If no match, return NULL.',  # pylint: disable=line-too-long
      )),
+    ('mjp_registerEncoder',
+     FunctionDecl(
+         name='mjp_registerEncoder',
+         return_type=ValueType(name='void'),
+         parameters=(
+             FunctionParameterDecl(
+                 name='encoder',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjpEncoder', is_const=True),
+                 ),
+             ),
+         ),
+         doc='Globally register an encoder. This function is thread-safe. If an identical mjpEncoder is already registered, this function does nothing. If a non-identical mjpEncoder with the same name is already registered, an mju_error is raised.',  # pylint: disable=line-too-long
+     )),
+    ('mjp_defaultEncoder',
+     FunctionDecl(
+         name='mjp_defaultEncoder',
+         return_type=ValueType(name='void'),
+         parameters=(
+             FunctionParameterDecl(
+                 name='encoder',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjpEncoder'),
+                 ),
+             ),
+         ),
+         doc='Set default resource encoder definition.',
+     )),
+    ('mjp_findEncoder',
+     FunctionDecl(
+         name='mjp_findEncoder',
+         return_type=PointerType(
+             inner_type=ValueType(name='mjpEncoder', is_const=True),
+         ),
+         parameters=(
+             FunctionParameterDecl(
+                 name='filename',
+                 type=PointerType(
+                     inner_type=ValueType(name='char', is_const=True),
+                 ),
+             ),
+             FunctionParameterDecl(
+                 name='content_type',
+                 type=PointerType(
+                     inner_type=ValueType(name='char', is_const=True),
+                 ),
+             ),
+         ),
+         doc='Return the encoder that matches against the content type or filename extension. If no match, return NULL.',  # pylint: disable=line-too-long
+     )),
     ('mju_openResource',
      FunctionDecl(
          name='mju_openResource',
@@ -10685,6 +10786,94 @@ FUNCTIONS: Mapping[str, FunctionDecl] = dict([
          ),
          doc='Set actuator to active adhesion; return error if any.',
      )),
+    ('mjs_setToDCMotor',
+     FunctionDecl(
+         name='mjs_setToDCMotor',
+         return_type=PointerType(
+             inner_type=ValueType(name='char', is_const=True),
+         ),
+         parameters=(
+             FunctionParameterDecl(
+                 name='actuator',
+                 type=PointerType(
+                     inner_type=ValueType(name='mjsActuator'),
+                 ),
+             ),
+             FunctionParameterDecl(
+                 name='motorconst',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(2,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='resistance',
+                 type=ValueType(name='double'),
+             ),
+             FunctionParameterDecl(
+                 name='nominal',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(3,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='saturation',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(3,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='inductance',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(2,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='cogging',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(3,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='controller',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(6,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='thermal',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(6,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='lugre',
+                 type=ArrayType(
+                     inner_type=ValueType(name='double'),
+                     extents=(5,),
+                 ),
+                 nullable=True,
+             ),
+             FunctionParameterDecl(
+                 name='input_mode',
+                 type=ValueType(name='int'),
+             ),
+         ),
+         doc='Set actuator to DC motor; return error if any.',
+     )),
     ('mjs_addMesh',
      FunctionDecl(
          name='mjs_addMesh',