ts-fsrs 2.0.2 → 2.0.3

package/README.md

@@ -1,7 +1,7 @@
 # About The
 
-ts-fsrs is a TypeScript package used to implement the Free Spaced Repetition Scheduler (FSRS) algorithm. It helps
-developers apply FSRS to their flashcard applications, thereby improving the user learning experience.
+ts-fsrs is a TypeScript package used to implement the [Free Spaced Repetition Scheduler (FSRS) algorithm](https://github.com/open-spaced-repetition/free-spaced-repetition-scheduler). It helps
+developers apply FSRS to their flashcard applications, there by improving the user learning experience.
 
 # Usage
 

package/lib/fsrs.d.ts

@@ -1,126 +1,126 @@
-import { Card, FSRSParameters, Rating, SchedulingCard, State } from "./index";
-import { int } from './help';
-export default class FSRS {
-    private param;
-    private readonly intervalModifier;
-    private seed?;
-    constructor(param?: FSRSParameters);
-    repeat: (card: Card, now: Date) => {
-        0: {
-            card: Card;
-            log: {
-                rating: Rating;
-                state: State;
-                elapsed_days: number;
-                scheduled_days: number;
-                review: Date;
-            };
-        };
-        1: {
-            card: Card;
-            log: {
-                rating: Rating;
-                state: State;
-                elapsed_days: number;
-                scheduled_days: number;
-                review: Date;
-            };
-        };
-        2: {
-            card: Card;
-            log: {
-                rating: Rating;
-                state: State;
-                elapsed_days: number;
-                scheduled_days: number;
-                review: Date;
-            };
-        };
-        3: {
-            card: Card;
-            log: {
-                rating: Rating;
-                state: State;
-                elapsed_days: number;
-                scheduled_days: number;
-                review: Date;
-            };
-        };
-    };
-    get_retrievability: (card: Card, now: Date) => undefined | string;
-    init_ds(s: SchedulingCard): void;
-    /**
-     *
-     * @param s scheduling Card
-     * @param last_d Difficulty
-     * @param last_s Stability
-     * @param retrievability Retrievability
-     */
-    next_ds(s: SchedulingCard, last_d: number, last_s: number, retrievability: number): void;
-    /**
-     * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
-     * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Stability (interval when R=90%)
-     */
-    init_stability(g: number): number;
-    /**
-     * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
-     * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Difficulty D \in [1,10]
-     */
-    init_difficulty(g: number): number;
-    apply_fuzz(ivl: number): number;
-    next_interval(s: number): int;
-    /**
-     * The formula used is :
-     * $$next_d = D + w_4 \cdot (R - 2)$$
-     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
-     * @param d
-     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
-     * @return next_D
-     */
-    next_difficulty(d: number, g: number): number;
-    /**
-     * The formula used is :
-     * $$\min \{\max \{D_0,1\},10\}$$
-     */
-    constrain_difficulty(difficulty: number): number;
-    /**
-     * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
-     * @return difficulty
-     */
-    mean_reversion(init: number, current: number): number;
-    /**
-     * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_r new stability after recall
-     */
-    next_recall_stability(d: number, s: number, r: number): number;
-    /**
-     * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\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_forget_stability(d: number, s: number, r: number): number;
-    /**
-     * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
-     * @param t t days since the last review
-     * @param s Stability (interval when R=90%)
-     * @return r Retrievability (probability of recall)
-     */
-    current_retrievability(t: number, s: number): number;
-}
+import { Card, FSRSParameters, Rating, SchedulingCard, State } from "./index";
+import { int } from './help';
+export default class FSRS {
+    private param;
+    private readonly intervalModifier;
+    private seed?;
+    constructor(param?: FSRSParameters);
+    repeat: (card: Card, now: Date) => {
+        0: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        1: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        2: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        3: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+    };
+    get_retrievability: (card: Card, now: Date) => undefined | string;
+    init_ds(s: SchedulingCard): void;
+    /**
+     *
+     * @param s scheduling Card
+     * @param last_d Difficulty
+     * @param last_s Stability
+     * @param retrievability Retrievability
+     */
+    next_ds(s: SchedulingCard, last_d: number, last_s: number, retrievability: number): void;
+    /**
+     * The formula used is :
+     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$\max \{S_0,0.1\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Stability (interval when R=90%)
+     */
+    init_stability(g: number): number;
+    /**
+     * The formula used is :
+     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$\min \{\max \{D_0(G),1\},10\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Difficulty D \in [1,10]
+     */
+    init_difficulty(g: number): number;
+    apply_fuzz(ivl: number): number;
+    next_interval(s: number): int;
+    /**
+     * The formula used is :
+     * $$next_d = D + w_4 \cdot (R - 2)$$
+     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
+     * @param d
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @return next_D
+     */
+    next_difficulty(d: number, g: number): number;
+    /**
+     * The formula used is :
+     * $$\min \{\max \{D_0,1\},10\}$$
+     */
+    constrain_difficulty(difficulty: number): number;
+    /**
+     * The formula used is :
+     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
+     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D + w_4 \cdot (R - 2)$$
+     * @return difficulty
+     */
+    mean_reversion(init: number, current: number): number;
+    /**
+     * The formula used is :
+     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_r new stability after recall
+     */
+    next_recall_stability(d: number, s: number, r: number): number;
+    /**
+     * The formula used is :
+     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\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_forget_stability(d: number, s: number, r: number): number;
+    /**
+     * The formula used is :
+     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * @param t t days since the last review
+     * @param s Stability (interval when R=90%)
+     * @return r Retrievability (probability of recall)
+     */
+    current_retrievability(t: number, s: number): number;
+}

package/lib/fsrs.js

@@ -1,189 +1,189 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const seedrandom_1 = __importDefault(require("seedrandom"));
-const index_1 = require("./index");
-class FSRS {
-    constructor(param) {
-        this.repeat = (card, now) => {
-            card = Object.assign({}, card);
-            now = new Date(now.getTime());
-            card.elapsed_days = card.state === index_1.State.New ? 0 : now.diff(card.last_review, "days"); //相距时间
-            card.last_review = now; // 上次复习时间
-            card.reps += 1;
-            const s = new index_1.SchedulingCard(card);
-            s.update_state(card.state);
-            this.seed = String(card.last_review.getTime()) + String(card.elapsed_days);
-            let easy_interval, good_interval, hard_interval;
-            switch (card.state) {
-                case index_1.State.New:
-                    this.init_ds(s);
-                    s.again.due = now.scheduler(1);
-                    s.hard.due = now.scheduler(5);
-                    s.good.due = now.scheduler(10);
-                    easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
-                    s.easy.scheduled_days = easy_interval;
-                    s.easy.due = now.scheduler(easy_interval, true);
-                    break;
-                case index_1.State.Learning:
-                case index_1.State.Relearning:
-                    hard_interval = 0;
-                    good_interval = this.next_interval(s.good.stability);
-                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
-                    s.schedule(now, hard_interval, good_interval, easy_interval);
-                    break;
-                case index_1.State.Review:
-                    const interval = card.elapsed_days;
-                    const last_d = card.difficulty;
-                    const last_s = card.stability;
-                    const retrievability = this.current_retrievability(interval, last_s);
-                    this.next_ds(s, last_d, last_s, retrievability);
-                    hard_interval = this.next_interval(last_s * this.param.hard_factor);
-                    good_interval = this.next_interval(s.good.stability);
-                    hard_interval = Math.min(hard_interval, good_interval);
-                    good_interval = Math.max(good_interval, hard_interval + 1);
-                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
-                    s.schedule(now, hard_interval, good_interval, easy_interval);
-                    break;
-            }
-            return s.record_log(card, now);
-        };
-        this.get_retrievability = (card, now) => {
-            if (card.state !== index_1.State.Review) {
-                return undefined;
-            }
-            const t = Math.max(now.diff(card.last_review, "days"), 0);
-            return (this.current_retrievability(t, card.stability) * 100).toFixed(2) + '%';
-        };
-        this.param = param || (0, index_1.generatorParameters)();
-        this.intervalModifier = Math.log(this.param.request_retention) / Math.log(0.9);
-    }
-    init_ds(s) {
-        s.again.difficulty = this.init_difficulty(index_1.Rating.Again);
-        s.again.stability = this.init_stability(index_1.Rating.Again);
-        s.hard.difficulty = this.init_difficulty(index_1.Rating.Hard);
-        s.hard.stability = this.init_stability(index_1.Rating.Hard);
-        s.good.difficulty = this.init_difficulty(index_1.Rating.Good);
-        s.good.stability = this.init_stability(index_1.Rating.Good);
-        s.easy.difficulty = this.init_difficulty(index_1.Rating.Easy);
-        s.easy.stability = this.init_stability(index_1.Rating.Easy);
-    }
-    /**
-     *
-     * @param s scheduling Card
-     * @param last_d Difficulty
-     * @param last_s Stability
-     * @param retrievability Retrievability
-     */
-    next_ds(s, last_d, last_s, retrievability) {
-        s.again.difficulty = this.next_difficulty(last_d, index_1.Rating.Again);
-        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
-        s.hard.difficulty = this.next_difficulty(last_d, index_1.Rating.Hard);
-        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
-        s.good.difficulty = this.next_difficulty(last_d, index_1.Rating.Good);
-        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
-        s.easy.difficulty = this.next_difficulty(last_d, index_1.Rating.Easy);
-        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
-    }
-    /**
-     * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
-     * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Stability (interval when R=90%)
-     */
-    init_stability(g) {
-        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
-    }
-    /**
-     * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
-     * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Difficulty D \in [1,10]
-     */
-    init_difficulty(g) {
-        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
-    }
-    apply_fuzz(ivl) {
-        if (!this.param.enable_fuzz || ivl < 2.5)
-            return ivl;
-        const generator = (0, seedrandom_1.default)(this.seed);
-        const fuzz_factor = generator();
-        ivl = Math.round(ivl);
-        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
-        const max_ivl = Math.round(ivl * 1.05 + 1);
-        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
-    }
-    next_interval(s) {
-        const newInterval = this.apply_fuzz(s * this.intervalModifier);
-        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
-    }
-    /**
-     * The formula used is :
-     * $$next_d = D + w_4 \cdot (R - 2)$$
-     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
-     * @param d
-     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
-     * @return next_D
-     */
-    next_difficulty(d, g) {
-        const next_d = d + this.param.w[4] * (g - 2);
-        return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
-    }
-    /**
-     * The formula used is :
-     * $$\min \{\max \{D_0,1\},10\}$$
-     */
-    constrain_difficulty(difficulty) {
-        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
-    }
-    /**
-     * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
-     * @return difficulty
-     */
-    mean_reversion(init, current) {
-        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_r new stability after recall
-     */
-    next_recall_stability(d, s, r) {
-        return s * (1 + Math.exp(this.param.w[6]) *
-            (11 - d) *
-            Math.pow(s, this.param.w[7]) *
-            (Math.exp((1 - r) * this.param.w[8]) - 1));
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\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_forget_stability(d, s, r) {
-        return this.param.w[9] * Math.pow(d, this.param.w[10]) * Math.pow(s, this.param.w[11]) * Math.exp((1 - r) * this.param.w[12]);
-    }
-    /**
-     * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
-     * @param t t days since the last review
-     * @param s Stability (interval when R=90%)
-     * @return r Retrievability (probability of recall)
-     */
-    current_retrievability(t, s) {
-        return Math.exp(Math.log(0.9) * t / s);
-    }
-}
-exports.default = FSRS;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const seedrandom_1 = __importDefault(require("seedrandom"));
+const index_1 = require("./index");
+class FSRS {
+    constructor(param) {
+        this.repeat = (card, now) => {
+            card = Object.assign({}, card);
+            now = new Date(now.getTime());
+            card.elapsed_days = card.state === index_1.State.New ? 0 : now.diff(card.last_review, "days"); //相距时间
+            card.last_review = now; // 上次复习时间
+            card.reps += 1;
+            const s = new index_1.SchedulingCard(card);
+            s.update_state(card.state);
+            this.seed = String(card.last_review.getTime()) + String(card.elapsed_days);
+            let easy_interval, good_interval, hard_interval;
+            switch (card.state) {
+                case index_1.State.New:
+                    this.init_ds(s);
+                    s.again.due = now.scheduler(1);
+                    s.hard.due = now.scheduler(5);
+                    s.good.due = now.scheduler(10);
+                    easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
+                    s.easy.scheduled_days = easy_interval;
+                    s.easy.due = now.scheduler(easy_interval, true);
+                    break;
+                case index_1.State.Learning:
+                case index_1.State.Relearning:
+                    hard_interval = 0;
+                    good_interval = this.next_interval(s.good.stability);
+                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                    s.schedule(now, hard_interval, good_interval, easy_interval);
+                    break;
+                case index_1.State.Review:
+                    const interval = card.elapsed_days;
+                    const last_d = card.difficulty;
+                    const last_s = card.stability;
+                    const retrievability = this.current_retrievability(interval, last_s);
+                    this.next_ds(s, last_d, last_s, retrievability);
+                    hard_interval = this.next_interval(last_s * this.param.hard_factor);
+                    good_interval = this.next_interval(s.good.stability);
+                    hard_interval = Math.min(hard_interval, good_interval);
+                    good_interval = Math.max(good_interval, hard_interval + 1);
+                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                    s.schedule(now, hard_interval, good_interval, easy_interval);
+                    break;
+            }
+            return s.record_log(card, now);
+        };
+        this.get_retrievability = (card, now) => {
+            if (card.state !== index_1.State.Review) {
+                return undefined;
+            }
+            const t = Math.max(now.diff(card.last_review, "days"), 0);
+            return (this.current_retrievability(t, card.stability) * 100).toFixed(2) + '%';
+        };
+        this.param = param || (0, index_1.generatorParameters)();
+        this.intervalModifier = Math.log(this.param.request_retention) / Math.log(0.9);
+    }
+    init_ds(s) {
+        s.again.difficulty = this.init_difficulty(index_1.Rating.Again);
+        s.again.stability = this.init_stability(index_1.Rating.Again);
+        s.hard.difficulty = this.init_difficulty(index_1.Rating.Hard);
+        s.hard.stability = this.init_stability(index_1.Rating.Hard);
+        s.good.difficulty = this.init_difficulty(index_1.Rating.Good);
+        s.good.stability = this.init_stability(index_1.Rating.Good);
+        s.easy.difficulty = this.init_difficulty(index_1.Rating.Easy);
+        s.easy.stability = this.init_stability(index_1.Rating.Easy);
+    }
+    /**
+     *
+     * @param s scheduling Card
+     * @param last_d Difficulty
+     * @param last_s Stability
+     * @param retrievability Retrievability
+     */
+    next_ds(s, last_d, last_s, retrievability) {
+        s.again.difficulty = this.next_difficulty(last_d, index_1.Rating.Again);
+        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
+        s.hard.difficulty = this.next_difficulty(last_d, index_1.Rating.Hard);
+        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
+        s.good.difficulty = this.next_difficulty(last_d, index_1.Rating.Good);
+        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
+        s.easy.difficulty = this.next_difficulty(last_d, index_1.Rating.Easy);
+        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
+    }
+    /**
+     * The formula used is :
+     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$\max \{S_0,0.1\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Stability (interval when R=90%)
+     */
+    init_stability(g) {
+        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
+    }
+    /**
+     * The formula used is :
+     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$\min \{\max \{D_0(G),1\},10\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Difficulty D \in [1,10]
+     */
+    init_difficulty(g) {
+        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
+    }
+    apply_fuzz(ivl) {
+        if (!this.param.enable_fuzz || ivl < 2.5)
+            return ivl;
+        const generator = (0, seedrandom_1.default)(this.seed);
+        const fuzz_factor = generator();
+        ivl = Math.round(ivl);
+        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
+        const max_ivl = Math.round(ivl * 1.05 + 1);
+        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
+    }
+    next_interval(s) {
+        const newInterval = this.apply_fuzz(s * this.intervalModifier);
+        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
+    }
+    /**
+     * The formula used is :
+     * $$next_d = D + w_4 \cdot (R - 2)$$
+     * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
+     * @param d
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @return next_D
+     */
+    next_difficulty(d, g) {
+        const next_d = d + this.param.w[4] * (g - 2);
+        return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
+    }
+    /**
+     * The formula used is :
+     * $$\min \{\max \{D_0,1\},10\}$$
+     */
+    constrain_difficulty(difficulty) {
+        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
+    }
+    /**
+     * The formula used is :
+     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
+     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D + w_4 \cdot (R - 2)$$
+     * @return difficulty
+     */
+    mean_reversion(init, current) {
+        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_r new stability after recall
+     */
+    next_recall_stability(d, s, r) {
+        return s * (1 + Math.exp(this.param.w[6]) *
+            (11 - d) *
+            Math.pow(s, this.param.w[7]) *
+            (Math.exp((1 - r) * this.param.w[8]) - 1));
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\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_forget_stability(d, s, r) {
+        return this.param.w[9] * Math.pow(d, this.param.w[10]) * Math.pow(s, this.param.w[11]) * Math.exp((1 - r) * this.param.w[12]);
+    }
+    /**
+     * The formula used is :
+     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * @param t t days since the last review
+     * @param s Stability (interval when R=90%)
+     * @return r Retrievability (probability of recall)
+     */
+    current_retrievability(t, s) {
+        return Math.exp(Math.log(0.9) * t / s);
+    }
+}
+exports.default = FSRS;