Struct rv::data::Partition

pub struct Partition { /* private fields */ }

Implementations

impl Partition

pub fn new() -> Partition

Empty partition

pub fn new_unchecked(z: Vec<usize>, counts: Vec<usize>) -> Self

pub fn z(&self) -> &Vec<usize>

pub fn z_mut(&mut self) -> &mut Vec<usize>

pub fn counts(&self) -> &Vec<usize>

pub fn counts_mut(&mut self) -> &mut Vec<usize>

pub fn from_z(z: Vec<usize>) -> Result<Self, PartitionError>

Create a Partition with a given assignment, z

Examples

let z1 = vec![0, 1, 2, 3, 1, 2];
let part = Partition::from_z(z1).unwrap();

assert_eq!(*part.z(), vec![0, 1, 2, 3, 1, 2]);
assert_eq!(*part.counts(), vec![1, 2, 2, 1]);

// Invalid z because k=4 is empty. All partitions must be occupied.
let z2 = vec![0, 1, 2, 3, 1, 5];
assert!(Partition::from_z(z2).is_err());

pub fn remove(&mut self, ix: usize) -> Result<(), PartitionError>

Remove the item at index ix

Example

let mut part = Partition::from_z(vec![0, 1, 0, 2]).unwrap();
part.remove(1).expect("Could not remove");

assert_eq!(*part.z(), vec![0, 0, 1]);
assert_eq!(*part.counts(), vec![2, 1]);

pub fn append(&mut self, zi: usize) -> Result<(), PartitionError>

Append a new item assigned to partition zi

Example

let mut part = Partition::from_z(vec![0, 1, 0, 2]).unwrap();
part.append(3).expect("Could not append");

assert_eq!(*part.z(), vec![0, 1, 0, 2, 3]);
assert_eq!(*part.counts(), vec![2, 1, 1, 1]);

pub fn k(&self) -> usize

Returns the number of partitions, k.

Example

let part = Partition::from_z(vec![0, 1, 0, 2]).unwrap();

assert_eq!(part.k(), 3);
assert_eq!(*part.counts(), vec![2, 1, 1]);

pub fn len(&self) -> usize

Returns the number items

pub fn is_empty(&self) -> bool

pub fn weights(&self) -> Vec<f64>

Return the partition weights (normalized counts)

Example

let part = Partition::from_z(vec![0, 1, 0, 2]).unwrap();
let weights = part.weights();

assert_eq!(weights, vec![0.5, 0.25, 0.25]);

Trait Implementations

impl Clone for Partition

fn clone(&self) -> Partition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Partition

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

Formats the value using the given formatter.

impl Default for Partition

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Partition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Partition

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

Formats the value using the given formatter.

impl From<&Partition> for String

fn from(part: &Partition) -> String

Converts to this type from the input type.

impl PartialEq for Partition

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Rv<Partition> for Crp

fn ln_f(&self, x: &Partition) -> f64

Probability function

fn draw<R: Rng>(&self, rng: &mut R) -> Partition

Single draw from the Rv

fn f(&self, x: &X) -> f64

Probability function

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<X>

Multiple draws of the Rv

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl Serialize for Partition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Support<Partition> for Crp

fn supports(&self, _x: &Partition) -> bool

Returns true if x is in the support of the Rv

impl Eq for Partition

impl StructuralPartialEq for Partition