Struct coliseum::space::Discrete

pub struct Discrete(pub u32);

The Discrete space allows a fixed range of non-negative numbers, so in this case valid actions are either 0 or 1.

Examples

Discrete contains actions 0..Discrete(N-1)

use coliseum::space::{Discrete, Space};

let N = 10;
let discrete = Discrete(N);

// what's the idiomatic way to avoid cloning here?
assert!(discrete.clone().sample() < 10);
assert!(!discrete.clone().contains(10));

We can represent N*2 states for Discrete{N}

use coliseum::space::{Discrete, Space};
let discrete = Discrete(3);

let sample: (u32, u32, u32) = match discrete.sample() {
    0 => (1, 0, 0),
    1 => (0, 1, 0),
    2 => (0, 0, 1),
    _ => panic!("This is out of bounds!")
};

assert_eq!(sample.0 + sample.1 + sample.2, 1)

Trait Implementations

impl Environment<Discrete, u32, Discrete, u32> for RockPaperScissors

Examples

use coliseum::env;
use env::{Environment, State};
use env::rock_paper_scissors::RockPaperScissors;

let mut game = RockPaperScissors::default();
game.reset();

// our player loves rock
let agent = || 1;

loop {
    let State { reward, done, .. } = game.step(agent());

    if done {
        break;
    }
}

fn reset(&mut self) -> u32

fn step(&mut self, action: u32) -> State<u32>

Step takes an agent action and (probably) mutates itself; returns State to the agent.

impl Space<u32> for Discrete

fn sample(self) -> u32

Draws a random item from [0, u32]

fn contains(self, sample: u32) -> bool

Checks if the sample is part of the set

impl Clone for Discrete

fn clone(&self) -> Discrete

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Discrete