X-Git-Url: https://git.cworth.org/git?p=mnemon;a=blobdiff_plain;f=mnemon.c;h=fd7b9bf15b4ce7da6b6772420cfeea79e4028a39;hp=1eebd20df491681e42a21190451ec55116f3893b;hb=ce8d39d4b7bd3cc650ea85636dfde4dad56903cf;hpb=698b08fa45715b2d24f311c041f3858decbd21d6 diff --git a/mnemon.c b/mnemon.c index 1eebd20..fd7b9bf 100644 --- a/mnemon.c +++ b/mnemon.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -35,23 +36,32 @@ typedef int bool_t; typedef struct _item { - int count; + int score; char *challenge; char *response; } item_t; typedef struct _bin { - int count; + int score; int items_size; int num_items; item_t **items; } bin_t; +typedef enum { + CATEGORY_ORDER_RANDOM, + CATEGORY_ORDER_SEQUENTIAL +} category_order_t; + typedef struct _category { char *name; int items_size; int num_items; item_t *items; + + /* Support sequential introduction of items from bin 0 */ + category_order_t order; + int bin_zero_head; } category_t; typedef struct _mnemon { @@ -64,6 +74,11 @@ typedef struct _mnemon { int bins_size; int num_bins; bin_t *bins; + + int to_introduce; + int to_master; + int unlearned; + int mastered; } mnemon_t; static void * @@ -100,7 +115,21 @@ xstrdup (const char *s) char *ret; ret = strdup (s); - if (s == NULL) { + if (ret == NULL) { + fprintf (stderr, "Error: out of memory\n"); + exit (1); + } + + return ret; +} + +static char * +xstrndup (const char *s, size_t n) +{ + char *ret; + + ret = strndup (s, n); + if (ret == NULL) { fprintf (stderr, "Error: out of memory\n"); exit (1); } @@ -126,11 +155,11 @@ xasprintf (char **strp, const char *fmt, ...) static void item_init (item_t *item, - int count, + int score, const char *challenge, const char *response) { - item->count = count; + item->score = score; item->challenge = xmalloc (strlen (challenge) + 1 + strlen (response) + 1); @@ -157,6 +186,8 @@ category_init (category_t *category, category->items_size = 0; category->num_items = 0; category->items = NULL; + category->order = CATEGORY_ORDER_RANDOM; + category->bin_zero_head = 0; } static void @@ -186,7 +217,7 @@ category_grow (category_t *category) static item_t * category_add_item (category_t *category, - int count, + int score, const char *challenge, const char *response) { @@ -197,11 +228,23 @@ category_add_item (category_t *category, item = &category->items[category->num_items++]; - item_init (item, count, challenge, response); + item_init (item, score, challenge, response); return item; } +static item_t * +category_next_bin_zero_item (category_t *category) +{ + int *i = &category->bin_zero_head; + + for ( ; *i < category->num_items; *i = *i + 1) + if (category->items[*i].score == 0) + return &category->items[*i]; + + return NULL; +} + static void category_print (category_t *category, FILE *file) @@ -209,12 +252,15 @@ category_print (category_t *category, int i; item_t *item; + fprintf (file, "order = %s\n\n", + category->order == CATEGORY_ORDER_RANDOM ? "random" : "sequential"); + for (i = 0; i < category->num_items; i++) { item = &category->items[i]; if (i != 0) fprintf (file, "\n"); fprintf (file, "%d\n%s\n%s\n", - item->count, + item->score, item->challenge, item->response); } @@ -222,9 +268,9 @@ category_print (category_t *category, static void bin_init (bin_t *bin, - int count) + int score) { - bin->count = count; + bin->score = score; bin->items_size = 0; bin->num_items = 0; @@ -253,7 +299,7 @@ static void bin_add_item (bin_t *bin, item_t *item) { - assert (item->count == bin->count); + assert (item->score == bin->score); if (bin->num_items == bin->items_size) bin_grow (bin); @@ -273,6 +319,45 @@ bin_remove_item (bin_t *bin, bin->items[item_index] = bin->items[bin->num_items]; } +/* Find the index for an item within a bin. + * + * XXX: This is currently a linear search, so is a potential + * performance problem. + */ +static int +bin_item_index (bin_t *bin, + item_t *item) +{ + int i; + + for (i = 0; i < bin->num_items; i++) + if (bin->items[i] == item) + return i; + + assert (0); +} + +typedef int (item_match_predicate_t) (void *closure, item_t *item); + +/* Return the number of items in the bin from the given category (or + * from all categories if category == NULL) */ +static int +bin_num_items_matching (bin_t *bin, + item_match_predicate_t *predicate, + void *closure) +{ + int i, num_items = 0; + + if (predicate == NULL) + return bin->num_items; + + for (i = 0; i < bin->num_items; i++) + if ((predicate) (closure, bin->items[i])) + num_items++; + + return num_items; +} + static void mnemon_init (mnemon_t *mnemon) { @@ -291,6 +376,11 @@ mnemon_init (mnemon_t *mnemon) mnemon->bins_size = 0; mnemon->num_bins = 0; mnemon->bins = NULL; + + mnemon->to_introduce = 10; + mnemon->to_master = 10; + mnemon->unlearned = 0; + mnemon->mastered = -1; } static void @@ -321,17 +411,31 @@ mnemon_categories_grow (mnemon_t *mnemon) mnemon->categories_size * sizeof (category_t)); } +/* Get a category by name if it exists */ static category_t * -mnemon_get_category (mnemon_t *mnemon, - const char *name) +mnemon_get_category_if_exists (mnemon_t *mnemon, + const char *name) { int i; - category_t *category; for (i = 0; i < mnemon->num_categories; i++) if (strcmp (mnemon->categories[i].name, name) == 0) return &mnemon->categories[i]; + return NULL; +} + +/* Get a category by name, creating new one if necessary. */ +static category_t * +mnemon_get_category (mnemon_t *mnemon, + const char *name) +{ + category_t *category; + + category = mnemon_get_category_if_exists (mnemon, name); + if (category) + return category; + mnemon_categories_grow (mnemon); category = &mnemon->categories[mnemon->num_categories++]; @@ -355,26 +459,28 @@ mnemon_bins_grow (mnemon_t *mnemon) static bin_t * mnemon_get_bin (mnemon_t *mnemon, - int count) + int score) { int i; bin_t *bin; for (i = 0; i < mnemon->num_bins; i++) - if (mnemon->bins[i].count == count) + if (mnemon->bins[i].score == score) return &mnemon->bins[i]; - else if (mnemon->bins[i].count > count) + else if (mnemon->bins[i].score > score) break; - mnemon_bins_grow (mnemon); + if (mnemon->num_bins == mnemon->bins_size) + mnemon_bins_grow (mnemon); bin = &mnemon->bins[i]; /* Make room to insert new bin at its sorted location. */ - memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); + if (i < mnemon->num_bins) + memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); mnemon->num_bins++; - bin_init (bin, count); + bin_init (bin, score); return bin; } @@ -385,6 +491,8 @@ mnemon_remove_bin (mnemon_t *mnemon, { int i = bin - mnemon->bins; + bin_fini (bin); + memmove (bin, bin + 1, (mnemon->num_bins - i) * sizeof (bin_t)); mnemon->num_bins--; } @@ -399,6 +507,26 @@ chomp (char *s) s[len - 1] = '\0'; } +static char * +trim_space (char *string) +{ + char *s; + + s = string; + while (*s && isspace (*s)) + s++; + + string = s; + + s = string + strlen (string) - 1; + while (s > string && isspace (*s)) { + *s = '\0'; + s--; + } + + return string; +} + static void mnemon_load_category (mnemon_t *mnemon, const char *name) @@ -424,20 +552,72 @@ mnemon_load_category (mnemon_t *mnemon, category = mnemon_get_category (mnemon, name); +#define READ_LINE do { \ + bytes_read = getline (&line, &line_size, file); \ + if (bytes_read == -1) \ + goto END_OF_FILE; \ + line_count++; \ + chomp (line); \ +} while (0) + + /* Parse options */ + while (1) { + char *name, *equal, *value; + + /* Ignore blank lines */ + READ_LINE; + if (*line == '\0') + continue; + + /* An initial digit means we hit an item. Trigger the + * spaghetti machine. */ + if (*line >= '0' && *line <= '9') + goto PARSE_BIN; + + equal = strchr (line, '='); + if (equal == NULL) { + fprintf (stderr, "Malformed option, (expected name=value): \"%s\" at %s:%d\n", + line, path, line_count); + exit (1); + } + + value = equal + 1; + name = line; + *equal = '\0'; + + name = trim_space (name); + value = trim_space (value); + + if (strcmp (name, "order") == 0) { + if (strcmp (value, "sequential") == 0) { + category->order = CATEGORY_ORDER_SEQUENTIAL; + } else if (strcmp (value, "random") == 0) { + category->order = CATEGORY_ORDER_RANDOM; + } else { + fprintf (stderr, "Unknown value for \"order\" option \"%s\" at %s:%d\n", + value, path, line_count); + exit (1); + } + } else { + fprintf (stderr, "Unknown option %s at %s:%d\n", + name, path, line_count); + exit (1); + } + } + + /* Parse items */ while (1) { - int count; + int score; char *challenge, *response; - /* Read bin number (ignoring blank separator lines) */ - do { - bytes_read = getline (&line, &line_size, file); - if (bytes_read == -1) - goto END_OF_FILE; - line_count++; - chomp (line); - } while (*line == '\0'); + /* Ignore blank lines */ + READ_LINE; + if (*line == '\0') + continue; - count = strtol (line, &end, 10); + /* Read bin number */ + PARSE_BIN: + score = strtol (line, &end, 10); if (*end != '\0') { fprintf (stderr, "Failed to parse bin number from \"%s\" at %s:%d\n", line, path, line_count); @@ -445,22 +625,14 @@ mnemon_load_category (mnemon_t *mnemon, } /* Read challenge */ - bytes_read = getline (&line, &line_size, file); - if (bytes_read == -1) - break; - line_count++; - chomp (line); + READ_LINE; challenge = strdup (line); /* Read response */ - bytes_read = getline (&line, &line_size, file); - if (bytes_read == -1) - break; - line_count++; - chomp (line); + READ_LINE; response = line; - category_add_item (category, count, challenge, response); + category_add_item (category, score, challenge, response); free (challenge); } @@ -479,7 +651,7 @@ mnemon_load_category (mnemon_t *mnemon, * bin. */ for (i = 0; i < category->num_items; i++) { item_t *item = &category->items[i]; - bin_t *bin = mnemon_get_bin (mnemon, item->count); + bin_t *bin = mnemon_get_bin (mnemon, item->score); bin_add_item (bin, item); } @@ -543,7 +715,7 @@ mnemon_save (mnemon_t *mnemon) err = rename (lock_filename, filename); if (err < 0) { - fprintf (stderr, "Error: Failes to rename %s to %s: %s\n", + fprintf (stderr, "Error: Failed to rename %s to %s: %s\n", lock_filename, filename, strerror (errno)); continue; } @@ -605,20 +777,300 @@ rand_within_exponential (int num_values) return ones; } +/* Find the category to which an item belongs. */ +static category_t * +mnemon_item_category (mnemon_t *mnemon, + item_t *item) +{ + category_t *category; + int i, item_index; + + for (i = 0; i < mnemon->num_categories; i++) { + category = &mnemon->categories[i]; + item_index = item - category->items; + if (item_index >= 0 && item_index < category->num_items) + return category; + } + + assert (0); +} + +typedef struct _item_in_category_closure +{ + mnemon_t *mnemon; + category_t *category; +} item_in_category_closure_t; + +static int +mnemon_item_in_category (void *closure, item_t *item) +{ + item_in_category_closure_t *iicc = closure; + mnemon_t *mnemon = iicc->mnemon; + category_t *category = iicc->category; + + return (mnemon_item_category (mnemon, item) == category); +} + +typedef struct _item_in_category_of_length_closure +{ + mnemon_t *mnemon; + category_t *category; + int length; +} item_in_category_of_length_closure_t; + +static int +mnemon_item_in_category_of_length (void *closure, item_t *item) +{ + item_in_category_of_length_closure_t *iicolc = closure; + mnemon_t *mnemon = iicolc->mnemon; + category_t *category = iicolc->category; + int length = iicolc->length; + + if (mnemon_item_category (mnemon, item) != category) + return 0; + + return strlen (item->challenge) == length; +} + static void mnemon_select_item (mnemon_t *mnemon, bin_t **bin_ret, int *item_index_ret) { - int bin_index; + int bin_index, item_index; bin_t *bin; bin_index = rand_within_exponential (mnemon->num_bins); bin = &mnemon->bins[bin_index]; + item_index = rand_within (bin->num_items); + + if (bin->score == 0) { + category_t *category; + item_t *item; + + item = bin->items[item_index]; + + category = mnemon_item_category (mnemon, item); + + if (category->order == CATEGORY_ORDER_SEQUENTIAL) { + item = category_next_bin_zero_item (category); + if (item) + item_index = bin_item_index (bin, item); + } + } + *bin_ret = bin; - *item_index_ret = rand_within (bin->num_items); + *item_index_ret = item_index; +} + + +#define HISTOGRAM_ROW_FORMAT "%3d: %3d" +#define HISTOGRAM_BAR_WIDTH 63 + +static void +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, + const char *category_name, + int length) +{ + int i, last_score, max; + category_t *category = NULL; + bin_t *bin; + int num_items; + item_match_predicate_t *predicate = NULL; + void *closure = NULL; + item_in_category_closure_t item_in_category; + item_in_category_of_length_closure_t item_in_category_of_length; + + if (mnemon->num_bins == 0) + return; + + if (category_name) { + category = mnemon_get_category_if_exists (mnemon, category_name); + if (category) { + if (length) { + predicate = mnemon_item_in_category_of_length; + item_in_category_of_length.mnemon = mnemon; + item_in_category_of_length.category = category; + item_in_category_of_length.length = length; + closure = &item_in_category_of_length; + } else { + predicate = mnemon_item_in_category; + item_in_category.mnemon = mnemon; + item_in_category.category = category; + closure = &item_in_category; + } + } + } + + for (i = 0; i < mnemon->num_bins; i++) { + num_items = bin_num_items_matching (&mnemon->bins[i], + predicate, closure); + if (i == 0 || num_items > max) + max = 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); + num_items = bin_num_items_matching (bin, + predicate, closure); + printf (HISTOGRAM_ROW_FORMAT " ", bin->score, num_items); + print_histogram_bar (num_items, max); + last_score = bin->score; + } +} + +static void +mnemon_handle_command (mnemon_t *mnemon, + const char *command) +{ + const char *arg; + int len; + switch (command[0]) { + case 'h': + { + char *category = NULL; + int length = 0; + + arg = command + 1; + arg += strspn (arg, " \t"); + len = strcspn (arg, " \t"); + if (len) { + category = xstrndup (arg, len); + arg += len; + arg += strspn (arg, " \t"); + if (*arg) + length = atoi (arg); + } + mnemon_print_histogram (mnemon, category, length); + } + 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++; + 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--; + mnemon->to_master--; + 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? (%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 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--; + mnemon->to_master++; + } + } + + printf (" "); + if (mnemon->to_introduce) + printf ("%d to come. ", mnemon->to_introduce); + if (mnemon->unlearned) + printf ("%d still unlearned. ", mnemon->unlearned); + if (mnemon->to_introduce == 0 && mnemon->to_master > 0) + printf ("%d items to master", mnemon->to_master); + printf ("\n\n"); + + bin = mnemon_get_bin (mnemon, item->score); + + bin_add_item (bin, item); } static void @@ -628,45 +1080,68 @@ mnemon_do_challenges (mnemon_t *mnemon) int item_index; item_t *item; char *response; - bool_t correct; + int i; - while (1) { + /* Count the number of items with negative scores. */ + mnemon->unlearned = 0; + for (i = 0; i < mnemon->num_bins; i++) { + bin = &mnemon->bins[i]; + if (bin->score >= 0) + break; + mnemon->unlearned += bin->num_items; + } + + 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. */ + if (mnemon->to_introduce == 0) { + bin = mnemon_get_bin (mnemon, 0); + mnemon_remove_bin (mnemon, bin); + } + + 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 ("Introducing %d new items.\n", mnemon->to_introduce); + } + printf ("\n"); + + do { mnemon_select_item (mnemon, &bin, &item_index); item = bin->items[item_index]; - printf ("%s\n", item->challenge); + if (bin->score == 0) + mnemon->to_introduce--; - response = readline ("> "); - if (response == NULL) { - printf ("\n"); - break; - } + while (1) { + printf ("%s\n", item->challenge); - correct = (strcmp (response, item->response) == 0); + response = readline ("> "); + /* Terminate on EOF */ + if (response == NULL) { + printf ("\n"); + return; + } - bin_remove_item (bin, item_index); - if (bin->num_items == 0) - mnemon_remove_bin (mnemon, bin); - - if (correct) { - printf ("Correct!\n\n"); - if (item->count < 0) - item->count = 1; - else - item->count++; - } else { - printf (" %s is the correct answer.\n\n", - item->response); - if (item->count > 0) - item->count = -1; + if (response[0] == '/') + mnemon_handle_command (mnemon, response + 1); else - item->count--; + break; } - bin = mnemon_get_bin (mnemon, item->count); + mnemon_handle_response (mnemon, bin, item_index, + item, response); + } while (mnemon->to_introduce || + mnemon->unlearned || + mnemon->to_master > 0); - bin_add_item (bin, item); - } + printf ("Great job.\n"); } int @@ -674,7 +1149,7 @@ main (int argc, char *argv[]) { mnemon_t mnemon; - srand (1); + srand (time (NULL)); mnemon_init (&mnemon);