Struct CuKinematicChain 

pub struct CuKinematicChain<const N: usize> { /* private fields */ }

Compile-time sized $N$-DOF serial robot kinematic chain.

Example

use repose_kinematics::{CuJointAxis, CuJointLimits, CuJointSpec, CuKinematicChain};
use cu_spatial_payloads::Transform3D;
use cu29::units::si::angle::radian;
use cu29::units::si::angular_velocity::radian_per_second;
use cu29::units::si::f64::{Angle, AngularVelocity, Length};
use cu29::units::si::length::meter;

let m = Length::new::<meter>;
let rad = Angle::new::<radian>;
let chain = CuKinematicChain::new([CuJointSpec::revolute(
    [m(0.0), m(0.0), m(0.1)],
    [rad(0.0); 3],
    CuJointAxis::PosZ,
    CuJointLimits::revolute(
        rad(-core::f64::consts::PI),
        rad(core::f64::consts::PI),
        AngularVelocity::new::<radian_per_second>(2.0),
    ),
)])
.with_tool_offset(Transform3D::<f64>::from_translation_euler_xyz([m(0.0), m(0.0), m(0.05)], [rad(0.0); 3]));
chain.validate().unwrap();
let mut ee = Transform3D::<f64>::identity();
chain.forward_kinematics(&[Angle::new::<radian>(0.0).into()], &mut ee).unwrap();
assert!((ee.to_matrix()[2][3] - 0.15).abs() < 1e-12);

Implementations

impl<const N: usize> CuKinematicChain<N>

pub const fn new(joints: [CuJointSpec; N]) -> Self

Creates a serial kinematic chain with an identity tool offset.

pub const fn with_tool_offset(self, tool_offset: Transform3D<f64>) -> Self

Replaces the flange-to-tool transform (builder form of Self::set_tool_offset).

pub fn validate(&self) -> CuResult<()>

Checks that every joint has finite origins, a valid axis, and well-formed limits.

pub const fn joints(&self) -> &[CuJointSpec; N]

Borrows the static joint specifications.

pub const fn tool_offset(&self) -> &Transform3D<f64>

Borrows the flange-to-tool transform.

pub fn set_tool_offset(&mut self, tool_offset: Transform3D<f64>)

Sets the flange-to-tool transform.

pub fn is_within_limits(&self, q: &[CuJointPosition; N]) -> bool

Returns true if every joint angle in q satisfies its joint limits.

pub fn clamp_to_limits(&self, q: &mut [CuJointPosition; N]) -> CuResult<()>

Clamps each joint angle in q in place to its configured limits.

pub fn forward_kinematics( &self, q: &[CuJointPosition; N], out: &mut Transform3D<f64>, ) -> CuResult<()>

Computes the base-to-tool forward kinematics transform in place.

pub fn forward_frames( &self, q: &[CuJointPosition; N], out_frames: &mut [Transform3D<f64>; N], out_ee: &mut Transform3D<f64>, ) -> CuResult<()>

Computes every intermediate link frame (0..N) and the final end-effector frame in place.

pub fn geometric_jacobian( &self, q: &[CuJointPosition; N], out_jacobian: &mut [[f64; N]; 6], ) -> CuResult<()>

Computes the $6 \times N$ geometric space Jacobian in the base frame in place.

Rows 0..3 correspond to linear velocity $[v_x, v_y, v_z]^T$ in $\text{m/s}$ and rows 3..6 correspond to angular velocity $[\omega_x, \omega_y, \omega_z]^T$ in $\text{rad/s}$, both measured at the tool origin and expressed in the base frame.

pub fn body_jacobian( &self, q: &[CuJointPosition; N], out_jacobian: &mut [[f64; N]; 6], ) -> CuResult<()>

Computes the $6 \times N$ geometric body Jacobian in the end-effector (tool) frame in place.

Rows 0..3 correspond to linear velocity $[v_x, v_y, v_z]^T$ in $\text{m/s}$ and rows 3..6 correspond to angular velocity $[\omega_x, \omega_y, \omega_z]^T$ in $\text{rad/s}$, both measured at the tool origin and expressed in the end-effector frame.

impl<const N: usize> CuKinematicChain<N>

pub fn manipulability_squared(&self, q: &[CuJointPosition; N]) -> CuResult<f64>

Computes Yoshikawa’s manipulability index squared $w^2 = \max(0, \det(J J^T))$ at q.

pub fn differential_ik( &self, q: &[CuJointPosition; N], twist: &CuTwist6D, cfg: &CuDiffIkParams, out_qd: &mut [CuJointVelocity; N], ) -> CuResult<CuDiffIkStatus>

Computes joint velocities out_qd in place for a desired 6D Cartesian twist using singularity-robust and joint-limit-aware damped least squares.

pub fn inverse_kinematics_dls( &self, target: &Transform3D<f64>, seed: &[CuJointPosition; N], cfg: &CuIkParams, out_q: &mut [CuJointPosition; N], ) -> CuResult<CuIkStatus>

Solves inverse kinematics in place using Damped Least-Squares (DLS).

Writes the resulting joint configuration into out_q without heap allocation.

Trait Implementations

impl<const N: usize> Clone for CuKinematicChain<N>

fn clone(&self) -> CuKinematicChain<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Copy for CuKinematicChain<N>

impl<const N: usize> Debug for CuKinematicChain<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for CuKinematicChain<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> From<CuKinematicChain<N>> for CuChainSpec<N>

fn from(chain: CuKinematicChain<N>) -> Self

Converts to this type from the input type.

impl<const N: usize> PartialEq for CuKinematicChain<N>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<const N: usize> Serialize for CuKinematicChain<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> TypePath for CuKinematicChain<N>

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>