pymomentum-cpu 0.1.82.post0__cp313-cp313-macosx_14_0_arm64.whl → 0.1.83.post0__cp313-cp313-macosx_14_0_arm64.whl

include/momentum/math/online_householder_qr.h

@@ -10,14 +10,14 @@
 #include <momentum/common/checks.h>
 
 #include <Eigen/Core>
-#include <gsl/span>
+#include <span>
 
 #include <deque>
 #include <vector>
 
 namespace momentum {
 
-void validateColumnIndices(gsl::span<const Eigen::Index> colIndices, Eigen::Index maxEntry);
+void validateColumnIndices(std::span<const Eigen::Index> colIndices, Eigen::Index maxEntry);
 
 // Remaps the matrix such that A_new.col(i) = A_orig.col(colIndices[i]).
 // This can be used to perform QR on a subset of the matrix columns.
@@ -28,7 +28,7 @@ class ColumnIndexedMatrix {
 
   explicit ColumnIndexedMatrix(Eigen::Ref<MatrixType> mat) : mat_(mat), useColumnIndices_(false) {}
 
-  explicit ColumnIndexedMatrix(Eigen::Ref<MatrixType> mat, gsl::span<const Eigen::Index> colIndices)
+  explicit ColumnIndexedMatrix(Eigen::Ref<MatrixType> mat, std::span<const Eigen::Index> colIndices)
       : mat_(mat), columnIndices_(colIndices), useColumnIndices_(true) {
     validateColumnIndices(colIndices, mat.cols());
   }
@@ -53,7 +53,7 @@ class ColumnIndexedMatrix {
     }
   }
 
-  [[nodiscard]] gsl::span<const Eigen::Index> columnIndices() const {
+  [[nodiscard]] std::span<const Eigen::Index> columnIndices() const {
     return columnIndices_;
   }
 
@@ -71,7 +71,7 @@ class ColumnIndexedMatrix {
 
  private:
   Eigen::Ref<MatrixType> mat_;
-  gsl::span<const Eigen::Index> columnIndices_;
+  std::span<const Eigen::Index> columnIndices_;
   bool useColumnIndices_;
 };
 

include/momentum/math/transform.h

@@ -216,8 +216,8 @@ using TransformListT =
 
 template <typename T>
 TransformT<T> blendTransforms(
-    gsl::span<const TransformT<T>> transforms,
-    gsl::span<const T> weights);
+    std::span<const TransformT<T>> transforms,
+    std::span<const T> weights);
 
 /// Spherical linear interpolation between two transforms
 template <typename T>

include/momentum/math/types.h

@@ -26,7 +26,7 @@
 #pragma warning(pop)
 #endif
 
-#include <gsl/gsl>
+#include <span>
 
 //------------------------------------------------------------------------------
 // Define some additional Eigen types
@@ -401,29 +401,29 @@ using ColorArray = Matrix3Xb;
 constexpr size_t kMaxModelParams = 2048; // at most 2048 parameters per frame
 using ParameterSet = std::bitset<kMaxModelParams>;
 
-/// @brief A utility struct that facilitates the deduction of a `gsl::span` type from a given type.
+/// @brief A utility struct that facilitates the deduction of a `std::span` type from a given type.
 ///
-/// This utility is particularly useful when a function accepts a `gsl::span<Vector3<T>>` as an
-/// argument, where the template argument of `gsl::span` is also a template. In such cases, direct
-/// deduction of the `gsl::span` type from other container types (e.g., `std::vector<Vector3<T>>`)
+/// This utility is particularly useful when a function accepts a `std::span<Vector3<T>>` as an
+/// argument, where the template argument of `std::span` is also a template. In such cases, direct
+/// deduction of the `std::span` type from other container types (e.g., `std::vector<Vector3<T>>`)
 /// at the call site may fail.
 ///
-/// By using this utility, the appropriate `gsl::span` type can be deduced automatically, ensuring
+/// By using this utility, the appropriate `std::span` type can be deduced automatically, ensuring
 /// smoother function calls and enhancing code readability.
 ///
 /// Example usage:
 /// @code
-/// void foo(DeduceSpanType<Vector3f>::type points); // Equivalent to gsl::span<Vector3f>
+/// void foo(DeduceSpanType<Vector3f>::type points); // Equivalent to std::span<Vector3f>
 ///
 /// std::vector<Vector3f> points;
 /// foo(points);                                     // This line will compile without any issues.
 /// @endcode
 ///
-/// @note The `gsl::span` generated by this utility gives a mutable view into the sequence. If an
-/// immutable view is needed, consider using `gsl::span<const T>` instead.
+/// @note The `std::span` generated by this utility gives a mutable view into the sequence. If an
+/// immutable view is needed, consider using `std::span<const T>` instead.
 template <typename T>
 struct DeduceSpanType {
-  using type = gsl::span<T>;
+  using type = std::span<T>;
 };
 
 /// Casts the scalar type of objects in a container that support the `cast<>()` method.

include/momentum/math/utility.h

@@ -208,8 +208,8 @@ Vector3<T> quaternionToEuler(const Quaternion<T>& q);
 /// @param w Optional weights for each quaternion (defaults to equal weights)
 /// @return The average quaternion
 Quaternionf quaternionAverage(
-    gsl::span<const Quaternionf> q,
-    gsl::span<const float> w = std::vector<float>());
+    std::span<const Quaternionf> q,
+    std::span<const float> w = std::vector<float>());
 
 /// Returns the closest points on two line segments where the line segments are represented in
 /// origin and direction

include/momentum/rasterizer/rasterizer.h

@@ -15,8 +15,8 @@
 #include <momentum/rasterizer/geometry.h>
 #include <momentum/rasterizer/tensor.h>
 #include <Eigen/Geometry>
-#include <gsl/span>
 #include <optional>
+#include <span>
 
 namespace momentum::rasterizer {
 
@@ -227,7 +227,7 @@ void rasterizeMesh(
 /// depthOffset Depth offset for layered rendering @param imageOffset Pixel offset for comparative
 /// rendering
 void rasterizeLines(
-    gsl::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3f> positions_world,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
     float nearClip,
@@ -240,7 +240,7 @@ void rasterizeLines(
 
 /// Rasterize 3D line segments (flat array version)
 ///
-/// @see rasterizeLines(gsl::span<const Eigen::Vector3f>&, const Camera&, const Eigen::Matrix4f&,
+/// @see rasterizeLines(std::span<const Eigen::Vector3f>&, const Camera&, const Eigen::Matrix4f&,
 /// float, const Eigen::Vector3f&, float, Span2f, Span3f, float, const Eigen::Vector2f&)
 ///
 /// @param positions_world Flat array of 3D positions (x1,y1,z1,x2,y2,z2,...)
@@ -276,7 +276,7 @@ void rasterizeLines(
 /// @param depthOffset Depth offset for layered rendering
 /// @param imageOffset Pixel offset for comparative rendering
 void rasterizeCircles(
-    gsl::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3f> positions_world,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
     float nearClip,
@@ -291,7 +291,7 @@ void rasterizeCircles(
 
 /// Rasterize 3D circles (flat array version)
 ///
-/// @see rasterizeCircles(gsl::span<const Eigen::Vector3f>, const Camera&, const Eigen::Matrix4f&,
+/// @see rasterizeCircles(std::span<const Eigen::Vector3f>, const Camera&, const Eigen::Matrix4f&,
 /// float, const std::optional<Eigen::Vector3f>&, const std::optional<Eigen::Vector3f>&, float,
 /// float, Span2f, Span3f, float, const Eigen::Vector2f&)
 ///
@@ -322,11 +322,11 @@ void rasterizeCircles(
 /// @param normals_world Vector of 3D vertex normals in world space
 /// @param triangles Vector of triangles with uint32 indices
 void rasterizeMesh(
-    gsl::span<const Eigen::Vector3f> positions_world,
-    gsl::span<const Eigen::Vector3f> normals_world,
-    gsl::span<const Eigen::Matrix<uint32_t, 3, 1>> triangles,
-    gsl::span<const Eigen::Vector2f> textureCoords,
-    gsl::span<const Eigen::Matrix<uint32_t, 3, 1>> textureTriangles,
+    std::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3f> normals_world,
+    std::span<const Eigen::Matrix<uint32_t, 3, 1>> triangles,
+    std::span<const Eigen::Vector2f> textureCoords,
+    std::span<const Eigen::Matrix<uint32_t, 3, 1>> textureTriangles,
     const Eigen::Ref<const Eigen::VectorXf>& perVertexDiffuseColor,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
@@ -379,11 +379,11 @@ void rasterizeMesh(
 /// @param normals_world Vector of 3D vertex normals in world space
 /// @param triangles Vector of triangles with int32 indices
 void rasterizeMesh(
-    gsl::span<const Eigen::Vector3f> positions_world,
-    gsl::span<const Eigen::Vector3f> normals_world,
-    gsl::span<const Eigen::Vector3i> triangles,
-    gsl::span<const Eigen::Vector2f> textureCoords,
-    gsl::span<const Eigen::Vector3i> textureTriangles,
+    std::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3f> normals_world,
+    std::span<const Eigen::Vector3i> triangles,
+    std::span<const Eigen::Vector2f> textureCoords,
+    std::span<const Eigen::Vector3i> textureTriangles,
     const Eigen::Ref<const Eigen::VectorXf>& perVertexDiffuseColor,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
@@ -418,8 +418,8 @@ void rasterizeMesh(
 /// @param depthOffset Depth offset for layered rendering
 /// @param imageOffset Pixel offset for comparative rendering
 void rasterizeWireframe(
-    gsl::span<const Eigen::Vector3f> positions_world,
-    gsl::span<const Eigen::Vector3i> triangles,
+    std::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3i> triangles,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
     float nearClip,
@@ -433,7 +433,7 @@ void rasterizeWireframe(
 
 /// Rasterize mesh wireframe (flat array version)
 ///
-/// @see rasterizeWireframe(gsl::span<const Eigen::Vector3f>, gsl::span<const Eigen::Vector3i>,
+/// @see rasterizeWireframe(std::span<const Eigen::Vector3f>, std::span<const Eigen::Vector3i>,
 /// const Camera&, const Eigen::Matrix4f&, float, const Eigen::Vector3f&, float, Span2f, Span3f,
 /// bool, float, const Eigen::Vector2f&)
 ///
@@ -473,8 +473,8 @@ void rasterizeWireframe(
 /// @param depthOffset Depth offset for layered rendering
 /// @param imageOffset Pixel offset for comparative rendering
 void rasterizeSplats(
-    gsl::span<const Eigen::Vector3f> positions_world,
-    gsl::span<const Eigen::Vector3f> normals_world,
+    std::span<const Eigen::Vector3f> positions_world,
+    std::span<const Eigen::Vector3f> normals_world,
     const Camera& camera,
     const Eigen::Matrix4f& modelMatrix,
     float nearClip,
@@ -499,7 +499,7 @@ void rasterizeSplats(
 /// pixels @param rgbBuffer Input/output RGB color buffer @param zBuffer **Optional** depth buffer
 /// (fills with zeros when provided) @param imageOffset Pixel offset for positioning
 void rasterizeLines2D(
-    gsl::span<const Eigen::Vector2f> positions_image,
+    std::span<const Eigen::Vector2f> positions_image,
     const Eigen::Vector3f& color,
     float thickness,
     Span3f rgbBuffer,
@@ -508,7 +508,7 @@ void rasterizeLines2D(
 
 /// Rasterize 2D line segments (flat array version)
 ///
-/// @see rasterizeLines2D(gsl::span<const Eigen::Vector2f>, const Eigen::Vector3f&, float, Span3f,
+/// @see rasterizeLines2D(std::span<const Eigen::Vector2f>, const Eigen::Vector3f&, float, Span3f,
 /// Span2f, const Eigen::Vector2f&)
 ///
 /// @param positions_image Flat array of 2D positions (x1,y1,x2,y2,...)
@@ -537,7 +537,7 @@ void rasterizeLines2D(
 /// @param zBuffer **Optional** depth buffer (fills with zeros when provided)
 /// @param imageOffset Pixel offset for positioning
 void rasterizeCircles2D(
-    gsl::span<const Eigen::Vector2f> positions_image,
+    std::span<const Eigen::Vector2f> positions_image,
     const std::optional<Eigen::Vector3f>& lineColor,
     const std::optional<Eigen::Vector3f>& fillColor,
     float lineThickness,
@@ -548,7 +548,7 @@ void rasterizeCircles2D(
 
 /// Rasterize 2D circles (flat array version)
 ///
-/// @see rasterizeCircles2D(gsl::span<const Eigen::Vector2f>, const std::optional<Eigen::Vector3f>&,
+/// @see rasterizeCircles2D(std::span<const Eigen::Vector2f>, const std::optional<Eigen::Vector3f>&,
 /// const std::optional<Eigen::Vector3f>&, float, float, Span3f, Span2f, const Eigen::Vector2f&)
 ///
 /// @param positions_image Flat array of 2D positions (x1,y1,x2,y2,...)

lib/cmake/axel/axelTargets.cmake

@@ -59,7 +59,7 @@ endif()
 add_library(axel::axel STATIC IMPORTED)
 
 set_target_properties(axel::axel PROPERTIES
-  INTERFACE_COMPILE_FEATURES "cxx_std_17"
+  INTERFACE_COMPILE_FEATURES "cxx_std_20"
   INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
   INTERFACE_LINK_LIBRARIES "Eigen3::Eigen;Microsoft.GSL::GSL;Dispenso::dispenso;drjit"
 )

{pymomentum_cpu-0.1.82.post0.dist-info → pymomentum_cpu-0.1.83.post0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymomentum-cpu
-Version: 0.1.82.post0
+Version: 0.1.83.post0
 Summary: A library providing foundational algorithms for human kinematic motion and numerical optimization solvers to apply human motion in various applications (CPU-only version for Linux, macOS Intel, and macOS ARM)
 Keywords: kinematics,motion,optimization,human-motion,inverse-kinematics,forward-kinematics,body-tracking,motion-capture,character-animation,robotics,cpu
 Author-Email: Meta Reality Labs Research <jeongseok@meta.com>
@@ -66,9 +66,11 @@ numerical optimization solvers to apply human motion in various applications.
 Pre-built binaries are available for Windows, macOS, and Linux:
 
 ```bash
-# Python (PyPI)
-pip install pymomentum-cpu      # CPU version
-pip install pymomentum-gpu      # GPU version with CUDA
+# Python (PyPI) - uv preferred over pip
+uv add pymomentum-cpu           # CPU version
+uv add pymomentum-gpu           # GPU version with CUDA
+pip install pymomentum-cpu      # Alternative: using pip
+pip install pymomentum-gpu
 
 # Python (Conda/Pixi)
 pixi add pymomentum             # Auto-detects GPU/CPU