CompareFunc.cpp

   1 // Implementation of comparison and sorting functions
   2 // Copyright © 2009 The University of Chicago
   3 #include "CompareFunc.h"
   4
   5 #include <algorithm>
   6 #include <iterator>
   7 #include <utility>
   8 #include <QStringList>
   9 #include <QString>
  10 #include <QChar>
  11 #include "MiniLexicon.h"
  12 #include "Signature.h"
  13 #include "Morpheme.h"
  14 #include "LParse.h"
  15 #include "Affix.h"
  16 #include "Stem.h"
  17 #include "StringFunc.h"
  18
  19 int CompareAlphabetically(const void *pA, const void *pB)
  20 {
  21         CLParse* pS1 = *static_cast<CLParse* const*>(pA);
  22         CLParse* pS2 = *static_cast<CLParse* const*>(pB);
  23
  24         Q_ASSERT(pS1);
  25         Q_ASSERT(pS2);
  26
  27         if ( pS1->GetMyMini() && pS2->GetMyMini() )
  28         {
  29                 QString str1 = pS1->Display( QChar(0),
  30                                         pS1->GetMyMini()->GetOutFilter() ),
  31                         str2 = pS2->Display( QChar(0),
  32                                         pS2->GetMyMini()->GetOutFilter() );
  33
  34                 return LxStrCmp( str1, str2, str1.length(), str2.length(),
  35                                         0, 0 );
  36         }
  37         else
  38                 return LxStrCmp( pS1->GetKeyPointer(),
  39                                         pS2->GetKeyPointer(),
  40                                         pS1->GetKeyLength(),
  41                                         pS2->GetKeyLength() );
  42 }
  43
  44 int CompareReverseAlphabetically(const void *pA, const void *pB)
  45 {
  46         CLParse* pS1 = *static_cast<CLParse* const*>(pA);
  47         CLParse* pS2 = *static_cast<CLParse* const*>(pB);
  48
  49   Q_ASSERT(pS1);
  50   Q_ASSERT(pS2);
  51
  52
  53   QChar* S1 = new QChar[pS1->GetKeyLength()];
  54   QChar* S2 = new QChar[pS2->GetKeyLength()];
  55   LxStrCpy_R( pS1->GetKeyPointer(), S1, pS1->GetKeyLength() );
  56   LxStrCpy_R( pS2->GetKeyPointer(), S2, pS2->GetKeyLength() );
  57   int comp = LxStrCmp( S1, S2, pS1->GetKeyLength(), pS2->GetKeyLength() );
  58
  59   delete [] S1;
  60   delete [] S2;
  61
  62   return comp;
  63 }
  64
  65 int CompareSortingQuantity (const void *pA, const void *pB)
  66 {
  67         CLParse* pS1 = *static_cast<CLParse* const*>(pA);
  68         CLParse* pS2 = *static_cast<CLParse* const*>(pB);
  69
  70   float  dif =   pS2->GetSortingQuantity() -  pS1->GetSortingQuantity();
  71
  72   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
  73 }
  74
  75 int CompareSortingString (const void *pA, const void *pB)
  76 {
  77         CLParse* pS1 = *static_cast<CLParse* const*>(pA);
  78         CLParse* pS2 = *static_cast<CLParse* const*>(pB);
  79
  80   return LxStrCmp( pS1->GetSortingString(), pS2->GetSortingString(), pS1->GetSortingString().length(), pS2->GetSortingString().length() );
  81
  82 }
  83
  84 int CompareNumberOfStems (const void *pA, const void *pB)
  85 {
  86         CSignature* pS1 = *static_cast<CSignature* const*>(pA);
  87         CSignature* pS2 = *static_cast<CSignature* const*>(pB);
  88
  89         int dif = pS2->GetNumberOfStems() -  pS1->GetNumberOfStems();
  90
  91   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
  92
  93 }
  94
  95 int CompareSigRemark (const void *pA, const void *pB)
  96 {
  97         CSignature* pS1 = *static_cast<CSignature* const*>(pA);
  98         CSignature* pS2 = *static_cast<CSignature* const*>(pB);
  99   return QString::compare( pS1->GetRemark(), pS2->GetRemark() );
 100 }
 101
 102 int CompareStemSource (const void *pA, const void *pB)
 103 {
 104         CStem* pS1 = *static_cast<CStem* const*>(pA);
 105         CStem* pS2 = *static_cast<CStem* const*>(pB);
 106   return QString::compare( pS1->GetConfidence(), pS2->GetConfidence() );
 107 }
 108
 109 int CompareCorpusCount (const void *pM1,   const void *pM2)
 110 {
 111         CLParse* pS1 = *static_cast<CLParse* const*>(pM1);
 112         CLParse* pS2 = *static_cast<CLParse* const*>(pM2);
 113
 114         int dif = pS2->GetCorpusCount() -  pS1->GetCorpusCount();
 115
 116   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 117 }
 118
 119 int CompareSize (const void *pM1,   const void *pM2)
 120 {
 121         CLParse* pS1 = *static_cast<CLParse* const*>(pM1);
 122         CLParse* pS2 = *static_cast<CLParse* const*>(pM2);
 123
 124   int  dif =   pS2->Size() -  pS1->Size();
 125
 126   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 127 }
 128
 129 int CompareLength (const void *pM1,   const void *pM2)
 130 {
 131         CLParse* pS1 = *static_cast<CLParse* const*>(pM1);
 132         CLParse* pS2 = *static_cast<CLParse* const*>(pM2);
 133
 134   int  dif =   pS2->GetKeyLength() -  pS1->GetKeyLength();
 135
 136   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 137 }
 138
 139 int CompareDLSavings (const void *pM1,   const void *pM2)
 140 {
 141         CMorpheme* pS1 = *static_cast<CMorpheme* const*>(pM1);
 142         CMorpheme* pS2 = *static_cast<CMorpheme* const*>(pM2);
 143
 144   double  dif =   pS2->GetDLSavings() -  pS1->GetDLSavings();
 145
 146   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 147 }
 148
 149 int CompareFrequency (const void *pM1,   const void *pM2)
 150 {
 151         CMorpheme* pS1 = *static_cast<CMorpheme* const*>(pM1);
 152         CMorpheme* pS2 = *static_cast<CMorpheme* const*>(pM2);
 153
 154   double  dif =   pS2->GetFrequency() -  pS1->GetFrequency();
 155
 156   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 157 }
 158
 159 int CompareMorphemeCount (const void *pM1,   const void *pM2)
 160 {
 161         CMorpheme* pS1 = *static_cast<CMorpheme* const*>(pM1);
 162         CMorpheme* pS2 = *static_cast<CMorpheme* const*>(pM2);
 163
 164   double  dif =   pS2->GetMorphemeCount() -  pS1->GetMorphemeCount();
 165
 166   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 167 }
 168
 169 int CompareUseCount (const void *pM1,   const void *pM2)
 170 {
 171         CAffix* pS1 = *static_cast<CAffix* const*>(pM1);
 172         CAffix* pS2 = *static_cast<CAffix* const*>(pM2);
 173
 174   double  dif =   pS2->GetUseCount() -  pS1->GetUseCount();
 175
 176   if (dif > 0) {return 1;} else if (dif < 0) {return -1;} else {return 0;}
 177 }
 178
 179 // compare() for basic types
 180 int MakeComparable(int a, int b)
 181 {
 182         const int difference = a - b;
 183
 184         if (difference < 0) return -1;
 185         else if (difference == 0) return 0;
 186         else return 1;
 187 }
 188
 189 int MakeComparable(double a, double b)
 190 {
 191         const double difference = a - b;
 192
 193         if (difference < 0) return -1;
 194         else if (difference == 0) return 0;
 195         else return 1;
 196 }