Struct SimulatorConfig 

pub struct SimulatorConfig {

    pub deck_size: usize,
    pub learn_span: usize,
    pub max_cost_perday: f32,
    pub max_ivl: f32,
    pub first_rating_prob: [f32; 4],
    pub review_rating_prob: [f32; 3],
    pub learn_limit: usize,
    pub review_limit: usize,
    pub new_cards_ignore_review_limit: bool,
    pub suspend_after_lapses: Option<u32>,
    pub post_scheduling_fn: Option<PostSchedulingFn>,
    pub review_priority_fn: Option<ReviewPriorityFn>,
    pub learning_step_transitions: [[f32; 4]; 3],
    pub relearning_step_transitions: [[f32; 4]; 3],
    pub state_rating_costs: [[f32; 4]; 3],
    pub learning_step_count: usize,
    pub relearning_step_count: usize,
}

Fields

deck_size: usize

learn_span: usize

max_cost_perday: f32

max_ivl: f32

first_rating_prob: [f32; 4]

review_rating_prob: [f32; 3]

learn_limit: usize

review_limit: usize

new_cards_ignore_review_limit: bool

suspend_after_lapses: Option<u32>

post_scheduling_fn: Option<PostSchedulingFn>

review_priority_fn: Option<ReviewPriorityFn>

learning_step_transitions: [[f32; 4]; 3]

relearning_step_transitions: [[f32; 4]; 3]

state_rating_costs: [[f32; 4]; 3]

learning_step_count: usize

relearning_step_count: usize

Implementations

impl SimulatorConfig

pub fn with_review_priority<F>(self, f: F) -> Self

where F: Fn(&Card) -> i32 + Sync + Send + 'static,

Set the review priority callback.

use fsrs::{Card, SimulatorConfig};

let config = SimulatorConfig::default()
    .with_review_priority(|card: &Card| (card.difficulty * 100.0) as i32);

pub fn with_post_scheduling<F>(self, f: F) -> Self

where F: for<'a> Fn(PostSchedulingContext<'a>) -> f32 + Sync + Send + 'static,

Set the post scheduling callback.

use fsrs::{PostSchedulingContext, SimulatorConfig};

let config = SimulatorConfig::default()
    .with_post_scheduling(|mut ctx: PostSchedulingContext<'_>| {
        let fuzz = ctx.random_f32();
        if fuzz >= 0.0 { ctx.card.interval } else { 1.0 }
    });

Trait Implementations

impl Debug for SimulatorConfig

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

Formats the value using the given formatter.

impl Default for SimulatorConfig

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for SimulatorConfig

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SimulatorConfig