Add /h command for printing a histogram of the current bins.

diff --git a/Makefile b/Makefile
index 238afe1719e90d14d6983bfde2c5b6b1d408dbea..360b418b1c66d516311e9b1d346f4a1c69ca3b99 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 MY_CFLAGS=-Wall -Wextra -Wmissing-prototypes -Wno-unused-parameter -Wno-sign-compare
 MY_CFLAGS=-Wall -Wextra -Wmissing-prototypes -Wno-unused-parameter -Wno-sign-compare

-MY_LDFLAGS=-lreadline
+MY_LDFLAGS=-lreadline -lm

 
 PROGRAMS=mnemon
 all: $(PROGRAMS)
 
 PROGRAMS=mnemon
 all: $(PROGRAMS)

diff --git a/mnemon.c b/mnemon.c
index 72c5174cd7e1ba067b3dcabb79cd5397f35c5ab8..3298197cde18d781b02ca19f0c64332ffe0078ec 100644 (file)
--- a/mnemon.c
+++ b/mnemon.c
@@ -22,6 +22,7 @@
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdint.h>

+#include <math.h>

 
 #include <sys/types.h>
 #include <dirent.h>
 
 #include <sys/types.h>
 #include <dirent.h>


@@ -64,6 +65,11 @@ typedef struct _mnemon {
     int bins_size;
     int num_bins;
     bin_t *bins;
     int bins_size;
     int num_bins;
     bin_t *bins;

+
+    int to_introduce;
+    int to_master;
+    int unlearned;
+    int mastered;

 } mnemon_t;
 
 static void *
 } mnemon_t;
 
 static void *


@@ -291,6 +297,11 @@ mnemon_init (mnemon_t *mnemon)
     mnemon->bins_size = 0;
     mnemon->num_bins = 0;
     mnemon->bins = NULL;
     mnemon->bins_size = 0;
     mnemon->num_bins = 0;
     mnemon->bins = NULL;

+
+    mnemon->to_introduce = 3;
+    mnemon->to_master = 10;
+    mnemon->unlearned = 0;
+    mnemon->mastered = 0;

 }
 
 static void
 }
 
 static void


@@ -625,143 +636,237 @@ mnemon_select_item (mnemon_t     *mnemon,
     *item_index_ret = rand_within (bin->num_items);
 }
 
     *item_index_ret = rand_within (bin->num_items);
 }
 

+
+#define HISTOGRAM_ROW_FORMAT "%3d: %3d"
+#define HISTOGRAM_BAR_WIDTH  63
+

 static void
 static void

-mnemon_do_challenges (mnemon_t *mnemon,
-                     int       to_introduce,
-                     int       to_master)
+print_histogram_bar (double    size,
+                    double     max)
+{
+    int units_per_cell = (int) ceil (max / HISTOGRAM_BAR_WIDTH);
+    static char const *boxes[8] = {
+       "█", "▉", "▊", "▋",
+       "▌", "▍", "▎", "▏"
+    };
+
+    while (size > units_per_cell) {
+       printf(boxes[0]);
+       size -= units_per_cell;
+    }
+
+    size /= units_per_cell;
+
+    if (size > 7.5/8.0)
+       printf(boxes[0]);
+    else if (size > 6.5/8.0)
+       printf(boxes[1]);
+    else if (size > 5.5/8.0)
+       printf(boxes[2]);
+    else if (size > 4.5/8.0)
+       printf(boxes[3]);
+    else if (size > 3.5/8.0)
+       printf(boxes[4]);
+    else if (size > 2.5/8.0)
+       printf(boxes[5]);
+    else if (size > 1.5/8.0)
+       printf(boxes[6]);
+    else if (size > 0.5/8.0)
+       printf(boxes[7]);
+
+    printf ("\n");
+}
+
+static void
+mnemon_print_histogram (mnemon_t *mnemon)
+{
+    int i, last_score, max;
+    bin_t *bin;
+
+    if (mnemon->num_bins == 0)
+       return;
+
+    max = mnemon->bins[0].num_items;
+    for (i = 1; i < mnemon->num_bins; i++)
+       if (mnemon->bins[i].num_items > max)
+           max = mnemon->bins[i].num_items;
+
+    for (i = 0; i < mnemon->num_bins; i++) {
+       bin = &mnemon->bins[i];
+       if (i != 0)
+           while (bin->score - last_score > 1)
+               printf (HISTOGRAM_ROW_FORMAT "\n", ++last_score, 0);
+       printf (HISTOGRAM_ROW_FORMAT " ", bin->score, bin->num_items);
+       print_histogram_bar (bin->num_items, max);
+       last_score = bin->score;
+    }
+}
+
+static void
+mnemon_handle_command (mnemon_t                *mnemon,
+                      const char       *command)
+{
+    switch (command[0]) {
+       case 'h':
+           mnemon_print_histogram (mnemon);
+           break;
+        default:
+           printf ("Unknown command: %s\n", command);
+           break;
+    }
+}
+
+static void
+mnemon_handle_response (mnemon_t       *mnemon,
+                       bin_t           *bin,
+                       int              item_index,
+                       item_t          *item,
+                       const char      *response)
+{
+    bool_t correct;
+
+    correct = (strcmp (response, item->response) == 0);
+
+    bin_remove_item (bin, item_index);
+
+    /* If the bin is now empty, we must remove it. Also if we just
+     * picked the last word we'll ever pick from the bin with
+     * score 0, then we can remove that as well. */
+    if (bin->num_items == 0 ||
+       (bin->score == 0 && mnemon->to_introduce == 0))
+    {
+       mnemon_remove_bin (mnemon, bin);
+    }
+
+    if (correct) {
+       item->score++;
+       /* We reserve an item score of 0 for an item that has
+        * never been asked. */
+       if (item->score == 0) {
+           item->score = 1;
+           mnemon->unlearned--;
+           printf ("You got it!");
+       } else if (item->score < 0) {
+           printf ("Yes---just give me %d more.",
+                   - item->score);
+       } else if (item->score == 1) {
+           printf ("On your first try, no less!");
+       } else {
+           printf ("Masterful (%dx).", item->score);
+       }
+    } else {
+       printf ("  %s is the correct answer.",
+               item->response);
+       /* Penalize an incorrect response by forcing the score
+        * negative. */
+       if (item->score >= 0) {
+           if (item->score > 0)
+               printf ( " Oops, you knew that, right?\n ");
+           mnemon->unlearned++;
+           mnemon->mastered = 0;
+           /* 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
+            * a correct response without any learning). */
+           item->score = -2;
+       } else {
+           item->score--;
+       }
+    }
+
+    printf (" (");
+    if (mnemon->to_introduce)
+       printf ("%d to come.", mnemon->to_introduce);
+    if (mnemon->to_introduce && mnemon->unlearned)
+       printf (" ");
+    if (mnemon->unlearned)
+       printf ("%d still unlearned.", mnemon->unlearned);
+    if (mnemon->to_introduce == 0 && mnemon->unlearned == 0) {
+       if (mnemon->mastered < mnemon->to_master)
+           printf ("%d items to master",
+                   mnemon->to_master - mnemon->mastered);
+       else
+           printf ("Great job!");
+           mnemon->mastered++;
+    }
+    printf (")\n\n");
+
+    bin = mnemon_get_bin (mnemon, item->score);
+
+    bin_add_item (bin, item);
+}
+
+static void
+mnemon_do_challenges (mnemon_t *mnemon)

 {
     bin_t *bin;
     int item_index;
     item_t *item;
     char *response;
 {
     bin_t *bin;
     int item_index;
     item_t *item;
     char *response;

-    bool_t correct;
-    int unlearned, mastered = 0;

     int i;
 
     /* Count the number of items with negative scores. */
     int i;
 
     /* Count the number of items with negative scores. */

-    unlearned = 0;
+    mnemon->unlearned = 0;

     for (i = 0; i < mnemon->num_bins; i++) {
        bin = &mnemon->bins[i];
        if (bin->score >= 0)
            break;
     for (i = 0; i < mnemon->num_bins; i++) {
        bin = &mnemon->bins[i];
        if (bin->score >= 0)
            break;

-       unlearned += bin->num_items;
+       mnemon->unlearned += bin->num_items;

     }
 
     }
 

-    to_introduce -= unlearned;
-    if (to_introduce < 0)
-       to_introduce = 0;
+    mnemon->to_introduce -= mnemon->unlearned;
+    if (mnemon->to_introduce < 0)
+       mnemon->to_introduce = 0;

 
     /* Get rid of bin with score of 0 if we aren't going to be
      * introducing anything from it. */
 
     /* Get rid of bin with score of 0 if we aren't going to be
      * introducing anything from it. */

-    if (to_introduce == 0) {
+    if (mnemon->to_introduce == 0) {

        bin = mnemon_get_bin (mnemon, 0);
        mnemon_remove_bin (mnemon, bin);        
     }
 
        bin = mnemon_get_bin (mnemon, 0);
        mnemon_remove_bin (mnemon, bin);        
     }
 

-    if (unlearned) {
-       printf ("You've got %d items to learn already. ", unlearned);
-       if (to_introduce)
-           printf ("I'll introduce %d more as we go.", to_introduce);
+    if (mnemon->unlearned) {
+       printf ("You've got %d items to learn already. ", mnemon->unlearned);
+       if (mnemon->to_introduce)
+           printf ("I'll introduce %d more as we go.", mnemon->to_introduce);

        printf ("\n");
     } else {
        printf ("\n");
     } else {

-       printf ("Introducing %d new items.\n", to_introduce);
+       printf ("Introducing %d new items.\n", mnemon->to_introduce);

     }
     printf ("\n");
 
     do {
        mnemon_select_item (mnemon, &bin, &item_index);
     }
     printf ("\n");
 
     do {
        mnemon_select_item (mnemon, &bin, &item_index);

-
-       if (bin->score == 0)
-           to_introduce--;
-

        item = bin->items[item_index];
 
        item = bin->items[item_index];
 

-       printf ("%s\n", item->challenge);
-
-       response = readline ("> ");
-       if (response == NULL) {
-           printf ("\n");
-           break;
-       }
-
-       correct = (strcmp (response, item->response) == 0);
-
-       bin_remove_item (bin, item_index);
+       if (bin->score == 0)
+           mnemon->to_introduce--;

 
 

-       /* If the bin is now empty, we must remove it. Also if we just
-        * picked the last word we'll ever pick from the bin with
-        * score 0, then we can remove that as well. */
-       if (bin->num_items == 0 ||
-           (bin->score == 0 && to_introduce == 0))
-       {
-           mnemon_remove_bin (mnemon, bin);
-       }
+       while (1) {
+           printf ("%s\n", item->challenge);

 
 

-       if (correct) {
-           item->score++;
-           /* We reserve an item score of 0 for an item that has
-            * never been asked. */
-           if (item->score == 0) {
-               item->score = 1;
-               unlearned--;
-               printf ("You got it!");
-           } else if (item->score < 0) {
-               printf ("Yes---just give me %d more.",
-                       - item->score);
-           } else if (item->score == 1) {
-               printf ("On your first try, no less!");
-           } else {
-               printf ("Masterful (%dx).", item->score);
-           }
-       } else {
-           printf ("  %s is the correct answer.",
-                   item->response);
-           /* Penalize an incorrect response by forcing the score
-            * negative. */
-           if (item->score >= 0) {
-               if (item->score > 0)
-                   printf ( " Oops, you knew that, right?\n ");
-               unlearned++;
-               mastered = 0;
-               /* 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
-                * a correct response without any learning). */
-               item->score = -2;
-           } else {
-               item->score--;
+           response = readline ("> ");
+           /* Terminate on EOF */
+           if (response == NULL) {
+               printf ("\n");
+               return;

            }
            }

-       }

 
 

-       printf (" (");
-       if (to_introduce)
-           printf ("%d to come.", to_introduce);
-       if (to_introduce && unlearned)
-           printf (" ");
-       if (unlearned)
-           printf ("%d still unlearned.", unlearned);
-       if (to_introduce == 0 && unlearned == 0) {
-           if (mastered < to_master)
-               printf ("%d items to master",
-                       to_master - mastered);
+           if (response[0] == '/')
+               mnemon_handle_command (mnemon, response + 1);

            else
            else

-               printf ("Great job!");
-           mastered++;
+               break;

        }
        }

-       printf (")\n\n");

 
 

-       bin = mnemon_get_bin (mnemon, item->score);
-
-       bin_add_item (bin, item);
-    } while (mastered <= to_master);
+       mnemon_handle_response (mnemon, bin, item_index,
+                               item, response);
+    } while (mnemon->mastered <= mnemon->to_master);

 }
 
 int
 main (int argc, char *argv[])
 {
     mnemon_t mnemon;
 }
 
 int
 main (int argc, char *argv[])
 {
     mnemon_t mnemon;

-    int to_introduce   = 3;
-    int to_master      = 10;

 
     srand (time (NULL));
 
 
     srand (time (NULL));
 


@@ -769,9 +874,7 @@ main (int argc, char *argv[])
 
     mnemon_load (&mnemon);
 
 
     mnemon_load (&mnemon);
 

-    mnemon_do_challenges (&mnemon,
-                         to_introduce,
-                         to_master);
+    mnemon_do_challenges (&mnemon);

 
     mnemon_save (&mnemon);
 
 
     mnemon_save (&mnemon);