home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume1 / 8708 / 14 / setlib.h < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-13  |  5.1 KB  |  291 lines
  1.  
  2. /* setlib.h - set pseudo-type for C, library programs */
  3. /* see sets.h for usage */
  4.  
  5. #define    _SETLIB_
  6. #include    "sets.h"
  7. #undef    _SETLIB_
  8.  
  9. #define    setsize(s) ((SET_BSIZE-(first_element(s)-last_element(s)))>>SET_SSIZE)
  10.  
  11. set *emptyset(s)
  12. register set *s;
  13. {
  14.     register int n;
  15.  
  16.     n = setsize(s);
  17.     s += 2;
  18.     while (n-- > 0)
  19.     *s++ = 0;
  20.     return (EMPTYSET);
  21. }
  22.  
  23. set *setcpy(s1,s2)
  24. register set *s1,*s2;
  25. {
  26.     register short n;
  27.     register set nonnull = 0;
  28.     set *s = s1;
  29.  
  30.     if (s2 != EMPTYSET) {
  31.     n = setsize(s2);
  32.     *s1++ = *s2++;    /* copy the element ranges too - can be different */
  33.     *s1++ = *s2++;
  34.     while (n-- > 0)
  35.         nonnull |= (*s1++ = *s2++);
  36.     return (nonnull ? s : EMPTYSET);
  37.     }
  38.     else
  39.     return (emptyset(s1));
  40. }
  41.  
  42. set *set3union(s1,s2,s3)
  43. register set *s1,*s2,*s3;
  44. {
  45.     register short n;
  46.     register set nonnull = 0;
  47.     set *s = s1;
  48.  
  49.     if (s2 == EMPTYSET)
  50.     s2 = s3, s3 = EMPTYSET;
  51.     if (s2 == EMPTYSET)
  52.     return (emptyset(s1));
  53.     n = setsize(s2);
  54.     *s1++ = *s2++;
  55.     *s1++ = *s2++;
  56.     if (s3 != EMPTYSET) {
  57.     s3 += 2;
  58.     while (n-- > 0)
  59.         nonnull |= (*s1++ = (*s2++ | *s3++));
  60.     }
  61.     else {
  62.     while (n-- > 0)
  63.         nonnull |= (*s1++ = *s2++);
  64.     }
  65.     return (nonnull ? s : EMPTYSET);
  66. }
  67.  
  68. set *set3inter(s1,s2,s3)
  69. register set *s1,*s2,*s3;
  70. {
  71.     register short n;
  72.     register set nonnull = 0;
  73.     set *s = s1;
  74.  
  75.     if (s2 == EMPTYSET)
  76.     s2 = s3, s3 = EMPTYSET;
  77.     if (s2 == EMPTYSET)
  78.     return (emptyset(s1));
  79.     n = setsize(s2);
  80.     *s1++ = *s2++;
  81.     *s1++ = *s2++;
  82.     if (s3 != EMPTYSET) {
  83.     s3 += 2;
  84.     while (n-- > 0)
  85.         nonnull |= (*s1++ = (*s2++ & *s3++));
  86.     return (nonnull ? s : EMPTYSET);
  87.     }
  88.     else
  89.     return (emptyset(s));    /* must use s, not (modified) s1 */
  90. }
  91.  
  92. set *set3diff(s1,s2,s3)
  93. register set *s1,*s2,*s3;
  94. {
  95.     register short n;
  96.     register set nonnull = 0;
  97.     set *s = s1;
  98.  
  99.     if (s2 == EMPTYSET)
  100.     return (emptyset(s1));
  101.     n = setsize(s2);
  102.     *s1++ = *s2++;
  103.     *s1++ = *s2++;
  104.     if (s3 != EMPTYSET && s2 != EMPTYSET) {
  105.      s3 += 2;
  106.     while (n-- > 0)
  107.         nonnull |= (*s1++ = (*s2++ & ~*s3++));
  108.     }
  109.     else {
  110.     while (n-- > 0)
  111.         nonnull |= (*s1++ = *s2++);
  112.     }
  113.     return (nonnull ? s : EMPTYSET);
  114. }
  115.  
  116. int setord(s)
  117. register set *s;
  118. {
  119.     register short member, total = 0;
  120.  
  121.     if (s != EMPTYSET) {
  122.     for (member=first_element(s); member<=last_element(s); member++) {
  123.         if (ismember(s,member))
  124.             total++;
  125.     }
  126.     }
  127.     return (total);
  128. }
  129.  
  130. int setcmp(s1,s2)
  131. register set *s1,*s2;
  132. {
  133.     register short n;
  134.     register int result;
  135.  
  136.     if (s1 != EMPTYSET && s2 != EMPTYSET) {
  137.     if (first_element(s1) != first_element(s2) ||
  138.          last_element(s1) != last_element(s2))
  139.         return (ERRORSET);
  140.     n = setsize(s1);
  141.     s1 += 2; s2 += 2;
  142.     result = SAMESET | DISJOINT;
  143.     while (n-- > 0 && result) {
  144.         if (*s1 & ~*s2)
  145.         result &= ~SUBSET;
  146.         if (*s2 & ~*s1)
  147.         result &= ~SUPERSET;
  148.         if (*s1++ & *s2++)
  149.         result &= ~DISJOINT;
  150.     }
  151.     if (result != DISJOINT)
  152.         result &= ~DISJOINT;
  153.     return (result);
  154.     }
  155.     else if (s1 != EMPTYSET) {
  156.     n = setsize(s1);
  157.     s1 += 2;
  158.     while (n-- > 0)
  159.         if (*s1++)
  160.         return (SUPERSET);
  161.     }
  162.     else if (s2 != EMPTYSET) {
  163.     n = setsize(s2);
  164.     s2 += 2;
  165.     while (n-- > 0)
  166.         if (*s2++)
  167.         return (SUBSET);
  168.     }
  169.     return (SAMESET);
  170. }
  171.  
  172. int ismember(s,e)
  173. register set *s;
  174. int e;
  175. {
  176.     if (first_element(s) <= e && e <= last_element(s)) {
  177.     e -= first_element(s);
  178.     return ((s[(e>>SET_SSIZE)+2] & (1<<(e & (SET_BSIZE-1)))) != 0);
  179.     }
  180.     else
  181.     return (0);
  182. }
  183.  
  184. set *addmember(s,e)
  185. register set *s;
  186. int e;
  187. {
  188.     if (first_element(s) <= e && e <= last_element(s)) {
  189.     e -= first_element(s);
  190.     s[(e>>SET_SSIZE)+2] |= (1<<(e & (SET_BSIZE-1)));
  191.     return (s);
  192.     }
  193.     else
  194.     return (EMPTYSET);
  195. }
  196.  
  197. set *submember(s,e)
  198. register set *s;
  199. int e;
  200. {
  201.     if (first_element(s) <= e && e <= last_element(s)) {
  202.     e -= first_element(s);
  203.     s[(e>>SET_SSIZE)+2] &= ~(1<<(e & (SET_BSIZE-1)));
  204.     return (s);
  205.     }
  206.     else
  207.     return (EMPTYSET);
  208. }
  209.  
  210. set *xormember(s,e)
  211. register set *s;
  212. int e;
  213. {
  214.     if (first_element(s) <= e && e <= last_element(s)) {
  215.     e -= first_element(s);
  216.     s[(e>>SET_SSIZE)+2] ^= (1<<(e & (SET_BSIZE-1)));
  217.     return (s);
  218.     }
  219.     else
  220.     return (EMPTYSET);
  221. }
  222.  
  223. set *S_lmember(s,l,fn)
  224. register set *s;
  225. register char *l;
  226. set *(*fn)();
  227. {
  228.     register short base;
  229.     register int *ll;
  230.  
  231.     base = first_element(s);
  232.     if (base > 1) {
  233.     while (*l)
  234.         (fn)(s,*l++);
  235.     }
  236.     else {
  237.     ll = (int *)l;
  238.     while (*ll != base-1)
  239.         (fn)(s,*ll++);
  240.     }
  241.     return (s);
  242. }
  243.  
  244. int S_setlord(s,l)
  245. register set *s;
  246. register char *l;
  247. {
  248.     register short base, total = 0;
  249.     register int *ll;
  250.  
  251.     if (s == EMPTYSET)
  252.     return (0);
  253.     base = first_element(s);
  254.     if (base > 1) {
  255.     while (*l)
  256.         total += ismember(s,*l++);
  257.     }
  258.     else {
  259.     ll = (int *)l;
  260.     while (*ll != base-1)
  261.         total += ismember(s,*ll++);
  262.     }
  263.     return (total);
  264. }
  265.  
  266. set *S_setlcpy(s1,l)
  267. set *s1;
  268. char *l;
  269. {
  270.     emptyset(s1);
  271.     return (S_lmember(s1,l,addmember));
  272. }
  273.  
  274. set *setncpy(s1,s2)
  275. register set *s1, *s2;
  276. {
  277.     register short member;
  278.     set *result = EMPTYSET;
  279.  
  280.     emptyset(s1);
  281.     if (s2 != EMPTYSET) {
  282.     for (member=first_element(s2); member<=last_element(s2); member++) {
  283.         if (ismember(s2,member) && addmember(s1,member))
  284.         result = s1;
  285.     }
  286.     }
  287.     return (result);
  288. }
  289.  
  290. #undef    setsize
  291.