Tweak the implementation of to_master

I think the to_master counter got off from some point from its original
purpose, (and probably because I never documented it that well).

Here are my current thoughts and what should be implemented now:

A mnemon session consists of three phases, some of which may be entirely
empty, as follows:

1. The introduction phase

   This phase is controlled by the to_introduce counter which is initially
   set to 10. It is decremented every time an item is introduced from the
   bin with score 0, or (if there is no bin with score 0), every time an
   item is introduced from the bin with the lowest non-negative score of
   any bin.

2. The mastering phase

   This phase is controlled by the to_master counter which is initially
   set to 10. It begins at the beginning of the session so can run
   concurrently with the introduction phase. The to_master counter is
   decremented every time an item with a positive (non-zero) score is
   answered correctly. It is also incremented every time an item with
   a positive (non-zero) score is answered incorrectly during the
   introduction phase. If perfect mastery is demonstrated, the mastering
   phase is likely to be complete simultaneous with the introduction
   stage. If the user is really struggling with mastery, the mastering
   phase will extend long after the introduction phase is over. But
   since we never incremeent to_master after the introduction phase is
   over, the user cannot build an infinite snowball of to_master items
   and have to give up in despair.

3. The solidifying phase

   This final phase continues after the mastering phase for as long as
   any items with a negative score remain. The idea here is that we
   want to quickly give the reinforcement from a missed item in the
   current session. Also, there's a bit of a challenge to the user to
   demonstrate good mastery of any non-negative items presented so that
   the phase actually terminates. It's possible for this phase to extend
   for an arbitrary amount of time, but not very likely, (since the
   negative items are chosen preferentially and the user will continue
   to see the correct answers to them over and over).

diff --git a/mnemon.c b/mnemon.c
index c334f22d7ef0915289fd9ed20f229fe9b700bd42..69ac5b10cb9c639e18fcc1b6be337d6bba8648a0 100644 (file)
--- a/mnemon.c
+++ b/mnemon.c
@@ -1116,13 +1116,11 @@ mnemon_handle_response (mnemon_t        *mnemon,
        (time_limit == 0.0 || response_time < time_limit))
     {
        item->score++;
        (time_limit == 0.0 || response_time < time_limit))
     {
        item->score++;

-       mnemon->to_master--;

        /* We reserve an item score of 0 for an item that has
         * never been asked. */
        if (item->score == 0) {
            item->score = 1;
            mnemon->unlearned--;
        /* We reserve an item score of 0 for an item that has
         * never been asked. */
        if (item->score == 0) {
            item->score = 1;
            mnemon->unlearned--;

-           mnemon->to_master--;

            printf ("You got it!");
        } else if (item->score < 0) {
            printf ("Yes---just give me %d more.",
            printf ("You got it!");
        } else if (item->score < 0) {
            printf ("Yes---just give me %d more.",


@@ -1131,6 +1129,8 @@ mnemon_handle_response (mnemon_t  *mnemon,
            printf ("On your first try, no less!");
        } else {
            printf ("Masterful (%dx).", item->score);
            printf ("On your first try, no less!");
        } else {
            printf ("Masterful (%dx).", item->score);

+           if (mnemon->to_master)
+               mnemon->to_master--;

        }
     } else {
        if (! correct)
        }
     } else {
        if (! correct)


@@ -1146,12 +1146,13 @@ mnemon_handle_response (mnemon_t        *mnemon,
                printf (" Oops, you knew that, right? (%dx)\n ",
                        item->score);
            mnemon->unlearned++;
                printf (" Oops, you knew that, right? (%dx)\n ",
                        item->score);
            mnemon->unlearned++;

-           /* We add three here, (rather than just 2 to track the
-            * change in the item's score below), as an extra
-            * penalty. If the user is forgetting stuff learned
-            * previously, then more time should be spent on mastering
-            * than learning new items. */
-           mnemon->to_master += item->score + 3;
+           /* We increase to_master here as an extra penalty. If the
+            * user is forgetting stuff learned previously, then more
+            * time should be spent on mastering than learning new
+            * items. Note that we only do this during the initial
+            * phase while new items are still being introduced. */
+           if (mnemon->to_introduce)
+               mnemon->to_master++;

            /* We go to -2 to force a little extra reinforcement
             * when re-learning an item, (otherwise, it will often
             * get asked again immediately where it is easy to get
            /* We go to -2 to force a little extra reinforcement
             * when re-learning an item, (otherwise, it will often
             * get asked again immediately where it is easy to get


@@ -1159,7 +1160,6 @@ mnemon_handle_response (mnemon_t  *mnemon,
            item->score = -2;
        } else {
            item->score--;
            item->score = -2;
        } else {
            item->score--;

-           mnemon->to_master++;

        }
     }
 
        }
     }