FSRSAlgorithm

class FSRSAlgorithm {

constructor(params: Partial<FSRSParameters>);

private update_parameters;

protected _seed?: string;

protected intervalModifier: number;

protected param: FSRSParameters;

get interval_modifier(): number;

set seed(seed: string);

get parameters(): FSRSParameters;

set parameters(params: Partial<FSRSParameters>);

protected params_handler_proxy(): ProxyHandler<FSRSParameters>;

apply_fuzz(

ivl: number,

elapsed_days: number,

enable_fuzz?: boolean,

): int;

calculate_interval_modifier(request_retention: number): number;

constrain_difficulty(difficulty: number): number;

forgetting_curve(elapsed_days: number, stability: number): number;

init_difficulty(g: Grade): number;

init_stability(g: Grade): number;

mean_reversion(init: number, current: number): number;

next_difficulty(d: number, g: Grade): number;

next_forget_stability(

d: number,

s: number,

r: number,

): number;

next_interval(

s: number,

elapsed_days: number,

enable_fuzz?: boolean,

): int;

next_recall_stability(

d: number,

s: number,

r: number,

g: Grade,

): number;

next_short_term_stability(s: number, g: Grade): number;

}

§Constructors

new FSRSAlgorithm(params: Partial<FSRSParameters>)

[src]

§Properties

update_parameters

[src]

_seed: string

[src]

intervalModifier: number

[src]

param: FSRSParameters

[src]

interval_modifier: number readonly

[src]

seed: string

[src]

parameters: FSRSParameters

[src]

Get the parameters of the algorithm.

§Methods

params_handler_proxy(): ProxyHandler<FSRSParameters> protected

[src]

apply_fuzz(ivl: number, elapsed_days: number, enable_fuzz?: boolean): int

[src]

If fuzzing is disabled or ivl is less than 2.5, it returns the original interval.

@param ivl

The interval to be fuzzed.

@param elapsed_days

t days since the last review

@param enable_fuzz

This adds a small random delay to the new interval time to prevent cards from sticking together and always being reviewed on the same day.

@return

The fuzzed interval.

calculate_interval_modifier(request_retention: number): number

[src]

@param request_retention

0<request_retention<=1,Requested retention rate

constrain_difficulty(difficulty: number): number

[src]

The formula used is : $$\min \lbrace \max \lbrace D_0,1 \rbrace,10\rbrace$$

@param difficulty

$$D \in [1,10]$$

forgetting_curve(elapsed_days: number, stability: number): number

[src]

The formula used is : $$R(t,S) = (1 + \text{FACTOR} \times \frac{t}{9 \cdot S})^{\text{DECAY}}$$

@param elapsed_days

t days since the last review

@param stability

Stability (interval when R=90%)

@return

r Retrievability (probability of recall)

init_difficulty(g: Grade): number

[src]

The formula used is : $$D_0(G) = w_4 - e^{(G-1) \cdot w_5} + 1 $$ $$D_0 = \min \lbrace \max \lbrace D_0(G),1 \rbrace,10 \rbrace$$ where the $$D_0(1)=w_4$$ when the first rating is good.

@param g

Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]

@return

Difficulty $$D \in [1,10]$$

init_stability(g: Grade): number

[src]

The formula used is : $$ S_0(G) = w_{G-1}$$ $$S_0 = \max \lbrace S_0,0.1\rbrace $$

@param g

Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]

@return

Stability (interval when R=90%)

mean_reversion(init: number, current: number): number

[src]

The formula used is : $$w_7 \cdot \text{init} +(1 - w_7) \cdot \text{current}$$

@param init

$$w_2 : D_0(3) = w_2 + (R-2) \cdot w_3= w_2$$

@param current

$$D - w_6 \cdot (R - 2)$$

@return

difficulty

next_difficulty(d: number, g: Grade): number

[src]

The formula used is : $$\text{next}_d = D - w_6 \cdot (g - 3)$$ $$D^\prime(D,R) = w_7 \cdot D_0(4) +(1 - w_7) \cdot \text{next}_d$$

@param d

Difficulty $$D \in [1,10]$$

@param g

Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]

@return

$$\text{next}_D$$

next_forget_stability(d: number, s: number, r: number): number

[src]

The formula used is : $$S^\prime_f(D,S,R) = w_{11}\cdot D^{-w_{12}}\cdot ((S+1)^{{w_{13}}-1) \cdot e}{w_{14}\cdot(1-R)}$$

@param d

Difficulty D \in [1,10]

@param s

Stability (interval when R=90%)

@param r

Retrievability (probability of recall)

@return

S^\prime_f new stability after forgetting

next_interval(s: number, elapsed_days: number, enable_fuzz?: boolean): int

[src]

@param s

Stability (interval when R=90%)

@param elapsed_days

t days since the last review

@param enable_fuzz

This adds a small random delay to the new interval time to prevent cards from sticking together and always being reviewed on the same day.

next_recall_stability(d: number, s: number, r: number, g: Grade): number

[src]

The formula used is : $$S^\prime_r(D,S,R,G) = S\cdot(e^{w_8}\cdot (11-D)\cdot S^{-w_9}\cdot(e^{w_{10}\cdot(1-R)}-1)\cdot w_{15}(\text{if} G=2) \cdot w_{16}(\text{if} G=4)+1)$$

@param d

Difficulty D \in [1,10]

@param s

Stability (interval when R=90%)

@param r

Retrievability (probability of recall)

@param g

Grade (Rating[0.again,1.hard,2.good,3.easy])

@return

S^\prime_r new stability after recall

next_short_term_stability(s: number, g: Grade): number

[src]

The formula used is : $$S^\prime_s(S,G) = S \cdot e^{w_{17} \cdot (G-3+w_{18})}$$

@param s

Stability (interval when R=90%)

@param g

Grade (Rating[0.again,1.hard,2.good,3.easy])