SuffixCollection.cpp

   1 // Implementation of CSuffixCollection methods
   2 // Copyright © 2009 The University of Chicago
   3 #include "SuffixCollection.h"
   4
   5 #include <Q3TextStream>
   6 #include <QIODevice>
   7 #include <QFile>
   8 #include "ui/Status.h"
   9 #include "MiniLexicon.h"
  10 #include "Lexicon.h"
  11 #include "Suffix.h"
  12 #include "log2.h"
  13
  14 //////////////////////////////////////////////////////////////////////
  15 // Construction/Destruction
  16 //////////////////////////////////////////////////////////////////////
  17
  18 CSuffixCollection::CSuffixCollection(CMiniLexicon* Lex)
  19 {
  20   // do the creation of TCollection with ptr to Lexicon and name of class
  21         m_pMiniLex = Lex;
  22         if( m_pMiniLex ) m_pLexicon = m_pMiniLex->GetLexicon();
  23 }
  24
  25
  26 CSuffixCollection::CSuffixCollection( )
  27 {
  28         m_pMiniLex = NULL;
  29         m_pLexicon = NULL;
  30 }
  31
  32
  33 CSuffixCollection::~CSuffixCollection()
  34 {
  35         if( m_pLexicon )
  36         {
  37                 CSuffix* pSuffix;
  38                 for( int i = 0; i < GetCount(); i++ )
  39                 {
  40                         pSuffix = GetAt(i);
  41
  42                         m_pLexicon->RemoveSuffix( pSuffix );
  43                 }
  44         }
  45 }
  46
  47 void CSuffixCollection::ListDisplay(
  48         Q3ListView* pView, QMap<QString, QString>* filter,
  49         linguistica::ui::status_user_agent& status,
  50         bool ExpressDeletees)
  51 {
  52         pView->setRootIsDecorated(false);
  53         pView->setSorting(1);
  54
  55         // Clean it out first.
  56         while (pView->columns() != 0)
  57                 pView->removeColumn(0);
  58
  59         // Add Column headers
  60         pView->addColumn("Prefixes");
  61         pView->addColumn("Descr. Length");
  62         pView->addColumn("Length of Ptr");
  63         pView->addColumn("Corpus Count");
  64         pView->addColumn("Use Count");
  65         pView->addColumn("Stems");
  66
  67         pView->setColumnAlignment(0, Qt::AlignCenter);
  68         pView->setColumnAlignment(1, Qt::AlignRight);
  69         pView->setColumnAlignment(2, Qt::AlignRight);
  70         pView->setColumnAlignment(3, Qt::AlignCenter);
  71         pView->setColumnAlignment(4, Qt::AlignCenter);
  72         pView->setColumnAlignment(5, Qt::AlignLeft);
  73
  74         // Column three gets really wide, so
  75         // limit the width to 100.
  76         pView->setColumnWidthMode(3, Q3ListView::Manual);
  77         pView->setColumnWidth(3, 100);
  78
  79         status.major_operation = "Creating suffix list for display";
  80         status.progress.clear();
  81
  82         if (m_SortValidFlag == false)
  83                 Sort(COUNT);
  84
  85         // Display each item
  86         status.progress.set_denominator(GetCount());
  87         for (int i = 0; i < (int) GetCount(); i++) {
  88                 GetAtSort(i)->ListDisplay(pView, filter, ExpressDeletees,
  89                                           m_pLexicon->GetNumberOfCharacterTypes());
  90                 status.progress = i;
  91         }
  92         status.progress.clear();
  93         status.major_operation.clear();
  94 }
  95
  96 CSuffix* CSuffixCollection::operator<< ( CStringSurrogate& Suffix )
  97 {
  98   CSuffix*  pSuffix;
  99
 100   pSuffix = AddToCollection( Suffix );
 101
 102   return pSuffix;
 103 }
 104
 105
 106 CSuffix* CSuffixCollection::operator<< ( CParse* Suffix )
 107 {
 108   CSuffix*  pSuffix;
 109
 110   pSuffix = AddToCollection (*Suffix);
 111
 112   return pSuffix;
 113 }
 114
 115
 116 CSuffix* CSuffixCollection::operator<< ( CParse& Suffix )
 117 {
 118   CSuffix*  pSuffix;
 119
 120   pSuffix = AddToCollection (Suffix);
 121
 122   return pSuffix;
 123 }
 124
 125 CSuffix* CSuffixCollection::operator<< ( QString Suffix )
 126 {
 127   CSuffix*  pSuffix;
 128
 129   CStringSurrogate cssSuffix( Suffix );
 130
 131   pSuffix = AddToCollection( cssSuffix );
 132
 133   return pSuffix;
 134 }
 135
 136
 137 void CSuffixCollection::AddPointer( CSuffix* pSuffix )
 138 {
 139         TCollection<CSuffix>::AddPointer( pSuffix );
 140
 141         if( m_pLexicon ) m_pLexicon->InsertSuffix( pSuffix );
 142 }
 143
 144
 145 CSuffix* CSuffixCollection::AddToCollection( CParse& Suffix )
 146 {
 147         CSuffix* pSuffix = TCollection<CSuffix>::AddToCollection( Suffix );
 148
 149         if( m_pLexicon ) m_pLexicon->InsertSuffix( pSuffix );
 150
 151         return pSuffix;
 152 }
 153
 154
 155 CSuffix* CSuffixCollection::AddToCollection( CStringSurrogate& Suffix )
 156 {
 157         CSuffix* pSuffix = TCollection<CSuffix>::AddToCollection( Suffix );
 158
 159         if( m_pLexicon ) m_pLexicon->InsertSuffix( pSuffix );
 160
 161         return pSuffix;
 162 }
 163
 164
 165 void CSuffixCollection::Empty()
 166 {
 167         if( m_pLexicon )
 168         {
 169                 CSuffix* pSuffix;
 170                 for( int suffixno = 0; suffixno < GetCount(); suffixno++ )
 171                 {
 172                         pSuffix = GetAt(suffixno);
 173                         m_pLexicon->RemoveSuffix( pSuffix );
 174                 }
 175         }
 176         TCollection<CSuffix>::Empty();
 177 }
 178
 179
 180 void CSuffixCollection::RemoveAll()
 181 {
 182         if( m_pLexicon )
 183         {
 184                 CSuffix* pSuffix;
 185
 186                 for( int suffixno = 0; suffixno < GetCount(); suffixno++ )
 187                 {
 188                         pSuffix = GetAt(suffixno);
 189                         m_pLexicon->RemoveSuffix( pSuffix );
 190                 }
 191         }
 192         TCollection<CSuffix>::RemoveAll();
 193 }
 194
 195
 196 bool CSuffixCollection::Remove( CSuffix* pSuffix )
 197 {
 198         if( m_pLexicon ) m_pLexicon->RemoveSuffix( pSuffix );
 199
 200         return TCollection<CSuffix>::Remove( pSuffix );
 201 }
 202
 203
 204 bool CSuffixCollection::RemoveMember( CSuffix* pSuffix )
 205 {
 206         if( m_pLexicon ) m_pLexicon->RemoveSuffix( pSuffix );
 207
 208         return TCollection<CSuffix>::RemoveMember( pSuffix );
 209 }
 210
 211
 212 bool CSuffixCollection::RemoveMember( CStringSurrogate& Suffix )
 213 {
 214         CSuffix* pSuffix = (CSuffix*)Find1( Suffix )->Get_T_Pointer();
 215
 216         if( m_pLexicon ) m_pLexicon->RemoveSuffix( pSuffix );
 217
 218         return TCollection<CSuffix>::RemoveMember( Suffix );
 219 }
 220
 221
 222 bool CSuffixCollection::RemoveMember( CStringSurrogate& Suffix, bool b )
 223 {
 224         CSuffix* pSuffix = (CSuffix*)Find1( Suffix )->Get_T_Pointer();
 225
 226         if( m_pLexicon ) m_pLexicon->RemoveSuffix( pSuffix );
 227
 228         return TCollection<CSuffix>::RemoveMember( Suffix, b );
 229 }
 230
 231 int CSuffixCollection::GetTotalUseCount()
 232 {  if (m_TotalUseCount <= 0)
 233       CalculateTotalUseCount();
 234     return m_TotalUseCount;
 235 }
 236
 237 void CSuffixCollection::CalculateTotalUseCount()
 238 {
 239         m_TotalUseCount = 0;
 240        for (int suffixno = 0; suffixno < GetCount(); suffixno++)
 241        {           m_TotalUseCount += GetAt(suffixno)->GetUseCount();
 242        }
 243 }
 244
 245 void CSuffixCollection::DeleteMarkedMembers()
 246 {
 247         if ( m_DeletionArray == NULL ) { return; }
 248
 249         int count = GetCount();
 250         for (int suffixno = 0; suffixno < count; suffixno++)
 251         {
 252                 if ( m_DeletionArray[suffixno] == 1 )
 253                 {
 254                         if( m_pLexicon ) m_pLexicon->RemoveSuffix( m_PointerArray[suffixno] );
 255                 }
 256         }
 257         TCollection<CSuffix>::DeleteMarkedMembers();
 258 }
 259
 260
 261 void CSuffixCollection::OutputSuffixes( QString FileName )
 262 {
 263         QFile file( FileName );
 264
 265         if( file.open( QIODevice::WriteOnly ) )
 266         {
 267                 Q3TextStream outf( &file );
 268                 outf.setEncoding( Q3TextStream::Unicode );
 269
 270                 outf << "# Suffix Count" << endl;
 271                 outf << "# ------------" << endl;
 272                 outf << "  " << GetCount() << endl << endl;
 273
 274                 outf << "# Suffix       | Use Count | Corpus Count | Index | " << endl;
 275                 outf << "# ------------------------------------------------- " << endl;
 276
 277                 Sort( CORPUSCOUNT );
 278                 for (int suffixno = 0; suffixno < (int)GetCount(); suffixno++)
 279                 {
 280                         GetAtSort(suffixno)->OutputSuffix( outf );
 281                 }
 282
 283                 file.close();
 284         }
 285 }
 286
 287
 288 void  CSuffixCollection::ReadSuffixFile (QString FileName)
 289 {
 290         CSuffix*        pSuffix;
 291         QFile           file(FileName);
 292         QString Buffer, Key;
 293         int             Index,
 294         size,
 295         UseCount,
 296         CorpusCount,
 297         LineCount = 0;
 298
 299         if( file.exists() && file.open( QIODevice::ReadOnly ) )
 300         {
 301                 Q3TextStream inf(&file);
 302                 inf.setEncoding ( Q3TextStream::Locale );
 303
 304                 Buffer = inf.readLine();
 305                 Q_ASSERT( Buffer[0] == '#' );
 306
 307                 Buffer = inf.readLine();
 308                 Q_ASSERT( Buffer[0] == '#' );
 309
 310                 inf >> size;
 311
 312                 Buffer = inf.readLine(); // end of size line
 313                 Q_ASSERT( Buffer.length() == 0 );
 314
 315                 Buffer = inf.readLine(); // blank line
 316                 Q_ASSERT( Buffer.length() == 0 );
 317
 318                 Buffer = inf.readLine();
 319                 Q_ASSERT( Buffer[0] == '#' );
 320
 321                 Buffer = inf.readLine();
 322                 Q_ASSERT( Buffer[0] == '#' );
 323
 324                 while( !inf.atEnd() && LineCount < size )
 325                 {
 326                         LineCount++;
 327
 328                         inf >> Key;
 329                         inf >> UseCount;
 330                         inf >> CorpusCount;
 331                         inf >> Index;
 332
 333                         // Filter all sequences that should be
 334                         // analyzed as one character
 335                         Key = Filter( m_pLexicon->GetInFilter(), Key );
 336
 337                         pSuffix = *this <<   Key ;
 338                         pSuffix->IncrementUseCount( UseCount );
 339                         pSuffix->IncrementCorpusCount( CorpusCount );
 340                 }
 341
 342                 file.close();
 343         }
 344 }
 345
 346 double  CSuffixCollection::GetDL_PhonologicalContent()
 347 {
 348         double affix_total_dl = 0;
 349         CSuffix* pAffix;
 350         for( int suffixno = 0; suffixno < (int)GetCount(); suffixno++ )
 351         {
 352                 pAffix =  GetAt(suffixno);
 353                 affix_total_dl += pAffix->ComputeDL( m_pMiniLex->GetNumberOfCharacterTypes() );
 354         }
 355         return affix_total_dl ;
 356 }
 357
 358
 359 double  CSuffixCollection::CalculatePointersToMySuffixes(eMDL_STYLE style )//sum of pointers to members; this should be removed, and replaced by "GetLengthOfPointerToMe"
 360 {
 361         double                  Denominator = 0;
 362         double                  ptr;
 363                                 m_DLofPointersToMyMembers = 0;
 364                                 m_CorpusCount = 0;
 365
 366         if (style == CorpusCount )
 367         {
 368                 for (int suffixno = 0; suffixno < GetCount(); suffixno++)
 369                 {
 370                         m_CorpusCount += GetAt(suffixno)->GetCorpusCount();
 371                 }
 372                 for (int suffixno = 0; suffixno < GetCount(); suffixno++)
 373                 {
 374                         ptr = base2log ( m_CorpusCount / GetAt(suffixno)->GetCorpusCount() );
 375                         m_DLofPointersToMyMembers += ptr;
 376                 }
 377         }
 378         else if (style  == GrammarCount )
 379         {
 380                 for (int suffixno = 0; suffixno < GetCount(); suffixno++)
 381                 {
 382                         Denominator += GetAt(suffixno)->GetUseCount();
 383                 }
 384                 for (int suffixno = 0; suffixno < GetCount(); suffixno++)
 385                 {
 386                         ptr = base2log ( Denominator/ GetAt(suffixno)->GetUseCount() );
 387                         m_DLofPointersToMyMembers += ptr;
 388                 }
 389         }
 390         return m_DLofPointersToMyMembers;
 391 }