jaxsim 0.5.1.dev147__py3-none-any.whl → 0.5.1.dev160__py3-none-any.whl

jaxsim/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.1.dev147'
-__version_tuple__ = version_tuple = (0, 5, 1, 'dev147')
+__version__ = version = '0.5.1.dev160'
+__version_tuple__ = version_tuple = (0, 5, 1, 'dev160')

jaxsim/api/model.py

@@ -736,152 +736,149 @@ def generalized_free_floating_jacobian_derivative(
     # Compute the base transform.
     W_H_B = data.base_transform()
 
-    @functools.partial(jax.vmap, in_axes=(0, None, None, 0))
-    def _compute_row(
-        B_H_L: jtp.Matrix,
-        B_J_full_WL_B: jtp.Matrix,
-        W_H_B: jtp.Matrix,
-        κb: jtp.Matrix,
-    ) -> jtp.Matrix:
+    # We add the 5 columns of ones to the Jacobian derivative to account for the
+    # base velocity and acceleration (5 + number of links = 6 + number of joints).
+    B_J̇_WL_B = (
+        jnp.hstack([jnp.ones((κb.shape[0], 5)), κb])[:, jnp.newaxis] * B_J̇_full_WX_B
+    )
+    B_J_WL_B = (
+        jnp.hstack([jnp.ones((κb.shape[0], 5)), κb])[:, jnp.newaxis] * B_J_full_WL_B
+    )
 
-        # =====================================================
-        # Compute quantities to adjust the input representation
-        # =====================================================
+    # =====================================================
+    # Compute quantities to adjust the input representation
+    # =====================================================
 
-        In = jnp.eye(model.dofs())
-        On = jnp.zeros(shape=(model.dofs(), model.dofs()))
+    In = jnp.eye(model.dofs())
+    On = jnp.zeros(shape=(model.dofs(), model.dofs()))
 
-        # Extract the link quantities using the boolean support body array.
-        B_J̇_WL_B = jnp.hstack([jnp.ones(5), κb]) * B_J̇_full_WX_B
-        B_J_WL_B = jnp.hstack([jnp.ones(5), κb]) * B_J_full_WL_B
+    match data.velocity_representation:
 
-        match data.velocity_representation:
+        case VelRepr.Inertial:
 
-            case VelRepr.Inertial:
+            B_X_W = jaxsim.math.Adjoint.from_transform(transform=W_H_B, inverse=True)
 
-                B_X_W = jaxsim.math.Adjoint.from_transform(
-                    transform=W_H_B, inverse=True
-                )
+            W_v_WB = data.base_velocity()
+            B_Ẋ_W = -B_X_W @ jaxsim.math.Cross.vx(W_v_WB)
 
-                W_v_WB = data.base_velocity()
-                B_Ẋ_W = -B_X_W @ jaxsim.math.Cross.vx(W_v_WB)
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_W, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_W, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_W, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_W, On)
+        case VelRepr.Body:
 
-            case VelRepr.Body:
+            B_X_B = jaxsim.math.Adjoint.from_rotation_and_translation(
+                translation=jnp.zeros(3), rotation=jnp.eye(3)
+            )
 
-                B_X_B = jaxsim.math.Adjoint.from_rotation_and_translation(
-                    translation=jnp.zeros(3), rotation=jnp.eye(3)
-                )
+            B_Ẋ_B = jnp.zeros(shape=(6, 6))
 
-                B_Ẋ_B = jnp.zeros(shape=(6, 6))
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_B, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_B, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_B, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_B, On)
+        case VelRepr.Mixed:
 
-            case VelRepr.Mixed:
+            BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
+            B_X_BW = jaxsim.math.Adjoint.from_transform(transform=BW_H_B, inverse=True)
 
-                BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
-                B_X_BW = jaxsim.math.Adjoint.from_transform(
-                    transform=BW_H_B, inverse=True
-                )
+            BW_v_WB = data.base_velocity()
+            BW_v_W_BW = BW_v_WB.at[3:6].set(jnp.zeros(3))
 
-                BW_v_WB = data.base_velocity()
-                BW_v_W_BW = BW_v_WB.at[3:6].set(jnp.zeros(3))
+            BW_v_BW_B = BW_v_WB - BW_v_W_BW
+            B_Ẋ_BW = -B_X_BW @ jaxsim.math.Cross.vx(BW_v_BW_B)
 
-                BW_v_BW_B = BW_v_WB - BW_v_W_BW
-                B_Ẋ_BW = -B_X_BW @ jaxsim.math.Cross.vx(BW_v_BW_B)
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_BW, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_BW, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_BW, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_BW, On)
+        case _:
+            raise ValueError(data.velocity_representation)
 
-            case _:
-                raise ValueError(data.velocity_representation)
+    # ======================================================
+    # Compute quantities to adjust the output representation
+    # ======================================================
 
-        # ======================================================
-        # Compute quantities to adjust the output representation
-        # ======================================================
+    match output_vel_repr:
 
-        match output_vel_repr:
+        case VelRepr.Inertial:
 
-            case VelRepr.Inertial:
+            O_X_B = W_X_B = jaxsim.math.Adjoint.from_transform(transform=W_H_B)
 
-                O_X_B = W_X_B = jaxsim.math.Adjoint.from_transform(transform=W_H_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
+            O_Ẋ_B = W_Ẋ_B = W_X_B @ jaxsim.math.Cross.vx(B_v_WB)  # noqa: F841
 
-                O_Ẋ_B = W_Ẋ_B = W_X_B @ jaxsim.math.Cross.vx(B_v_WB)  # noqa: F841
+        case VelRepr.Body:
 
-            case VelRepr.Body:
+            O_X_B = L_X_B = jaxsim.math.Adjoint.from_transform(
+                transform=B_H_L, inverse=True
+            )
 
-                O_X_B = L_X_B = jaxsim.math.Adjoint.from_transform(
-                    transform=B_H_L, inverse=True
-                )
+            B_X_L = jaxsim.math.Adjoint.inverse(adjoint=L_X_B)
 
-                B_X_L = jaxsim.math.Adjoint.inverse(adjoint=L_X_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
+                L_v_WL = jnp.einsum(
+                    "b6j,j->b6", L_X_B @ B_J_WL_B, data.generalized_velocity()
+                )
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
-                    L_v_WL = L_X_B @ B_J_WL_B @ data.generalized_velocity()
+            O_Ẋ_B = L_Ẋ_B = -L_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
+                jnp.einsum("bij,bj->bi", B_X_L, L_v_WL) - B_v_WB
+            )
 
-                O_Ẋ_B = L_Ẋ_B = -L_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
-                    B_X_L @ L_v_WL - B_v_WB
-                )
+        case VelRepr.Mixed:
 
-            case VelRepr.Mixed:
+            W_H_L = W_H_B @ B_H_L
+            LW_H_L = W_H_L.at[:, 0:3, 3].set(jnp.zeros_like(W_H_L[:, 0:3, 3]))
+            LW_H_B = LW_H_L @ jaxsim.math.Transform.inverse(B_H_L)
 
-                W_H_L = W_H_B @ B_H_L
-                LW_H_L = W_H_L.at[0:3, 3].set(jnp.zeros(3))
-                LW_H_B = LW_H_L @ jaxsim.math.Transform.inverse(B_H_L)
+            O_X_B = LW_X_B = jaxsim.math.Adjoint.from_transform(transform=LW_H_B)
 
-                O_X_B = LW_X_B = jaxsim.math.Adjoint.from_transform(transform=LW_H_B)
+            B_X_LW = jaxsim.math.Adjoint.inverse(adjoint=LW_X_B)
 
-                B_X_LW = jaxsim.math.Adjoint.inverse(adjoint=LW_X_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
+            with data.switch_velocity_representation(VelRepr.Mixed):
+                BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
+                B_X_BW = Adjoint.from_transform(transform=BW_H_B, inverse=True)
+                LW_v_WL = jnp.einsum(
+                    "bij,bj->bi",
+                    LW_X_B,
+                    B_J_WL_B
+                    @ jax.scipy.linalg.block_diag(B_X_BW, jnp.eye(model.dofs()))
+                    @ data.generalized_velocity(),
+                )
 
-                with data.switch_velocity_representation(VelRepr.Mixed):
-                    BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
-                    B_X_BW = Adjoint.from_transform(transform=BW_H_B, inverse=True)
-                    LW_v_WL = LW_X_B @ (
-                        B_J_WL_B
-                        @ jax.scipy.linalg.block_diag(B_X_BW, jnp.eye(model.dofs()))
-                        @ data.generalized_velocity()
-                    )
-                    LW_v_W_LW = LW_v_WL.at[3:6].set(jnp.zeros(3))
+                LW_v_W_LW = LW_v_WL.at[:, 3:6].set(jnp.zeros_like(LW_v_WL[:, 3:6]))
 
-                LW_v_LW_L = LW_v_WL - LW_v_W_LW
-                LW_v_B_LW = LW_v_WL - LW_X_B @ B_v_WB - LW_v_LW_L
+            LW_v_LW_L = LW_v_WL - LW_v_W_LW
+            LW_v_B_LW = LW_v_WL - jnp.einsum("bij,j->bi", LW_X_B, B_v_WB) - LW_v_LW_L
 
-                O_Ẋ_B = LW_Ẋ_B = -LW_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
-                    B_X_LW @ LW_v_B_LW
-                )
-            case _:
-                raise ValueError(output_vel_repr)
+            O_Ẋ_B = LW_Ẋ_B = -LW_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
+                jnp.einsum("bij,bj->bi", B_X_LW, LW_v_B_LW)
+            )
 
-        # =============================================================
-        # Express the Jacobian derivative in the target representations
-        # =============================================================
+        case _:
+            raise ValueError(output_vel_repr)
 
-        # Sum all the components that form the Jacobian derivative in the target
-        # input/output velocity representations.
-        O_J̇_WL_I = jnp.zeros(shape=(6, 6 + model.dofs()))
-        O_J̇_WL_I += O_Ẋ_B @ B_J_WL_B @ T
-        O_J̇_WL_I += O_X_B @ B_J̇_WL_B @ T
-        O_J̇_WL_I += O_X_B @ B_J_WL_B @ Ṫ
+    # =============================================================
+    # Express the Jacobian derivative in the target representations
+    # =============================================================
 
-        return O_J̇_WL_I
+    # Sum all the components that form the Jacobian derivative in the target
+    # input/output velocity representations.
+    O_J̇_WL_I = jnp.zeros_like(B_J̇_WL_B)
+    O_J̇_WL_I += O_Ẋ_B @ B_J_WL_B @ T
+    O_J̇_WL_I += O_X_B @ B_J̇_WL_B @ T
+    O_J̇_WL_I += O_X_B @ B_J_WL_B @ Ṫ
 
-    return _compute_row(B_H_L, B_J_full_WL_B, W_H_B, κb)
+    return O_J̇_WL_I
 
 
 @functools.partial(jax.jit, static_argnames=["prefer_aba"])

jaxsim/math/adjoint.py

@@ -56,14 +56,13 @@ class Adjoint:
             The 6x6 adjoint matrix.
         """
 
-        A_H_B = jnp.array(transform).astype(float)
-        assert transform.shape == (4, 4)
+        A_H_B = jnp.reshape(transform, (-1, 4, 4))
 
         return (
             jaxlie.SE3.from_matrix(matrix=A_H_B).adjoint()
             if not inverse
             else jaxlie.SE3.from_matrix(matrix=A_H_B).inverse().adjoint()
-        )
+        ).reshape(transform.shape[:-2] + (6, 6))
 
     @staticmethod
     def from_rotation_and_translation(
@@ -145,13 +144,18 @@ class Adjoint:
         Returns:
             jtp.Matrix: The inverse adjoint matrix.
         """
-        A_X_B = adjoint
+        A_X_B = adjoint.reshape(-1, 6, 6)
 
-        A_R_B = A_X_B[0:3, 0:3]
+        A_R_B_T = jnp.swapaxes(A_X_B[..., 0:3, 0:3], -2, -1)
+        A_T_B = A_X_B[..., 0:3, 3:6]
 
-        return jnp.vstack(
+        return jnp.concatenate(
             [
-                jnp.block([A_R_B.T, -A_R_B.T @ A_X_B[0:3, 3:6] @ A_R_B.T]),
-                jnp.block([jnp.zeros(shape=(3, 3)), A_R_B.T]),
-            ]
-        )
+                jnp.concatenate(
+                    [A_R_B_T, -A_R_B_T @ A_T_B @ A_R_B_T],
+                    axis=-1,
+                ),
+                jnp.concatenate([jnp.zeros_like(A_R_B_T), A_R_B_T], axis=-1),
+            ],
+            axis=-2,
+        ).reshape(adjoint.shape)

jaxsim/math/cross.py

@@ -24,13 +24,18 @@ class Cross:
         Raises:
             ValueError: If the input vector does not have a size of 6.
         """
-        v, ω = jnp.split(velocity_sixd.squeeze(), 2)
+        velocity_sixd = velocity_sixd.reshape(-1, 6)
 
-        v_cross = jnp.vstack(
+        v, ω = jnp.split(velocity_sixd, 2, axis=-1)
+
+        v_cross = jnp.concatenate(
             [
-                jnp.block([Skew.wedge(vector=ω), Skew.wedge(vector=v)]),
-                jnp.block([jnp.zeros(shape=(3, 3)), Skew.wedge(vector=ω)]),
-            ]
+                jnp.concatenate(
+                    [Skew.wedge(ω), jnp.zeros((ω.shape[0], 3, 3)).squeeze()], axis=-2
+                ),
+                jnp.concatenate([Skew.wedge(v), Skew.wedge(ω)], axis=-2),
+            ],
+            axis=-1,
         )
 
         return v_cross

jaxsim/math/skew.py

@@ -20,9 +20,20 @@ class Skew:
             jtp.Matrix: The skew-symmetric matrix corresponding to the input vector.
 
         """
-        vector = vector.squeeze()
-        x, y, z = vector
-        skew = jnp.array([[0, -z, y], [z, 0, -x], [-y, x, 0]])
+
+        vector = vector.reshape(-1, 3)
+
+        x, y, z = jnp.split(vector, 3, axis=-1)
+
+        skew = jnp.stack(
+            [
+                jnp.concatenate([jnp.zeros_like(x), -z, y], axis=-1),
+                jnp.concatenate([z, jnp.zeros_like(x), -x], axis=-1),
+                jnp.concatenate([-y, x, jnp.zeros_like(x)], axis=-1),
+            ],
+            axis=-2,
+        ).squeeze()
+
         return skew
 
     @staticmethod

jaxsim/math/transform.py

@@ -92,7 +92,11 @@ class Transform:
             The 4x4 inverse transformation matrix.
         """
 
-        A_H_B = jnp.array(transform).astype(float)
-        assert A_H_B.shape == (4, 4)
+        A_H_B = jnp.reshape(transform, (-1, 4, 4))
 
-        return jaxlie.SE3.from_matrix(matrix=A_H_B).inverse().as_matrix()
+        return (
+            jaxlie.SE3.from_matrix(matrix=A_H_B)
+            .inverse()
+            .as_matrix()
+            .reshape(transform.shape[:-2] + (4, 4))
+        )

{jaxsim-0.5.1.dev147.dist-info → jaxsim-0.5.1.dev160.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jaxsim
-Version: 0.5.1.dev147
+Version: 0.5.1.dev160
 Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
 Author-email: Diego Ferigo <dgferigo@gmail.com>, Filippo Luca Ferretti <filippoluca.ferretti@outlook.com>
 Maintainer-email: Filippo Luca Ferretti <filippo.ferretti@iit.it>, Alessandro Croci <alessandro.croci@iit.it>
@@ -237,16 +237,30 @@ You can enforce GPU support, if needed, by also specifying `"jaxlib = * = *cuda*
 <details>
 <summary>With <code>pixi</code></summary>
 
-> [!NOTE]
+> ### Note
 > The minimum version of `pixi` required is `0.39.0`.
 
-You can install the default dependencies of the project using [`pixi`][pixi] as follows:
+You can add the jaxsim dependency in [`pixi`][pixi] project as follows:
 
 ```bash
-pixi install
+pixi add jaxsim
 ```
 
-See `pixi task list` for a list of available tasks.
+If you are on Linux and you want to use a `cuda`-powered version of `jax`, remember to add the appropriate line in the [`system-requirements`](https://pixi.sh/latest/reference/pixi_manifest/#the-system-requirements-table) table, i.e. adding
+
+~~~toml
+[system-requirements]
+cuda = "12"
+~~~
+
+if you are using a `pixi.toml` file or
+
+~~~toml
+[tool.pixi.system-requirements]
+cuda = "12"
+~~~
+
+if you are using a `pyproject.toml` file.
 
 </details>
 
@@ -267,7 +281,7 @@ If you need GPU support, follow the official [installation instructions][jax_gpu
 </details>
 
 <details>
-<summary>Contributors installation</summary>
+<summary>Contributors installation (with <code>conda</code>)</summary>
 
 If you want to contribute to the project, we recommend creating the following `jaxsim` conda environment first:
 
@@ -284,6 +298,22 @@ pip install --no-deps -e .
 
 </details>
 
+<details>
+<summary>Contributors installation (with <code>pixi</code>)</summary>
+
+> ### Note
+> The minimum version of `pixi` required is `0.39.0`.
+
+You can install the default dependencies of the project using [`pixi`][pixi] as follows:
+
+```bash
+pixi install
+```
+
+See `pixi task list` for a list of available tasks.
+
+</details>
+
 [conda]: https://anaconda.org/
 [pip]: https://github.com/pypa/pip/
 [pixi]: https://pixi.sh/

{jaxsim-0.5.1.dev147.dist-info → jaxsim-0.5.1.dev160.dist-info}/RECORD

@@ -1,5 +1,5 @@
 jaxsim/__init__.py,sha256=_8rbKOf3bwx-2ChEbspZxs_rZY0RqUcmWAftnEw1bfM,3401
-jaxsim/_version.py,sha256=FRAq9Ja5ETQImIOQUFNBXpAELhsbGMZ09hbzc0KN4cE,428
+jaxsim/_version.py,sha256=LFzsk7IuMCWjONW-0TMiOLJ2B9UR9fM3LGiij2F17N4,428
 jaxsim/exceptions.py,sha256=qjfTjE9lXvD3-JCPQcxxiX2XSS8QegawzQ6ZuC2tc0Y,2638
 jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=7msl8t5Jt09RNYfKdPJtpjLfWurldcycDappb045Eso,761
@@ -12,7 +12,7 @@ jaxsim/api/frame.py,sha256=d6pa6vywGDqfaJU76F_-yjLJs6R3mrjZ6B-KXPu6f3Q,14595
 jaxsim/api/joint.py,sha256=AnqlNWmBOay-gsoo0y4AbfFQ2OCJm-8T1E0IMhZeLoY,7457
 jaxsim/api/kin_dyn_parameters.py,sha256=BaOp7ICxWosDIdWVjh8-cdlX8mXM9IM8wzy2fHz8Ufc,30444
 jaxsim/api/link.py,sha256=nHjffhNdi_xGkteMsqdb_hC9mdV9rNw7k3pl89Uhw_8,12798
-jaxsim/api/model.py,sha256=LSdPk1NrBHEP4avKh3K0ANIXkPHVF1AyzZj8TfDiQ00,80162
+jaxsim/api/model.py,sha256=27U_3JxEvbCyPox76h2uxIKnpFHahxsGZCYZQy1vXf4,79859
 jaxsim/api/ode.py,sha256=XFi3gGRU2s-hqOpZEAuk7o4cxEa871V1LmGcvT5wf10,16056
 jaxsim/api/ode_data.py,sha256=ggF1AVaLW5QuXrfpNsFs-voVcW6gZkxK2Xe9GiDmou0,13755
 jaxsim/api/references.py,sha256=YkdZhRv8NoBC94qvpwn1w9_alVuxrfiZV5w5NHQIt-g,20737
@@ -21,14 +21,14 @@ jaxsim/integrators/common.py,sha256=sXc0HLmqiGluU-ffsNcAxVO-UA4QzS96pjef5N-5rHI,
 jaxsim/integrators/fixed_step.py,sha256=roiRR1evnQMPmdvY5D_iRHTYlbOvkG4CM6JDSqlmTAU,4034
 jaxsim/integrators/variable_step.py,sha256=pMYiMbaqQTlq2VF4Ca78ovxU06lMF1mrnrfzAahtvcg,24577
 jaxsim/math/__init__.py,sha256=2T1WUU_chNBCvyvkKSdiesPlckbo-gXVbCZEGoF-W0I,381
-jaxsim/math/adjoint.py,sha256=AT1iDFnryGxpulSZUpzl0kmm85fYo_3fN_smK_29mSc,4808
-jaxsim/math/cross.py,sha256=ihL1Ss2XCqf6IiaRFfu5IvAVE4txrNZt0CZEYdf_UvM,1378
+jaxsim/math/adjoint.py,sha256=ccXuF9jnMLpGhQ3vg1hu7V6zUz8D3rVMhj-bongdk9c,5019
+jaxsim/math/cross.py,sha256=brlzoThCzQAHmuHubh1N_CLtvP5asR4iWXp-I1HAYFc,1522
 jaxsim/math/inertia.py,sha256=Bh92FlJvJMMZg8825mzEzV3sHAAufJOSaQST1ZnzgSQ,1631
 jaxsim/math/joint_model.py,sha256=EzAveaG5B6ZnCFNUzN30KEQUVesd83lfWXJarYR-kUw,9989
 jaxsim/math/quaternion.py,sha256=fO3VNrIoZrcchCXCv_Zn2Ad6-rcgrNzysRrn5raQWJE,4595
 jaxsim/math/rotation.py,sha256=bl9WCbYyLKg6RyRkMaEBBTmARBs8pB-FGR0JVbfbaNE,2187
-jaxsim/math/skew.py,sha256=FeyKPMxrGzf6c4fohLR-24deYutetT1jw2r43q2yJEo,1151
-jaxsim/math/transform.py,sha256=ZIhcHa9KCxBWyDj_UTiy8qOfhavOtIaDK6aAofyx28M,3267
+jaxsim/math/skew.py,sha256=P82yeQs9Fzb7Ri_MAikcb54_06cE_syi9yPssSg4ydw,1426
+jaxsim/math/transform.py,sha256=We0ChLajSckxGINiJsP1a5Ur3yjg3JuweQ3kK4Woix4,3332
 jaxsim/math/utils.py,sha256=2id1F6QOvkHkIF3Nuxuj_tz_kI0IYlrlgVQrETmXFfI,1058
 jaxsim/mujoco/__init__.py,sha256=fZyRWre49pIhOrYdf6yJk_hOax8qWGe8OCmoq-dMVq8,201
 jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
@@ -67,8 +67,8 @@ jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=Fxa555u14VUsVlKU1rBQFurrVzBp7BNsIaVoNko0lrI,11261
 jaxsim/utils/tracing.py,sha256=Btwxdfhb7fJLk3r5PlQkGYj60Y2KbFT1gANGIA697FU,530
 jaxsim/utils/wrappers.py,sha256=3IMwydqFgmSPqeuUQ3PRmdhDc1IoT6XC23jPC_LjWXs,4175
-jaxsim-0.5.1.dev147.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.5.1.dev147.dist-info/METADATA,sha256=LYzQ___gRWAJsixXYn9lRcbioNzj4-d62a8oDIvp-tg,19484
-jaxsim-0.5.1.dev147.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jaxsim-0.5.1.dev147.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.5.1.dev147.dist-info/RECORD,,
+jaxsim-0.5.1.dev160.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.5.1.dev160.dist-info/METADATA,sha256=zujfy9xVKXUkRBBa-5weqc0q8Xy-dEEgIqjyZzidR9A,20201
+jaxsim-0.5.1.dev160.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jaxsim-0.5.1.dev160.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.5.1.dev160.dist-info/RECORD,,