Struct dds_bridge::Deal

pub struct Deal(pub [Hand; 4]);

A deal of four hands

Tuple Fields

0: [Hand; 4]

Implementations

impl Deal

pub fn new(rng: &mut (impl Rng + ?Sized)) -> Self

Create a deal from a shuffled standard 52-card deck

Examples found in repository

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

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

    let histogram = dds::solve_deals(&deals, dds::StrainFlags::NOTRUMP)?
        .into_iter()
        .map(|table| table[dds::Strain::Notrump])
        .fold(Histogram::default(), |mut acc, row| {
            let (n, e, s, w) = (
                usize::from(row.get(dds::Seat::North)),
                usize::from(row.get(dds::Seat::East)),
                usize::from(row.get(dds::Seat::South)),
                usize::from(row.get(dds::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 display(self, seat: Seat) -> impl Display

PBN-compatible display from a seat’s perspective

Examples found in repository

examples/compute-hot-deals/main.rs (line 66)

fn main() -> Result<ExitCode, dds::Error> {
    let deals = match std::env::args().nth(1) {
        Some(string) => {
            if let Ok(n) = string.parse::<usize>() {
                n
            } else {
                eprintln!("{}", include_str!("README.md"));
                return Ok(ExitCode::FAILURE);
            }
        }
        None => 1,
    };

    for _ in 0..deals {
        let (deal, tricks) = compute_deal(&mut rand::thread_rng())?;
        println!(
            "{} {:X}",
            deal.display(dds::Seat::North),
            tricks.hex(dds::Seat::North, dds::Strain::SYS)
        );
    }

    Ok(ExitCode::SUCCESS)
}

pub fn shuffled(self, rng: &mut (impl Rng + ?Sized), seats: SeatFlags) -> Self

Shuffle existing hands while preserving the numbers of cards

Trait Implementations

impl Clone for Deal

fn clone(&self) -> Deal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Deal

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

Formats the value using the given formatter.

impl Default for Deal

fn default() -> Deal

Returns the “default value” for a type.

impl From<Deal> for ddTableDeal

fn from(deal: Deal) -> Self

Converts to this type from the input type.

impl Hash for Deal

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 Index<Seat> for Deal

type Output = Hand

The returned type after indexing.

fn index(&self, seat: Seat) -> &Hand

Performs the indexing (container[index]) operation.

impl IndexMut<Seat> for Deal

fn index_mut(&mut self, seat: Seat) -> &mut Hand

Performs the mutable indexing (container[index]) operation.

impl PartialEq for Deal

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

impl Eq for Deal

impl StructuralPartialEq for Deal