MiniLexicon.cpp

   1 // Implementation of core CMiniLexicon methods
   2 // Copyright © 2009 The University of Chicago
   3 #include "MiniLexicon.h"
   4
   5 #include <iostream>
   6 #include <Q3TextStream>
   7 #include <QTime>
   8 #include "Lexicon.h"
   9 #include "GUIclasses.h"
  10 #include "FSA.h"
  11 #include "DescriptionLength.h"
  12 #include "Datum.h"
  13 #include "Stem.h"
  14 #include "SignatureCollection.h"
  15 #include "PrefixCollection.h"
  16 #include "SuffixCollection.h"
  17 #include "WordCollection.h"
  18 #include "StemCollection.h"
  19 #include "POSCollection.h"
  20 #include "AffixLocation.h"
  21 #include "log2.h"
  22 #include "Suffix.h"
  23 #include "Prefix.h"
  24 #include "HTML.h"
  25
  26 CMiniLexicon::CMiniLexicon(CLexicon* lexicon, int index,
  27                         enum eAffixLocation affixLocation)
  28         : m_pLexicon(lexicon),
  29         m_Index(index),
  30         m_AffixLocation(affixLocation),
  31         m_pWords(new CWordCollection(this)),
  32         m_pSuffixes(is_initial(affixLocation) ?
  33                         0 :
  34                         new CSuffixCollection(this)),
  35         m_pPrefixes(is_initial(affixLocation) ?
  36                         new CPrefixCollection(this) :
  37                         0),
  38         m_pStems(new CStemCollection(this)),
  39         m_pSignatures(is_initial(affixLocation) ?
  40                 new CSignatureCollection(this, m_pPrefixes, affixLocation) :
  41                 new CSignatureCollection(this, m_pSuffixes, affixLocation)),
  42         m_pPOS(),
  43         m_DescriptionLength(),
  44         m_CorpusCountOfUnanalyzedWords(0.0),
  45         m_PhonologicalInformationOfUnanalyzedWords(0.0),
  46         m_GUIWords(new GUIWordCollection(this, m_pWords)),
  47         m_DataMap()
  48         //m_pFSA(0)
  49         { }
  50
  51 CMiniLexicon::~CMiniLexicon()
  52 {
  53         // Update corpus words when deleting mini-lexicon
  54         for (int i = 0; i < m_pWords->GetCount(); ++i) {
  55                 CStem* word = m_pWords->GetAt(i);
  56
  57                 word->SimplifyParseStructure();
  58                 m_pLexicon->UpdateWord(word);
  59         }
  60         m_pLexicon->DoWordUpdates();
  61
  62         delete m_pWords;
  63         delete m_pSuffixes;
  64         delete m_pPrefixes;
  65         delete m_pStems;
  66         delete m_pSignatures;
  67         delete m_pPOS;
  68         delete m_DescriptionLength;
  69         delete m_GUIWords;
  70         //delete m_pFSA;
  71 }
  72
  73 void CMiniLexicon::AddToScreen( QString msg )
  74 {
  75   m_pLexicon->AddToScreen( msg );
  76 }
  77
  78 GUIWordCollection* CMiniLexicon::GetGUIWords()
  79 {
  80     return m_GUIWords;
  81 }
  82
  83 int CMiniLexicon::GetCorpusCount()
  84 {
  85         return m_pLexicon->GetCorpusCount();
  86 }
  87
  88
  89 int CMiniLexicon::GetNumberOfCharacterTypes()
  90 {
  91         return m_pLexicon->GetNumberOfCharacterTypes();
  92 }
  93
  94
  95 CDLHistory* CMiniLexicon::GetDLHistory()
  96 {
  97         return m_pLexicon->GetDLHistory();
  98 }
  99
 100 CStem* CMiniLexicon::GetWordFromStemSuffix(CStem* pStem, CSuffix* pSuffix)
 101 {
 102     if (pSuffix->Display() == TheStringNULL)
 103     {
 104         return *m_pWords ^= pStem->Display();
 105     }
 106     else
 107     {
 108         return *m_pWords ^= pStem->Display() + pSuffix->Display();
 109     }
 110 }
 111 CStem* CMiniLexicon::GetWordFromStemPrefix(CStem* pStem, CPrefix* pPrefix)
 112 {
 113     if (pPrefix->Display() == TheStringNULL)
 114     {
 115         return *m_pWords ^= pStem->Display();
 116     }
 117     else
 118     {
 119         return *m_pWords ^= pPrefix->Display() + pStem->Display();
 120     }
 121 }
 122 void CMiniLexicon::AddToWordCollection(CWordCollection* pWords,
 123         enum which_words subset)
 124 {
 125         CStem* pWord, * qWord;
 126         int w;
 127         CStringSurrogate css;
 128
 129         for( w = 0; w < (int) pWords->GetCount(); w++ )
 130         {
 131                 pWord = pWords->GetAt(w);
 132
 133                 switch (subset) {
 134                 case WW_All:
 135                         qWord = (*m_pWords) << pWord;
 136                         qWord->SetWordType( pWord->GetWordType() );
 137                         break;
 138                 case WW_AnalyzedOnly:
 139                         if( pWord->Size() > 1 )
 140                         {
 141                                 qWord = (*m_pWords) << pWord;
 142                                 qWord->SetWordType( pWord->GetWordType() );
 143                         }
 144                         break;
 145                 case WW_UnanalyzedOnly:
 146                 default:
 147                         if( pWord->Size() <= 1 )
 148                         {
 149                                 qWord = (*m_pWords) << pWord;
 150                                 qWord->SetWordType( pWord->GetWordType() );
 151                         }
 152                         break;
 153                 }
 154         }
 155 }
 156
 157
 158 void CMiniLexicon::AddToWordCollection( CStemCollection* pWords )
 159 {
 160         for (int w = 0; w < pWords->GetCount(); ++w) {
 161                 CStem* pWord = pWords->GetAt(w);
 162                 CStem* qWord = (*m_pWords) << pWord;
 163
 164                 const bool compound =
 165                         pWord->GetStemType() == CStem::BIWORD_COMPOUND ||
 166                         pWord->GetStemType() == CStem::MULTIPLE_COMPOUND;
 167                 qWord->SetWordType(compound ?
 168                         CStem::STEM_COMPOUND : CStem::STEM_NORMAL);
 169         }
 170 }
 171
 172
 173 void CMiniLexicon::ClearAll()
 174 {
 175   if( m_pStems ) m_pStems->Empty();
 176   if( m_pWords ) m_pWords->Empty();
 177
 178   if( m_pSuffixes ) m_pSuffixes->Empty();
 179   if( m_pPrefixes ) m_pPrefixes->Empty();
 180
 181   if( m_pSignatures ) m_pSignatures->Empty();
 182 }
 183
 184
 185 CCorpusWord*  CMiniLexicon::FindAWord(CStem* pStem, CSuffix* pSuffix)
 186 {
 187   return m_pLexicon->FindAWord(pStem, pSuffix);
 188 }
 189
 190
 191 CSuffixCollection* CMiniLexicon::FindSuffixes() //Suffixes/Run all
 192 {
 193         QTime t;
 194         t.start();
 195
 196         QString mini_name( "Mini-Lexicon %1" );
 197         mini_name = mini_name.arg( m_Index );
 198
 199         QString remark;
 200
 201         if( m_AffixLocation == STEM_FINAL || m_AffixLocation == WORD_FINAL )
 202         {
 203                 m_pWords->SuccessorFreq1(GetStems(),
 204                         GetSuffixes(), GetSignatures(), SF1,
 205                         CStem::NUMBER | CStem::UNKNOWN);
 206
 207
 208                 CheckSignatures();
 209
 210
 211                 ExtendKnownStemsToKnownAffixes();
 212                 TakeSignaturesFindStems();
 213                 TakeSignaturesFindStems();
 214                 ExtendKnownStemsToKnownAffixes();
 215                 FromStemsFindAffixes(); // problem here @@@ oct 2008 jg
 216
 217                 LooseFit();
 218
 219                 CheckSignatures();
 220
 221                FindSingletonSignatures(); //problem here jan 2010
 222
 223                 CheckSignatures();
 224
 225                 FindMajorSignatures();
 226                 m_pWords->m_DisplayMode = CWordListViewItem::MiniLexicon_MorphologyStuffFirst;
 227                 CalculateDescriptionLength();
 228
 229
 230
 231                 FindAllomorphy();
 232                 this->m_pLexicon->SetFSA(new FSA(this));
 233
 234         }
 235
 236         std::cout << "Find Suffixes: Time elapsed: " <<
 237         t.elapsed() << "ms." << std::endl;
 238
 239         return m_pSuffixes;
 240 }
 241
 242
 243 CPrefixCollection* CMiniLexicon::FindPrefixes()
 244 {
 245         if( m_AffixLocation == STEM_INITIAL || m_AffixLocation == WORD_INITIAL )
 246         {
 247                 QTime t;
 248                 t.start();
 249
 250                 m_pWords->CreateReverseTrie();
 251
 252                 m_pWords->PredecessorFreq1(GetStems(),
 253                         GetPrefixes(), GetSignatures(), SF1,
 254                         CStem::NUMBER | CStem::UNKNOWN);
 255
 256                 CheckSignatures();
 257
 258                 ExtendKnownStemsToKnownAffixes();
 259
 260                 TakeSignaturesFindStems();
 261
 262                 ExtendKnownStemsToKnownAffixes();
 263
 264                 FromStemsFindAffixes();
 265
 266                 ExtendKnownStemsToKnownAffixes();
 267
 268                 LooseFit();
 269
 270                 CheckSignatures();
 271
 272                 FindSingletonSignatures();
 273
 274                 std::cout << "Find Prefixes: Time elapsed: " <<
 275                 t.elapsed() << "ms." << std::endl;
 276
 277                 if(this->m_pLexicon->GetFSA())
 278                         this->m_pLexicon->GetFSA()->AddPrefixes(this);
 279
 280                 return m_pPrefixes;
 281         }
 282         else return NULL;
 283 }
 284
 285
 286 LinguisticaMainWindow*  CMiniLexicon::GetDocument()
 287 {
 288   return m_pLexicon->GetDocument();
 289 }
 290
 291 int CMiniLexicon::GetIntParameter( QString strParam, int iDefault )
 292 {
 293   return m_pLexicon->GetIntParameter( strParam, iDefault );
 294 }
 295
 296
 297 QTextStream* CMiniLexicon::GetLogFile()
 298 {
 299   return m_pLexicon->GetLogFileStream();
 300 }
 301
 302
 303 int CMiniLexicon::GetMiniCount()
 304 {
 305   return m_pLexicon->GetMiniCount();
 306 }
 307
 308
 309 int CMiniLexicon::GetMiniSize()
 310 {
 311   return m_pLexicon->GetMiniSize();
 312 }
 313
 314
 315 CMiniLexicon* CMiniLexicon::GetMiniLexicon( int index )
 316 {
 317   return m_pLexicon->GetMiniLexicon( index );
 318 }
 319
 320
 321 StringToString* CMiniLexicon::GetOutFilter()
 322 {
 323   return m_pLexicon->GetOutFilter();
 324 }
 325
 326
 327 bool CMiniLexicon::LogFileOn()
 328 {
 329         return (CLexicon*)m_pLexicon->LogFileOn();
 330 }
 331
 332
 333 bool CMiniLexicon::SetAffixLocation(enum eAffixLocation affixLoc)
 334 {
 335         if (m_AffixLocation == affixLoc)
 336                 // done, without lifting a finger!
 337                 return true;
 338
 339         if (is_initial(m_AffixLocation) == is_initial(affixLoc)) {
 340                 m_AffixLocation = affixLoc;
 341                 return true;
 342         }
 343
 344         // Affix types differ: throw away discoveries.
 345
 346         if (m_pStems->GetCount() != 0)
 347                 // someone else could be using our discovered stems
 348                 return false;
 349
 350         if (is_initial(affixLoc)) {
 351                 Q_ASSERT(m_pPrefixes == 0);
 352                 m_pPrefixes = new CPrefixCollection(this);
 353
 354                 delete m_pSuffixes;
 355                 m_pSuffixes = 0;
 356         } else {
 357                 delete m_pPrefixes;
 358                 m_pPrefixes = 0;
 359
 360                 Q_ASSERT(m_pSuffixes == 0);
 361                 m_pSuffixes = new CSuffixCollection(this);
 362         }
 363
 364         m_AffixLocation = affixLoc;
 365
 366         delete m_pSignatures;
 367         m_pSignatures = is_initial(affixLoc) ?
 368                 new CSignatureCollection(this, m_pPrefixes, affixLoc) :
 369                 new CSignatureCollection(this, m_pSuffixes, affixLoc);
 370         return true;
 371 }
 372
 373 int     CMiniLexicon::GetCorpusCountOfUnanalyzedWords           ( )
 374 {
 375         int i = 0;
 376
 377
 378         m_CorpusCountOfUnanalyzedWords = 0;
 379
 380                 if ( GetAffixLocation() == WORD_FINAL || GetAffixLocation() == STEM_FINAL )
 381                 {
 382                         for (i = 0; i < m_pWords->GetCount(); i++)
 383                         {
 384                                 if ( 0 == m_pWords->GetAt(i)->GetSuffixSignature() )
 385                                 {
 386                                         m_CorpusCountOfUnanalyzedWords += m_pWords->GetAt(i)->GetCorpusCount();
 387                                 }
 388                         }
 389                 }
 390                 else if (  GetAffixLocation() == WORD_INITIAL || GetAffixLocation() == STEM_INITIAL )
 391
 392                 {
 393                         for (i = 0; i < m_pWords->GetCount(); i++)
 394                         {
 395                                 if ( 0 == m_pWords->GetAt(i)->GetPrefixSignature() )
 396                                 {
 397                                         m_CorpusCountOfUnanalyzedWords += m_pWords->GetAt(i)->GetCorpusCount();
 398                                 }
 399                         }
 400                 }
 401
 402         return (int) m_CorpusCountOfUnanalyzedWords;
 403 }
 404 double CMiniLexicon::CalculateSumOfPointersToMyUnanalyzedWords ( eMDL_STYLE MDLflag)
 405 {
 406         int     i = 0;
 407         double  total = 0;
 408         double  denominator = 0;
 409
 410         switch (MDLflag)
 411         {
 412         case CorpusCount:
 413
 414
 415                 denominator = GetCorpusCountOfUnanalyzedWords ( ) +
 416                                           m_pStems->GetCorpusCount();
 417
 418
 419                 if ( GetAffixLocation() == WORD_FINAL || GetAffixLocation() == STEM_FINAL )
 420                 {
 421                         for (i = 0; i < m_pWords->GetCount(); i++)
 422                         {
 423                                 if ( 0 == m_pWords->GetAt(i)->GetSuffixLoc() )
 424                                 {
 425                                         total += base2log ( denominator / (double)       m_pWords->GetAt(i)->GetCorpusCount() ) ;
 426                                 }
 427                         }
 428                 }
 429                 else if (  GetAffixLocation() == WORD_INITIAL || GetAffixLocation() == STEM_INITIAL )
 430
 431                 {
 432                         for (i = 0; i < m_pWords->GetCount(); i++)
 433                         {
 434                                 if ( 0 == m_pWords->GetAt(i)->GetPrefixLoc() )
 435                                 {
 436                                         total += base2log ( denominator / m_pWords->GetAt(i)->GetCorpusCount() ) ;
 437                                 }
 438                         }
 439                 }
 440                 break;
 441
 442         case GrammarCount:
 443         int NumberOfUnanalyzedWords;
 444         GetNumberOfAnalyzedWords(NumberOfUnanalyzedWords);
 445
 446                 denominator = NumberOfUnanalyzedWords +
 447                                           m_pStems->GetTotalUseCount    ( );
 448
 449                 if ( GetAffixLocation() == WORD_FINAL || GetAffixLocation() == STEM_FINAL )
 450                 {
 451                         for (i = 0; i < m_pWords->GetCount(); i++)
 452                         {
 453                                 if ( 0 == m_pWords->GetAt(i)->GetSuffixLoc() )
 454                                 {
 455                                         total += base2log ( denominator ) ;
 456                                 }
 457                         }
 458                 }
 459                 else if (  GetAffixLocation() == WORD_INITIAL || GetAffixLocation() == STEM_INITIAL )
 460
 461                 {
 462                         for (i = 0; i < m_pWords->GetCount(); i++)
 463                         {
 464                                 if ( 0 == m_pWords->GetAt(i)->GetPrefixLoc() )
 465                                 {
 466                                         total += base2log ( denominator ) ;
 467
 468                                 }
 469                         }
 470                 }
 471
 472                 break;
 473
 474         }
 475         return total;
 476 }
 477
 478 double CMiniLexicon::CalculateUnanalyzedWordsTotalPhonologicalInformationContent( )
 479 {
 480         CLexicon* MotherLexicon = GetLexicon();
 481         int i;
 482         if (   m_PhonologicalInformationOfUnanalyzedWords == 0)
 483         {
 484                 if ( GetAffixLocation() == WORD_FINAL || GetAffixLocation() == STEM_FINAL )
 485                 {
 486                         for (i = 0; i < m_pWords->GetCount(); i++)
 487                         {
 488                                 if ( 0 == m_pWords->GetAt(i)->GetSuffixLoc() )
 489                                 {
 490                                         m_PhonologicalInformationOfUnanalyzedWords += m_pWords->GetAt(i)->CalculatePhonologicalInformationContent( MotherLexicon );
 491                                 }
 492                         }
 493                 }
 494                 else if (  GetAffixLocation() == WORD_INITIAL || GetAffixLocation() == STEM_INITIAL )
 495                         {
 496                         for (i = 0; i < m_pWords->GetCount(); i++)
 497                         {
 498                                 if ( 0 == m_pWords->GetAt(i)->GetPrefixLoc() )
 499                                 {
 500                                         m_PhonologicalInformationOfUnanalyzedWords += m_pWords->GetAt(i)->CalculatePhonologicalInformationContent( MotherLexicon );
 501                                 }
 502                         }
 503                 }
 504         }
 505
 506
 507         return  m_PhonologicalInformationOfUnanalyzedWords;
 508
 509 }
 510
 511
 512 double CMiniLexicon::CalculateCompressedLengthOfUnanalyzedWords(  )
 513 {
 514         double CompressedLengthOfUnanalyzedWords = 0;
 515         CLexicon* MotherLexicon = GetLexicon();
 516         int i;
 517
 518                 if ( GetAffixLocation() == WORD_FINAL || GetAffixLocation() == STEM_FINAL )
 519                 {
 520                         for (i = 0; i < GetWords()->GetCount(); i++)
 521                         {
 522                                 if ( NULL == GetWords()->GetAt(i)->GetSuffixSignature() )
 523                                 {
 524                                         CompressedLengthOfUnanalyzedWords       +=
 525                                                 GetWords()->GetAt(i)->CalculatePhonologicalInformationContent( MotherLexicon )
 526                                                 *  GetWords()->GetAt(i)->GetCorpusCount();
 527                                 }
 528                         }
 529                 }
 530                 else if ( GetAffixLocation() == WORD_INITIAL ||  GetAffixLocation() == STEM_INITIAL )
 531                         {
 532                         for (i = 0; i <  m_pWords->GetCount(); i++)
 533                         {
 534                                 if ( 0 ==  m_pWords->GetAt(i)->GetPrefixSignature() )
 535                                 {
 536                                         CompressedLengthOfUnanalyzedWords  +=
 537                                                 m_pWords->GetAt(i)->CalculatePhonologicalInformationContent( MotherLexicon )
 538                                                 * m_pWords->GetAt(i)->GetCorpusCount();
 539                                 }
 540                         }
 541                 }
 542
 543
 544
 545         return CompressedLengthOfUnanalyzedWords;
 546 }
 547
 548 int     CMiniLexicon::GetNumberOfAnalyzedWords (int& NumberOfUnanalyzedWords)
 549 {
 550         CStem* pWord;
 551         int     NumberOfAnalyzedWords = 0;
 552                         NumberOfUnanalyzedWords = 0;
 553         for (int i = 0;i < m_pWords->GetCount(); i++)
 554         {
 555                 pWord = m_pWords->GetAt(i);
 556                 if (pWord->IsAnalyzed() )
 557                 {
 558                         NumberOfAnalyzedWords++;
 559                 }       else
 560                 {
 561                         NumberOfUnanalyzedWords++;
 562                 }
 563         }
 564         return NumberOfAnalyzedWords;
 565 }
 566
 567
 568 //                      Log File functions
 569
 570
 571
 572  void CMiniLexicon::LogFileHeader(QString s1, QString s2, QString s3)
 573  {    if (LogFileOn()) *GetLogFile() <<
 574                  StartTable <<
 575                      StartTableRow << MakeTableHeader(s1) <<  MakeTableHeader(s2) << MakeTableHeader(s3) <<
 576                      EndTableRow;
 577  }
 578
 579  void CMiniLexicon::LogFileSmallTitle(QString s1, QString s2, QString s3)
 580  {       if (LogFileOn()) {  *GetLogFile() << SmallTitle( s1) <<
 581                   StartTable <<
 582                       StartTableRow << MakeTableHeader(s2) << MakeTableHeader(s3) ;
 583          }
 584  }
 585 void CMiniLexicon::LogFileSmallTitle(QString s)      { if (LogFileOn()) *GetLogFile() << SmallTitle( s );}
 586 void CMiniLexicon::LogFileSmallTitle(QString s, QString t)      { if (LogFileOn()) *GetLogFile() << SmallTitle( s ) << StartTableRow << MakeTableHeader(t) << EndTableRow; }
 587 void CMiniLexicon::LogFileLargeTitle(QString title)  { if (LogFileOn()) *GetLogFile() << LargeTitle(title) << endl; }
 588 void CMiniLexicon::LogFileStartTable()               { if (LogFileOn()) *GetLogFile() << StartTable;}
 589 void CMiniLexicon::LogFileEndTable()                 { if (LogFileOn()) *GetLogFile() << EndTable;}
 590 void CMiniLexicon::LogFileStartRow()                 { if (LogFileOn()) *GetLogFile() << StartTableRow; }
 591 void CMiniLexicon::LogFileEndRow()                   { if (LogFileOn()) *GetLogFile() << EndTableRow; }
 592 void CMiniLexicon::LogFileStartRow(QString str)      { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(str); }
 593 void CMiniLexicon::LogFile1SimpleString(QString s)   { if (LogFileOn()) *GetLogFile() << TableData(s); }
 594 void CMiniLexicon::LogFileSimpleString(QString s)   { if (LogFileOn()) *GetLogFile() << TableData(s); }
 595 void CMiniLexicon::LogFileSimpleDouble(double d)    { if (LogFileOn()) *GetLogFile() << TableData(d); }
 596 void CMiniLexicon::LogFileSimpleInteger(int n)       { if (LogFileOn()) *GetLogFile() << TableData(n); }
 597 void CMiniLexicon::LogFile (double d)                { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(d)  <<                  EndTableRow; }
 598 void CMiniLexicon::LogFile (QString s)               { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s)  <<                  EndTableRow; }
 599 void CMiniLexicon::LogFile (QString s, int n)        { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s)  << TableData (n) << EndTableRow; }
 600 void CMiniLexicon::LogFile (int n, QString s)        { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(n)  << TableData(s)  << EndTableRow; }
 601 void CMiniLexicon::LogFile (QString s1, QString s2)  { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s1) << TableData(s2) << EndTableRow; }
 602 void CMiniLexicon::LogFile (QString s1, double d)    { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s1) << TableData( d) << EndTableRow; }
 603 void CMiniLexicon::LogFile (QString s,int i,double d){ if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s)  << TableData(i) <<  TableData( d) << EndTableRow; }
 604 void CMiniLexicon::LogFile (QString s, int n, int m, double d, double e, double f)        { if (LogFileOn()) *GetLogFile() << StartTableRow << TableData(s)  << TableData(n)  << TableData(m) << TableData(d) << TableData(e) << TableData(f) << EndTableRow; }
 605 void CMiniLexicon::LogFile (QString s, QString t, QString u) { if (LogFileOn()) *GetLogFile()<< StartTableRow << TableData(s) <<  TableData(t) << TableData(u) <<  EndTableRow;}
 606 void CMiniLexicon::LogFile (QString s, QString t, QString u, QString v) { if (LogFileOn()) *GetLogFile()<< StartTableRow << TableData(s) <<  TableData(t) << TableData(u)  << TableData(v)  <<  EndTableRow;}
 607 void CMiniLexicon::LogFile (QString s, QString t, QString u, QString v, QString w) { if (LogFileOn()) *GetLogFile()<< StartTableRow << TableData(s) <<  TableData(t) << TableData(u)  << TableData(v) << TableData(w) <<  EndTableRow;}
 608 void CMiniLexicon::LogFile (QString s, QString t, QString u, QString v, QString w, QString x) { if (LogFileOn()) *GetLogFile()<< StartTableRow << TableData(s) <<  TableData(t) << TableData(u) << TableData(v) << TableData(w) << TableData (x)  << EndTableRow;}
 609 void CMiniLexicon::LogFileHeader( QString s)         { if (LogFileOn()) *GetLogFile() << StartTableRow << MakeTableHeader(s) << EndTableRow; }
 610 void CMiniLexicon::LogFileHeader( QString s, QString t)                                             { if (LogFileOn())      *GetLogFile() << StartTableRow << MakeTableHeader(s) << MakeTableHeader(t) << EndTableRow; }
 611 void CMiniLexicon::LogFileHeader (QString s, QString t, QString u, QString v, QString w, QString x) { if (LogFileOn())      *GetLogFile() << StartTableRow << MakeTableHeader(s) << MakeTableHeader(t) << MakeTableHeader(u) << MakeTableHeader(v) << MakeTableHeader(w) << MakeTableHeader (x)  << EndTableRow;}
 612 void CMiniLexicon::LogFile (int n, double d, QString s) { if (LogFileOn()) *GetLogFile()<< StartTableRow << TableData(n) <<  TableData(d) << TableData(s) <<  EndTableRow;}