#include <math.h>
#include <sys/types.h>
+#include <sys/time.h>
#include <dirent.h>
#include <errno.h>
#include <string.h>
/* Support sequential introduction of items from bin 0 */
category_order_t order;
+ /* Support categories where responses are timed (0.0 == disable). */
+ double time_limit;
int bin_zero_head;
} category_t;
category->num_items = 0;
category->items = NULL;
category->order = CATEGORY_ORDER_RANDOM;
+ category->time_limit = 0.0;
category->bin_zero_head = 0;
}
fprintf (file, "order = %s\n\n",
category->order == CATEGORY_ORDER_RANDOM ? "random" : "sequential");
+ fprintf (file, "time = %f\n\n",
+ category->time_limit);
for (i = 0; i < category->num_items; i++) {
item = &category->items[i];
mnemon->bins = NULL;
mnemon->to_introduce = 10;
- mnemon->to_master = 0;
+ mnemon->to_master = 10;
mnemon->unlearned = 0;
mnemon->mastered = -1;
}
value, path, line_count);
exit (1);
}
+ } else if (strcmp (name, "time") == 0) {
+ double limit;
+ char *end;
+ limit = strtod (value, &end);
+ while (isspace (*end))
+ end++;
+ if (*end == '\0') {
+ category->time_limit = limit;
+ } else {
+ fprintf (stderr, "Failed to parse time value: %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);
static void
mnemon_select_item (mnemon_t *mnemon,
bin_t **bin_ret,
- int *item_index_ret)
+ int *item_index_ret,
+ category_t **category_ret)
{
int bin_index, item_index;
bin_t *bin;
+ item_t *item;
+ category_t *category;
bin_index = rand_within_exponential (mnemon->num_bins);
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);
+ item = bin->items[item_index];
+ category = mnemon_item_category (mnemon, item);
+ if (bin->score == 0) {
if (category->order == CATEGORY_ORDER_SEQUENTIAL) {
item = category_next_bin_zero_item (category);
if (item)
*bin_ret = bin;
*item_index_ret = item_index;
+ *category_ret = category;
}
bin_t *bin,
int item_index,
item_t *item,
- const char *response)
+ const char *response,
+ double response_time,
+ double time_limit)
{
bool_t correct;
mnemon_remove_bin (mnemon, bin);
}
- if (correct) {
+ if (correct &&
+ (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--;
+ mnemon->to_master--;
printf ("You got it!");
} else if (item->score < 0) {
printf ("Yes---just give me %d more.",
printf ("On your first try, no less!");
} else {
printf ("Masterful (%dx).", item->score);
- if (mnemon->to_master)
- mnemon->mastered++;
}
} else {
- printf (" %s is the correct answer.",
- item->response);
+ if (! correct)
+ printf (" %s is the correct answer.",
+ item->response);
+ else
+ printf ("Correct, but not quite quick enough (%0.2f seconds---needed %0.2f seconds)\n",
+ response_time, time_limit);
/* Penalize an incorrect response by forcing the score
* negative. */
if (item->score >= 0) {
if (item->score > 0)
- printf ( " Oops, you knew that, right?\n ");
+ 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
item->score = -2;
} else {
item->score--;
+ mnemon->to_master++;
}
}
- if (mnemon->to_introduce == 0 &&
- mnemon->unlearned == 0 &&
- mnemon->to_master == 0)
- {
- mnemon->to_master = 10;
- mnemon->mastered = 0;
- }
-
printf (" ");
if (mnemon->to_introduce)
printf ("%d to come. ", mnemon->to_introduce);
if (mnemon->unlearned)
printf ("%d still unlearned. ", mnemon->unlearned);
- if (mnemon->to_master) {
- if (mnemon->mastered < mnemon->to_master)
- printf ("%d items to master",
- mnemon->to_master - mnemon->mastered);
- else
- printf ("Great job!");
- }
+ 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_t *bin;
int item_index;
item_t *item;
+ category_t *category;
char *response;
int i;
printf ("\n");
do {
- mnemon_select_item (mnemon, &bin, &item_index);
+ struct timeval start, end;
+
+ mnemon_select_item (mnemon, &bin, &item_index, &category);
item = bin->items[item_index];
if (bin->score == 0)
mnemon->to_introduce--;
while (1) {
+ if (category->time_limit > 0.0) {
+ response = readline ("The next one is timed. Press enter when ready:");
+ free (response);
+ }
+
printf ("%s\n", item->challenge);
+ gettimeofday (&start, NULL);
response = readline ("> ");
+ gettimeofday (&end, NULL);
+
/* Terminate on EOF */
if (response == NULL) {
printf ("\n");
return;
}
- if (response[0] == '/')
+ if (response[0] == '/') {
mnemon_handle_command (mnemon, response + 1);
- else
+ free (response);
+ } else {
break;
+ }
}
mnemon_handle_response (mnemon, bin, item_index,
- item, response);
- } while (mnemon->mastered < mnemon->to_master);
+ item, response,
+ (end.tv_sec + end.tv_usec / 1e6) -
+ (start.tv_sec + start.tv_usec / 1e6),
+ category->time_limit);
+ free (response);
+ } while (mnemon->to_introduce ||
+ mnemon->unlearned ||
+ mnemon->to_master > 0);
}
int
main (int argc, char *argv[])
{
mnemon_t mnemon;
+ char *response;
srand (time (NULL));
mnemon_fini (&mnemon);
+ mnemon_init (&mnemon);
+ mnemon_load (&mnemon);
+
+ printf ("Great job.\nHere are your current results:\n");
+ mnemon_print_histogram (&mnemon, NULL, 0);
+ response = readline ("Press enter to quit.\n");
+ free (response);
+
+ mnemon_fini (&mnemon);
+
return 0;
}
projects / mnemon / blobdiff