home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sets115.zip / Sets.cpp next >
C/C++ Source or Header  |  1997-05-24  |  5KB  |  222 lines
  1. // Sets v 1.15
  2. // Hubert Chan, May 24, 1997
  3.  
  4. #include "Sets.hpp"
  5.  
  6. static int counter;
  7. #define DOONWHOLEARRAY(x) for(counter = 0; counter < SETELEMENTSIZE; counter++) x
  8.  
  9. Set::Set(Set& Set2) {
  10.     DOONWHOLEARRAY(SetElements[counter] = Set2.SetElements[counter]);
  11. }
  12.  
  13. void Set::AddElem(SetElement Element) {
  14.     int Segment = (Element - MINELEMENT) / 8,
  15.         Offset  = (Element - MINELEMENT) % 8;
  16.  
  17.     SetElements[Segment] |= 1 << Offset;
  18. }
  19.  
  20. void Set::RemoveElem(SetElement Element) {
  21.     int Segment = (Element - MINELEMENT) / 8,
  22.         Offset  = (Element - MINELEMENT) % 8;
  23.  
  24.     SetElements[Segment] &= ~(1 << Offset);
  25. }
  26.  
  27. void Set::ClearSet() {
  28.     DOONWHOLEARRAY(SetElements[counter] = 0);
  29. }
  30.  
  31. int Set::Card() {
  32.     int Cardinality = 0;
  33.     DOONWHOLEARRAY(Cardinality += (SetElements[counter] & 1) + ((SetElements[counter] >> 1) & 1)
  34.                          + ((SetElements[counter] >> 2) & 1) + ((SetElements[counter] >> 3) & 1)
  35.                          + ((SetElements[counter] >> 4) & 1) + ((SetElements[counter] >> 5) & 1)
  36.                          + ((SetElements[counter] >> 6) & 1) + ((SetElements[counter] >> 7) & 1));
  37.     return Cardinality;
  38. }
  39.  
  40. Set Set::operator=(Set Set2) {
  41.     DOONWHOLEARRAY(SetElements[counter] = Set2.SetElements[counter]);
  42.     return *this;
  43. }
  44.  
  45. Set Set::operator+(Set Set2) {
  46.     Set Result;
  47.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] | Set2.SetElements[counter]);
  48.     return Result;
  49. }
  50.  
  51. Set Set::operator|(Set Set2) {
  52.     return (*this + Set2);
  53. }
  54.  
  55. Set Set::operator+(SetElement Element) {
  56.     Set Result = *this;
  57.     Result.AddElem(Element);
  58.     return Result;
  59. }
  60.  
  61. Set Set::operator|(SetElement Element) {
  62.     return (*this + Element);
  63. }
  64.  
  65. Set Set::operator+=(Set Set2) {
  66.     DOONWHOLEARRAY(SetElements[counter] |= Set2.SetElements[counter]);
  67.     return *this;
  68. }
  69.  
  70. Set Set::operator|=(Set Set2) {
  71.     return (*this += Set2);
  72. }
  73.  
  74. Set Set::operator+=(SetElement Element) {
  75.     AddElem(Element);
  76.     return *this;
  77. }
  78.  
  79. Set Set::operator|=(SetElement Element) {
  80.     return (*this += Element);
  81. }
  82.  
  83. Set Set::operator-() {
  84.     Set Result;
  85.     DOONWHOLEARRAY(Result.SetElements[counter] = ~SetElements[counter]);
  86.     return Result;
  87. }
  88.  
  89. Set Set::operator~() {
  90.     return -(*this);
  91. }
  92.  
  93. Set Set::operator*(Set Set2) {
  94.     Set Result;
  95.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] & Set2.SetElements[counter]);
  96.     return Result;
  97. }
  98.  
  99. Set Set::operator^(Set Set2) {
  100.     return (*this * Set2);
  101. }
  102.  
  103. Set Set::operator&(Set Set2) {
  104.     return (*this * Set2);
  105. }
  106.  
  107. Set Set::operator*=(Set Set2) {
  108.     DOONWHOLEARRAY(SetElements[counter] &= Set2.SetElements[counter]);
  109.     return *this;
  110. }
  111.  
  112. Set Set::operator^=(Set Set2) {
  113.     return (*this *= Set2);
  114. }
  115.  
  116. Set Set::operator&=(Set Set2) {
  117.     return (*this *= Set2);
  118. }
  119.  
  120. Set Set::operator-(Set Set2) {
  121.     Set Result;
  122.     DOONWHOLEARRAY(Result.SetElements[counter] = SetElements[counter] & (~Set2.SetElements[counter]));
  123.     return Result;
  124. }
  125.  
  126. Set Set::operator-(SetElement Element) {
  127.     Set Result = *this;
  128.     Result.RemoveElem(Element);
  129.     return Result;
  130. }
  131.  
  132. Set Set::operator-=(Set Set2) {
  133.     DOONWHOLEARRAY(SetElements[counter] &= !Set2.SetElements[counter]);
  134.     return *this;
  135. }
  136.  
  137. Set Set::operator-=(SetElement Element) {
  138.     RemoveElem(Element);
  139.     return *this;
  140. }
  141.  
  142. int Set::operator==(Set Set2) {
  143.     int Equivalent = -1;
  144.     DOONWHOLEARRAY(Equivalent &= (SetElements[counter] == Set2.SetElements[counter]));
  145.     return Equivalent;
  146. }
  147.  
  148. int Set::operator!=(Set Set2) {
  149.     int NotEquivalent = 0;
  150.     DOONWHOLEARRAY(NotEquivalent |= (SetElements[counter] != Set2.SetElements[counter]));
  151.     return (NotEquivalent != 0);
  152. }
  153.  
  154. int Set::operator<=(Set Set2) {
  155.     int Subset = -1;
  156.     DOONWHOLEARRAY(Subset &= (~SetElements[counter] | Set2.SetElements[counter]));
  157.     return (Subset == -1);
  158. }
  159.  
  160. int Set::operator<(Set Set2) {
  161.     int Subset = 0;
  162.     DOONWHOLEARRAY(Subset |= (SetElements[counter] != Set2.SetElements[counter]));
  163.     Subset = (Subset != 0 ) ? -1 : 0;
  164.     DOONWHOLEARRAY(Subset &= (~SetElements[counter] | Set2.SetElements[counter]));
  165.     return (Subset == -1);
  166. }
  167.  
  168. int Set::operator>=(Set Set2) {
  169.     int Superset = -1;
  170.     DOONWHOLEARRAY(Superset &= (SetElements[counter] | ~Set2.SetElements[counter]));
  171.     return (Superset == -1);
  172. }
  173.  
  174. int Set::operator>(Set Set2) {
  175.     int Superset = 0;
  176.     DOONWHOLEARRAY(Superset |= (SetElements[counter] != Set2.SetElements[counter]));
  177.     Superset = (Superset != 0) ? -1 : 0;
  178.     DOONWHOLEARRAY(Superset &= (SetElements[counter] | ~Set2.SetElements[counter]));
  179.     return (Superset == -1);
  180. }
  181.  
  182. int operator<=(Set::SetElement Element, Set Set2) {
  183.     int Segment = (Element - MINELEMENT) / 8,
  184.         Offset  = (Element - MINELEMENT) % 8;
  185.  
  186.     return ((Set2.SetElements[Segment] & (1 << Offset)) != 0);
  187. }
  188.  
  189. //ostream & operator<<(ostream & s, Set & Set2) {
  190. //    Set::SetElement counter;
  191. //    int NotFirst = 0;
  192. //    s << "{ ";
  193. //    for(counter = MINELEMENT; counter <= MAXELEMENT; counter++)
  194. //        if (counter <= Set2)
  195. //            if (NotFirst)
  196. //                s << form(",%d",counter);
  197. //            else {
  198. //                s << form("%d",counter);
  199. //                NotFirst = !0;
  200. //            }
  201. //    s << " }";
  202. //    return s;
  203. //}
  204.  
  205. #include <stdio.h>
  206.  
  207. void PrintSet(Set &Set1) {
  208.     Set::SetElement counter;
  209.     int NotFirst = 0;
  210.     printf("{ ");
  211.     for(counter = MINELEMENT; counter <= MAXELEMENT; counter++)
  212.         if (Set1 >= counter)
  213.             if (NotFirst)
  214.                 printf(",%d",counter);
  215.             else {
  216.                 printf("%d",counter);
  217.                 NotFirst = -1;
  218.             }
  219.     printf(" }\n");
  220. }
  221.  
  222.