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