Struct TricksRow 

pub struct TricksRow(/* private fields */);

Tricks that each seat can take as declarer for a strain

Implementations

impl TricksRow

pub const fn new(n: u8, e: u8, s: u8, w: u8) -> Self

Create a new row from the number of tricks each seat can take

pub const fn get(self, seat: Seat) -> u8

Get the number of tricks a seat can take as declarer

Examples found in repository

examples/notrump-tricks/main.rs (line 37)

fn analyze_deals(n: usize) -> Result<(), solver::Error> {
    let deals: Vec<_> = core::iter::repeat_with(|| Deal::new(&mut rand::rng()))
        .take(n)
        .collect();

    let histogram = solver::solve_deals(&deals, solver::StrainFlags::NOTRUMP)?
        .into_iter()
        .map(|table| table[Strain::Notrump])
        .fold(Histogram::default(), |mut acc, row| {
            let (n, e, s, w) = (
                usize::from(row.get(Seat::North)),
                usize::from(row.get(Seat::East)),
                usize::from(row.get(Seat::South)),
                usize::from(row.get(Seat::West)),
            );
            acc.each[n] += 1;
            acc.each[e] += 1;
            acc.each[s] += 1;
            acc.each[w] += 1;
            acc.right[n.max(s)] += 1;
            acc.right[e.max(w)] += 1;
            acc.max[n.max(e).max(s).max(w)] += 1;
            acc
        });

    dbg!(&to_cumulative_probability(histogram.each)[6..]);
    dbg!(&to_cumulative_probability(histogram.right)[6..]);
    dbg!(&to_cumulative_probability(histogram.max)[6..]);
    Ok(())
}

pub fn hex(self, seat: Seat) -> impl UpperHex

Hexadecimal representation from a seat’s perspective

Trait Implementations

impl Clone for TricksRow

fn clone(&self) -> TricksRow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TricksRow

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

Formats the value using the given formatter.

impl Hash for TricksRow

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TricksRow

fn eq(&self, other: &TricksRow) -> 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 Copy for TricksRow

impl Eq for TricksRow

impl StructuralPartialEq for TricksRow