Struct stochasta::CardDeck

source ·

pub struct CardDeck<C>where
    C: Eq + Hash + Ord,{ /* private fields */ }

Expand description

A deck of cards.

This may contain multiple cards which are equal.

Example: Uneven dice

The following code shows how to construct an uneven dice with a second one instead of a six.

use stochasta::CardDeck;
use stochasta::Probability;

let dice = CardDeck::from(vec!["1", "2", "3", "4", "5", "1"]);

assert_eq!(dice.size(), 6);
assert_eq!(dice.probability(&"1"), Probability::new(1, 3));
assert_eq!(dice.probability(&"2"), Probability::new(1, 6));
assert_eq!(dice.probability(&"5"), Probability::new(1, 6));
assert_eq!(dice.probability(&"6"), Probability::new(0, 6));

Type Parameters

C: The type of a single card

Implementations§

source §

impl<C> CardDeck<C>where C: Eq + Hash + Ord,

source

pub fn new() -> Self

Creates a new empty deck.

Example

use stochasta::CardDeck;

let cards: CardDeck<i32> = CardDeck::new();
assert_eq!(cards.is_empty(), true);

source

pub fn add(&mut self, card: C)

Adds the given card once to the deck.

Example

use stochasta::CardDeck;

let card = "demo";
let mut deck = CardDeck::new();
assert_eq!(deck.count(&card), 0);

deck.add(card);
assert_eq!(deck.count(&card), 1);

source

pub fn add_times(&mut self, card: C, n: u64)

Adds the card n times to the deck.

Example

use stochasta::CardDeck;

let card = "demo";
let mut deck = CardDeck::new();
assert_eq!(deck.count(&card), 0);

deck.add_times(card, 5);
assert_eq!(deck.count(&card), 5);

source

pub fn remove_all(&mut self, card: &C)

Removes all appearances of the given card from the deck.

Example

use stochasta::CardDeck;

let mut deck = CardDeck::from(vec![1, 3, 3]);
assert_eq!(deck.count(&3), 2);

deck.remove_all(&3);
assert_eq!(deck.count(&3), 0);

source

pub fn remove_times(&mut self, card: C, n: u64)

Removes the card n times from the deck.

If n is greater than count the amount will simply set to zero.

Example

use stochasta::CardDeck;

let mut deck = CardDeck::from(vec![3, 3, 3]);
assert_eq!(deck.count(&3), 3);

deck.remove_times(3, 2);
assert_eq!(deck.count(&3), 1);

source

pub fn set_card(&mut self, card: C, n: u64)

Sets the amount of cards to n. Will overwrite any pre-existing value.

Example

use stochasta::CardDeck;

let mut deck = CardDeck::new();
assert_eq!(deck.count(&"alpha"), 0);

deck.set_card("alpha", 10);
assert_eq!(deck.count(&"alpha"), 10);

source

pub fn is_empty(&self) -> bool

Returns true, if the deck is empty.

Example

use stochasta::CardDeck;

let cards: CardDeck<i32> = CardDeck::new();
// ...
assert_eq!(cards.is_empty(), cards.size() == 0);

source

pub fn size(&self) -> u64

Returns the number of cards in the deck.

Example

use stochasta::CardDeck;

let weird_dice = CardDeck::from(vec![1, 2, 1]);
assert_eq!(weird_dice.size(), 3);

source

pub fn probability(&self, card: &C) -> Probability

Returns the probability of an equal card to be drawn.

Example

use stochasta::Probability;
use stochasta::CardDeck;

let dice = CardDeck::from(vec!["1", "2", "3", "4", "5", "6"]);
assert_eq!(dice.probability(&"1"), Probability::new(1, 6));

source

pub fn probabilities(&self) -> HashMap<&C, Probability>

Returns the probability of the cards to be drawn.

The probabilities are guaranteed to be > 0.

Example

use std::collections::HashMap;
use stochasta::Probability;
use stochasta::CardDeck;

let coin = CardDeck::from(vec!["heads", "tails"]);
assert_eq!(
    coin.probabilities(),
    HashMap::from([
        (&"heads", Probability::new(1, 2)),
        (&"tails", Probability::new(1, 2)),
    ])
);

source

pub fn contains(&self, card: &C) -> bool

Checks whether the card is contained at least once in the deck.

Example

use stochasta::CardDeck;

let card = "demo";
let mut deck = CardDeck::new();
assert_eq!(deck.contains(&card), false);

deck.add(card);
assert_eq!(deck.contains(&card), true);

source

pub fn count(&self, card: &C) -> u64

Checks the amount of equal cards.

Example

use stochasta::CardDeck;

let deck = CardDeck::from(vec![1, 3, 3]);

assert_eq!(deck.count(&1), 1);
assert_eq!(deck.count(&3), 2);
assert_eq!(deck.count(&5), 0);

source §

impl<C> CardDeck<C>where C: Eq + Hash + Ord + Clone,

source

pub fn draw(&self, card: C) -> Self

Draws one exemplar of card from the deck and returns a new deck.

Example

use stochasta::CardDeck;

let original = CardDeck::from(vec![1, 2, 3]);

assert_eq!(original.contains(&3), true);

let new_deck = original.draw(3);

assert_eq!(original.contains(&3), true);
assert_eq!(new_deck.contains(&3), false);