3f5569a6adf57680b3a311a78c739cb158dbe629
kent
  Fri Sep 21 15:31:46 2012 -0700
Improving readability.
diff --git src/kehayden/alphaAsm/alphaAsm.c src/kehayden/alphaAsm/alphaAsm.c
index 93ac2ba..4ff40a7 100644
--- src/kehayden/alphaAsm/alphaAsm.c
+++ src/kehayden/alphaAsm/alphaAsm.c
@@ -285,31 +285,31 @@
 for (child = wt->children; child != NULL; child = child->next)
     {
     double childRatio = (double)child->useCount / childrenTotalUses;
     wordTreeNormalize(child, childRatio*outTarget, childRatio*normVal);
     }
 }
 
 char *wordTreeString(struct wordTree *wt)
 /* Return something like '(a b c)' where c would be the value at wt itself, and
  * a and b would be gotten by following parents. */
 {
 struct slName *list = NULL, *el;
 for (;wt != NULL; wt = wt->parent)
     {
     char *word = wt->monomer->word;
-    if (!isEmpty(word))   // Avoid blank great grandparent
+    if (!isEmpty(word))   // Avoid blank great grandparent at root of tree.
 	slNameAddHead(&list, word);
     }
 
 struct dyString *dy = dyStringNew(0);
 dyStringAppendC(dy, '(');
 for (el = list; el != NULL; el = el->next)
    {
    dyStringPrintf(dy, "%s", el->name);
    if (el->next != NULL)
        dyStringAppendC(dy, ' ');
    }
 dyStringAppendC(dy, ')');
 slFreeList(&list);
 return dyStringCannibalize(&dy);
 }
@@ -344,39 +344,39 @@
     fprintf(f, "%d\t%d\t%d\t%d\t%f\t", 
 	    level, wt->useCount, wt->outTarget, wt->outCount, wt->normVal);
     
     for (i=1; i<=level; ++i)
 	{
 	spaceOut(f, level*2);
 	fprintf(f, "%s ", words[i]);
 	}
     fprintf(f, "\n");
     }
 struct wordTree *child;
 for (child = wt->children; child != NULL; child = child->next)
     wordTreeDump(level+1, child, maxChainSize, f);
 }
 
-struct wordTree *pickRandom(struct wordTree *list)
+struct wordTree *pickWeightedRandomFromList(struct wordTree *list)
 /* Pick word from list randomly, but so that words with higher outTargets
  * are picked more often. */
 {
 struct wordTree *picked = NULL;
 
 /* Debug output. */
     {
-    verbose(2, "   pickRandom(");
+    verbose(2, "   pickWeightedRandomFromList(");
     struct wordTree *wt;
     for (wt = list; wt != NULL; wt = wt->next)
         {
 	if (wt != list)
 	    verbose(2, " ");
 	verbose(2, "%s:%d", wt->monomer->word, wt->outTarget);
 	}
     verbose(2, ") total %d\n", wordTreeSumOutTargets(list));
     }
 
 /* Figure out total number of outputs left, and a random number between 0 and that total. */
 int total = wordTreeSumOutTargets(list);
 if (total > 0)
     {
     int threshold = rand() % total; 
@@ -459,31 +459,31 @@
  * have statistics for what comes next given the words in list, then it returns
  * NULL. */
 {
 verbose(2, "  predictNextFromAllPredecessors(%s, %s)\n", wordTreeString(wt), dlListFragWords(list));
 struct dlNode *node;
 for (node = list; !dlEnd(node); node = node->next)
     {
     struct monomer *monomer = node->val;
     wt = wordTreeFindInList(wt->children, monomer);
     verbose(2, "   wordTreeFindInList(%s) = %p %s\n", monomer->word, wt, wordTreeString(wt));
     if (wt == NULL || wt->children == NULL)
         break;
     }
 struct wordTree *result = NULL;
 if (wt != NULL && wt->children != NULL)
-    result = pickRandom(wt->children);
+    result = pickWeightedRandomFromList(wt->children);
 return result;
 }
 
 struct wordTree *predictFromWordTree(struct wordTree *wt, struct dlNode *recent)
 /* Predict next word given tree and recently used word list.  Will use all words in
  * recent list if can,  but if there is not data in tree, will back off, and use
  * progressively less previous words. */
 {
 struct dlNode *node;
 verbose(2, " predictNextFromWordTree(%s)\n", wordTreeString(wt));
 
 for (node = recent; !dlEnd(node); node = node->next)
     {
     struct wordTree *result = predictNextFromAllPredecessors(wt, node);
     if (result != NULL)
@@ -573,31 +573,31 @@
     }
 verbose(2, "predictFromPreviousTypes past all unknown types\n");
 return NULL;
 }
 
 
 struct wordTree *predictNext(struct alphaStore *store, struct dlList *past)
 /* Given input data store and what is known from the past, predict the next word. */
 {
 struct dlNode *recent = nodesFromTail(past, store->maxChainSize);
 struct wordTree *pick =  predictFromWordTree(store->markovChains, recent);
 if (pick == NULL)
     pick = predictFromPreviousTypes(store, past);
 if (pick == NULL)
     {
-    pick = pickRandom(store->markovChains->children);
+    pick = pickWeightedRandomFromList(store->markovChains->children);
     warn("in predictNext() last resort pick of %s", pick->monomer->word);
     }
 return pick;
 }
 
 void decrementOutputCountsInTree(struct wordTree *wt)
 /* Decrement output count of self and parents. */
 {
 while (wt != NULL)
     {
     /* Decrement target count, but don't let it fall below sum of counts of all children. 
      * This can happen with incomplete data if we don't prevent it.  This
      * same code also prevents us from having negative outTarget. */
     int outTarget = wt->outTarget - 1;
     int kidSum = wordTreeSumOutTargets(wt->children);
@@ -1221,31 +1221,32 @@
 struct alphaStore *store = alphaStoreNew(maxChainSize);
 alphaReadListFromFile(readsFile, store);
 alphaStoreLoadMonomerOrder(store, readsFile, monomerOrderFile);
 fillInTypes(store);
 integrateOrphans(store);
 makeMarkovChains(store);
 struct wordTree *wt = store->markovChains;
 alphaStoreNormalize(store, outSize);
 
 if (optionExists("chain"))
     {
     char *fileName = optionVal("chain", NULL);
     wordTreeWrite(wt, store->maxChainSize, fileName);
     }
 
-wordTreeGenerateFile(store, store->maxChainSize, pickRandom(wt->children), outSize, outFile);
+wordTreeGenerateFile(store, store->maxChainSize, 
+    pickWeightedRandomFromList(wt->children), outSize, outFile);
 
 if (optionExists("afterChain"))
     {
     char *fileName = optionVal("afterChain", NULL);
     wordTreeWrite(wt, store->maxChainSize, fileName);
     }
 }
 
 int main(int argc, char *argv[])
 /* Process command line. */
 {
 optionInit(&argc, argv, options);
 if (argc != 4)
     usage();
 maxChainSize = optionInt("size", maxChainSize);