Commits

Anonymous committed d6cc8c8

minor typo corrections

Comments (0)

Files changed (7)

first-stage/PARSE/Bchart.C

     depth(0),
     curDir(-1),
     gcurVal(NULL),
-    alreadyPopedNum( 0 )
+    alreadyPoppedNum( 0 )
 {
   pretermNum = 0;
   heap = new EdgeHeap();
     curDir(-1),
     gcurVal(NULL),
     extraPos(extPos),
-    alreadyPopedNum( 0 )
+    alreadyPoppedNum( 0 )
 {
   pretermNum = 0;
   heap = new EdgeHeap();
 ~Bchart()
 {
   int i;
-  for(i = 0 ; i < alreadyPopedNum ; i++)
-    delete alreadyPoped[i];
+  for(i = 0 ; i < alreadyPoppedNum ; i++)
+    delete alreadyPopped[i];
   delete heap;
 }
 
 parse()
 {
   initDenom();
-    alreadyPopedNum = 0;
+    alreadyPoppedNum = 0;
     
     bool   haveS = false;
     int locTimeout = ruleiCountTimeout_;
     for (;;)
     {
       //check();
-      if( ruleiCounts_ > locTimeout || popedEdgeCount_ > poppedTimeout_)
+      if( ruleiCounts_ > locTimeout || poppedEdgeCount_ > poppedTimeout_)
 	{
 	  if(printDebug(5)) cerr << "Ran out of time" << endl;
 	  break;
 	{
 	  // once we have found a parse, the total edes is set to edges * 3.5;
 	  haveS = true;
-	  if(printDebug(10)) cerr << "Found S " << popedEdgeCount_ << endl;
-	  popedEdgeCountAtS_ = popedEdgeCount_;
+	  if(printDebug(10)) cerr << "Found S " << poppedEdgeCount_ << endl;
+	  poppedEdgeCountAtS_ = poppedEdgeCount_;
 	  totEdgeCountAtS_ = ruleiCounts_;
 	  int newTime = (int)(ruleiCounts_ * timeFactor);  
 	  if(newTime < ruleiCountTimeout_)
 	  if(printDebug(5)) cerr << "Over or underflow" << endl;
 	  break;
 	}
-      if(alreadyPopedNum >= 400000)
+      if(alreadyPoppedNum >= 400000)
 	{
-	  if(printDebug(5)) cerr << "alreadyPoped got too large" << endl;
+	  if(printDebug(5)) cerr << "alreadyPopped got too large" << endl;
 	  break;
 	}
       if(printDebug() > 10)
 	{
-	  cerr << popedEdgeCount_ << "\tPop";
+	  cerr << poppedEdgeCount_ << "\tPop";
 	  if(stus == 0) cerr << "< ";
 	  else if(stus == 2) cerr << ". ";
 	  else cerr << "> ";
 	  cerr << "\t" << ruleiCounts_;
 	  cerr << endl;
 	}
-      popedEdgeCount_++;
-      alreadyPoped[alreadyPopedNum++] = edge;
+      poppedEdgeCount_++;
+      alreadyPopped[alreadyPoppedNum++] = edge;
       if(!haveS) addToDemerits(edge);
       /* and add it to chart */
       //heap->check();
     globalGi[thrdid] = NULL;
     if(newEdge->merit() == 0)
       {
-	assert(alreadyPopedNum < 450000);
-	alreadyPoped[alreadyPopedNum++] = newEdge;
+	assert(alreadyPoppedNum < 450000);
+	alreadyPopped[alreadyPoppedNum++] = newEdge;
 	Edge* prd = newEdge->pred();
 	if(prd) prd->sucs().pop_front();
 	return;
 		  newEdge->start(), newEdge->loc());
   if(regi)
     {
-      /* redoP is a crutial function.  It uses to probability of the edge
+      /* redoP is a crucial function.  It uses the probability of the edge
 	 to see what the new prob of regi should be, and if it is over
-	 the threshold for propogating probs, It will recursively
+	 the threshold for propogating probs, it will recursively
 	 do this up the chart. */
       redoP(regi, newEdge->prob());
     }

first-stage/PARSE/Bchart.h

     void   addToDemerits(Edge* edge);
     static Item*    stops[MAXSENTLEN];
     EdgeHeap*       heap;
-    int             alreadyPopedNum;
-    Edge*           alreadyPoped[450000]; //was 350000;
+    int             alreadyPoppedNum;
+    Edge*           alreadyPopped[450000]; //was 350000;
     static int&     posStarts(int i, int j);
     static int      posStarts_[MAXNUMNTTS][MAXNUMNTS];
   int     curDemerits_[MAXSENTLEN][MAXSENTLEN];

first-stage/PARSE/ChartBase.C

   sentence_( sentence ),
   crossEntropy_(0.0L), 
   wrd_count_(0),
-  popedEdgeCount_(0),
+  poppedEdgeCount_(0),
   ruleiCounts_(0)
 {
 #ifdef DEBUG

first-stage/PARSE/ChartBase.h

     const Items&    items( int i, int j ) const
 		    {   return regs[ i ][ j ];   }
     int             edgeCount() const    { return ruleiCounts_; }
-    int             popedEdgeCount() const    { return popedEdgeCount_; }
-    int             popedEdgeCountAtS() const    { return popedEdgeCountAtS_; }
+    int             poppedEdgeCount() const    { return poppedEdgeCount_; }
+    int             poppedEdgeCountAtS() const    { return poppedEdgeCountAtS_; }
     int             totEdgeCountAtS() const    { return totEdgeCountAtS_; }
     Item*           addtochart(const Term* trm);
     // printing information about the parse.
     list<Edge*>     waitingEdges[2][MAXSENTLEN];
     double          crossEntropy_;
     int             wrd_count_;
-    int             popedEdgeCount_;
+    int             poppedEdgeCount_;
     int             totEdgeCountAtS_;
-    int             popedEdgeCountAtS_;
+    int             poppedEdgeCountAtS_;
     int             ruleiCounts_; // keeps track of how many edges have been
                                 // created --- used to time out the parse
     Item*           pretermItems[4000];

first-stage/PARSE/EgsFromTree.C

       Edge*   newEdge = new Edge(*prevEdge, *item, 0);
       prevEdge  = newEdge;
       cerr << "ae1 " << *item << " " << *newEdge << endl;
-      alreadyPoped[alreadyPopedNum++] = newEdge;  //so it will be gced.;
+      alreadyPopped[alreadyPoppedNum++] = newEdge;  //so it will be gced.;
       if(item->term() != Term::stopTerm) item->needme().push_back(newEdge);
       if(pos > 0) ii--;
     }
       Edge*   newEdge = new Edge(*prevEdge, *item, 1);
       prevEdge  = newEdge;
       cerr << "ae2 " << *item << " " << *newEdge << endl;
-      alreadyPoped[alreadyPopedNum++] = newEdge;  //so it will be gced.;
+      alreadyPopped[alreadyPoppedNum++] = newEdge;  //so it will be gced.;
       if(item->term() != Term::stopTerm) item->needme().push_back(newEdge);
     }
   prevEdge->setFinishedParent( lhs );    

first-stage/PARSE/TimeIt.C

   if(elapsedTime < 0) elapsedTime += 2147;
   cerr << "Parsing time = " << elapsedTime
        << "\tEdges created = " << chart->totEdgeCountAtS()
-       << "\tEdges poped = " << chart->popedEdgeCountAtS() << endl;
+       << "\tEdges popped = " << chart->poppedEdgeCountAtS() << endl;
   totParseTime += elapsedTime;
   //totEdges += chart->totEdgeCountAtS();
-  //totPopedEdges += chart->popedEdgeCountAtS();
+  //totPoppedEdges += chart->poppedEdgeCountAtS();
   totEdges += chart->totEdgeCountAtS();
-  totPopedEdges += chart->popedEdgeCountAtS();
+  totPoppedEdges += chart->poppedEdgeCountAtS();
   lastTime = clock();
 }
 
        << totSemParseTime/totSents
        << "\nAv edges created = "
        << (float)totEdges/totSents
-       << "\tAv edges poped = "
-       << (float)totPopedEdges/totSents
+       << "\tAv edges popped = "
+       << (float)totPoppedEdges/totSents
        << endl;
 }

first-stage/PARSE/TimeIt.h

  public:
   TimeIt() :
     totEdges(0),
-    totPopedEdges(0),
+    totPoppedEdges(0),
     totAccessTime(0),
     totParseTime(0),
     totSemParseTime(0)
   void aftSent();
   void finish(int totSents);
   int    totEdges;
-  int    totPopedEdges;
+  int    totPoppedEdges;
   double totAccessTime;
   double totParseTime;
   double totSemParseTime;
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.