Enum Observation 

pub enum Observation {
    Flat(Vec<f32>),
    Dict(Vec<(String, Vec<f32>)>),
}

A concrete observation value.

Flat is the default: a single dense vector of f32 values. Dict supports multi-modal observations (e.g. image + proprioception), stored as ordered key-value pairs of named sub-vectors.

Variants

Flat(Vec<f32>)

A flat float vector (the common case).

Dict(Vec<(String, Vec<f32>)>)

Named sub-observations in a fixed order.

Implementations

impl Observation

pub fn flat(data: Vec<f32>) -> Self

Convenience constructor matching the old tuple-struct API.

Observation::flat(vec) is equivalent to the former Observation(vec).

pub fn try_as_slice(&self) -> Option<&[f32]>

Try to view as a flat f32 slice.

Returns Some(&[f32]) for the Flat variant, None for Dict. Prefer this over as_slice when handling observations that may be either variant.

pub fn as_slice(&self) -> &[f32]

View as a flat f32 slice.

For Flat, returns the inner data directly.

Panics

Panics if the observation is the Dict variant. Use try_as_slice for a fallible alternative, or flatten if you need a contiguous copy.

pub fn into_inner(self) -> Vec<f32>

Consume and return the inner Vec for the Flat variant.

For Dict, returns a flattened (concatenated) copy.

pub fn total_dim(&self) -> usize

Total number of f32 elements across all keys.

pub fn flatten(&self) -> Vec<f32>

Flatten to a single Vec<f32> (concatenate all values in key order).

For Flat, returns a clone of the inner data. For Dict, concatenates all sub-vectors.

pub fn get(&self, key: &str) -> Option<&[f32]>

Get a named sub-observation (for the Dict variant).

Returns None for the Flat variant or if the key is not found.

Trait Implementations

impl Clone for Observation

fn clone(&self) -> Observation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Observation

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

Formats the value using the given formatter.

impl PartialEq for Observation

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Observation