head	1.9;
access;
symbols
	bobbase:1.8
	bob:1.8.1
	r2_1:1.2
	r2_0:1.2
	r1_1_beta:1.2
	r1_1_alpha:1.2
	r1_0:1.2
	r0_11:1.2;
locks; strict;
comment	@// @;


1.9
date	94.10.18.17.28.10;	author gmt;	state Exp;
branches;
next	1.8;

1.8
date	94.10.04.05.38.18;	author gmt;	state Exp;
branches
	1.8.1.1;
next	1.7;

1.7
date	94.10.03.19.38.09;	author thoth;	state Exp;
branches;
next	1.6;

1.6
date	94.10.03.17.48.35;	author thoth;	state Exp;
branches;
next	1.5;

1.5
date	94.09.29.15.46.14;	author gmt;	state Exp;
branches;
next	1.4;

1.4
date	94.09.28.19.43.07;	author gmt;	state Exp;
branches;
next	1.3;

1.3
date	94.09.26.21.44.20;	author gmt;	state Exp;
branches;
next	1.2;

1.2
date	94.04.26.18.08.17;	author thoth;	state Exp;
branches;
next	1.1;

1.1
date	94.03.21.23.06.53;	author thoth;	state Exp;
branches;
next	;

1.8.1.1
date	94.10.12.17.20.06;	author thoth;	state Exp;
branches;
next	1.8.1.2;

1.8.1.2
date	94.12.08.14.43.38;	author thoth;	state Exp;
branches;
next	;


desc
@Container class for the generic Set
@


1.9
log
@Fixed a return value for another volatile function for compilers
that do not deal with volatile functions.
@
text
@// Emacs -*- C++ -*-

//
//	Copyright 1993, Center for Computer Vision and Visualization,
//	University of Florida.  All rights reserved.
//

//
// $Log: Set.c,v $
// Revision 1.8  1994/10/04  05:38:18  gmt
// Addes some "return 0"'s for those compilers that cannot deal with
// volatile functions.
//
// Revision 1.7  1994/10/03  19:38:09  thoth
// Get rid of redundant scalar-set operations in preparation for operator
// table.
//
// Revision 1.6  1994/10/03  17:48:35  thoth
// Added predicate sets.
//
// Revision 1.5  1994/09/29  15:46:14  gmt
// Put wrapper IA_NO_VOLATILE_FUNCTIONS ifdef blocks where appropriate.
// Also commented out the slack function at the end of the file.
//
// Revision 1.4  1994/09/28  19:43:07  gmt
// SC++ doesn't deal with volatile correctly. . .
//
// Revision 1.4  1994/09/27  03:36:13  gmt
// The "not yet implemented" cases for some of the set operations
// did not return an IA_Set, and the Mac compiler didn't like it, so. . .
//
// Revision 1.3  1994/09/26  21:44:20  gmt
// Changed IA::LatticeRelation to IA_LatticeRelation so that the
// Symantec compiler will like it.
//
// Revision 1.2  1994/04/26  18:08:17  thoth
// Added compare function between Sets.
//
// Revision 1.1  1994/03/21  23:06:53  thoth
// Initial revision
//

#define SUPPRESS_INCLUDE
#include "Set.h"
#include "ValueSet.h"
#include "LazySet.h"

template <class T>
void IA_Set<T>::set_and_reference(IA_BaseSet<T> *p)
{
    bsp = p;
    p->incr_ref();
}

template <class T>
void IA_Set<T>::disassociate()
{
    if (bsp->decr_ref()<=0) {
	delete bsp;
    }
    bsp=0;
}

template <class T>
IA_Set<T>::IA_Set() {
    set_and_reference(new IA_ValueSet<T>);
}

template <class T>
IA_Set<T>::IA_Set(const IA_Set<T>& s) {
    set_and_reference(s.bsp);
}

template <class T>
IA_Set<T>::~IA_Set() {
    disassociate();
}

template <class T>
IA_Set<T> & IA_Set<T>::operator=(const IA_Set<T>& s)
{
    IA_BaseSet<T>	*temp = s.bsp;

    temp->incr_ref();

    disassociate();
    
    bsp = temp;
    return *this;
}

template <class T>
IA_Set<T>::IA_Set(T t1) {
    set_and_reference(new IA_ValueSet<T>(t1));
}

template <class T>
IA_Set<T>::IA_Set(T t1, T t2) {
    set_and_reference(new IA_ValueSet<T>(t1, t2));
}

template <class T>
IA_Set<T>::IA_Set(T t1, T t2, T t3) {
    set_and_reference(new IA_ValueSet<T>(t1, t2, t3));
}

template <class T>
IA_Set<T>::IA_Set(T t1, T t2, T t3, T t4) {
    set_and_reference(new IA_ValueSet<T>(t1, t2, t3, t4));
}

template <class T>
IA_Set<T>::IA_Set(T t1, T t2, T t3, T t4, T t5) {
    set_and_reference(new IA_ValueSet<T>(t1, t2, t3, t4, t5));
}

template <class T>
IA_Set<T>::IA_Set(const T *t, unsigned int len) {
    set_and_reference(new IA_ValueSet<T>(t, len));
}

template <class T>
IA_Set<T>::IA_Set(int (*f)(T)) {
    set_and_reference(new IA_PredicateSet_V<T>(f));
}

template <class T>
IA_Set<T>::IA_Set(int (*f)(const T&)) {
    set_and_reference(new IA_PredicateSet_CR<T>(f));
}
//
//

#if 1

// comparisons go here

#define STUBBY

template <class T>
int operator<(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return *lhs_ < *rhs_;
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}

template <class T>
int operator<=(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return *lhs_ <= *rhs_;
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}

template <class T>
int operator==(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return *lhs_ == *rhs_;
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}

#if 0
template <class T>
int operator>=(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return *lhs_ >= *rhs_;
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}

template <class T>
int operator>=(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return *lhs_ >= *rhs_;
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}

template <class T>
int disjoint(const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
#ifdef STUBBY
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return disjoint(*lhs_,*rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return 0;
#endif
    }
#endif
}
#endif

#endif

template <class T>
#ifdef IA_NO_NESTED_ENUMS
IA_LatticeRelation
#else
IA::LatticeRelation
#endif
compare(const IA_Set<T>&lhs,
	const IA_Set<T>&rhs)
{
  if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
      rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return compare(*lhs_,*rhs_);
  } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA::NO_REL;
#endif
  }
}


//
//
//

template <class T>
IA_Set<T> operator| (const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(*lhs_ | *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator& (const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(*lhs_ & *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator/ (const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(*lhs_ / *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator^ (const IA_Set<T> &lhs, const IA_Set<T> &rhs)
{
    if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(*lhs_ ^ *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

//
//
//

#if 0

template <class T>
IA_Set<T> operator|(const T &lhs, const IA_Set<T> &rhs)
{
    if (rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(IA_ValueSet<T>(lhs) | *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator&(const T &lhs, const IA_Set<T> &rhs)
{
    if (rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(IA_ValueSet<T>(lhs) & *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator/(const T &lhs, const IA_Set<T> &rhs)
{
    if (rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(IA_ValueSet<T>(lhs) / *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__, __LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> operator^(const T &lhs, const IA_Set<T> &rhs)
{
    if (rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	return new IA_ValueSet<T>(IA_ValueSet<T>(lhs) ^ *rhs_);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

//
//
//

template <class T>
IA_Set<T> IA_Set<T>::operator| (const T &rhs) const
{
    if (bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	return new IA_ValueSet<T>(*lhs_ | rhs);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> IA_Set<T>::operator& (const T &rhs) const
{
    if (bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	return new IA_ValueSet<T>(*lhs_ & rhs);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> IA_Set<T>::operator/ (const T &rhs) const
{
    if (bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	return new IA_ValueSet<T>(*lhs_ / rhs);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}

template <class T>
IA_Set<T> IA_Set<T>::operator^ (const T &rhs) const
{
    if (bsp->type()==IA_ValueSet<T>::s_type()) {
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
	return new IA_ValueSet<T>(*lhs_ ^ rhs);
    } else {
	IA::not_yet_implemented(__FILE__,__LINE__);
#ifdef IA_NO_VOLATILE_FUNCTIONS
	return IA_Set<T>();
#endif
    }
}
#endif
@


1.8
log
@Addes some "return 0"'s for those compilers that cannot deal with
volatile functions.
@
text
@d10 4
d268 3
@


1.8.1.1
log
@Added ClosureSets.
Removed the binary operations to let the operations table work.
@
text
@a9 4
// Revision 1.8  1994/10/04  05:38:18  gmt
// Addes some "return 0"'s for those compilers that cannot deal with
// volatile functions.
//
a42 1
#include "ClosureSet.h"
a126 7

template <class T>
IA_Set<T>::IA_Set(const IA_ClosureSet<T> & set)
{
    set_and_reference(set.clone_self());
}

d267 131
d401 57
@


1.8.1.2
log
@Comparison rework to handle more computable cases.
@
text
@a9 4
// Revision 1.8.1.1  1994/10/12  17:20:06  thoth
// Added ClosureSets.
// Removed the binary operations to let the operations table work.
//
a44 1
#include "SetIter.h"
d142 1
a142 1
#if 0
d269 8
a276 78
   if (lhs.extensive()) {
       if (rhs.extensive()) {
	   if (lhs.bsp->type()==IA_ValueSet<T>::s_type() &&
	       rhs.bsp->type()==IA_ValueSet<T>::s_type()) {
	       IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)lhs.bsp;
	       IA_ValueSet<T>	*rhs_ = (IA_ValueSet<T>*)rhs.bsp;
	       return compare(*lhs_,*rhs_);
	   } else {
	       IA_SetIter<T>	liter(lhs), riter(rhs);
	       T	lv, rv;
	       IA::LatticeRelation	rval=IA::EQUAL;
	       if (!liter.done() && !riter.done()) {
		   liter.curr(lv);
		   riter.curr(rv);
		   while (!liter.done() && !riter.done()) {
		       int cmp = IA_ValueSet<T>::value_type_compare(&lv, &rv);
		       if (cmp<0) {
			   if (rval==IA::P_SUBSET)
			       return IA::NO_REL;
			   liter();
			   liter.curr(lv);
			   rval = IA::P_SUPERSET;
		       } else if (cmp==0) {
			   liter();
			   liter.curr(lv);
			   riter();
			   riter.curr(rv);
		       } else /* cmp>0 */ {
			   if (rval==IA::P_SUPERSET)
			       return IA::NO_REL;
			   riter();
			   riter.curr(rv);
			   rval = IA::P_SUBSET;
		       }
		   }
	       }
	       if (!liter.done()) {
		   if (rval==IA::P_SUBSET)
		       return IA::NO_REL;
		   return IA::P_SUPERSET;
	       } else if (!riter.done()) {
		   if (rval==IA::P_SUPERSET)
		       return IA::NO_REL;
		   return IA::P_SUBSET;
	       } else {
		   return rval;
	       }
	       
	   }
       } else /* !rhs.extensive() */ {
	   IA_SetIter<T>	liter(lhs);
	   int	contained=1;
	   T	val;
	   while (liter(val)) {
	       if (!rhs.contains(val)) {
		   contained=0;
		   break;
	       }
	   }
	   return contained ? IA::MP_SUBSET : IA::UNKNOWN;
       }
   } else /* ! lhs.extensive() */ {
       if (rhs.extensive()) {
	   IA_SetIter<T>	riter(rhs);
	   int	contained=1;
	   T	val;
	   while (riter(val)) {
	       if (!lhs.contains(val)) {
		   contained=0;
		   break;
	       }
	   }
	   return contained ? IA::MP_SUPERSET : IA::UNKNOWN;
       } else /* !rhs.extensive() */ {
	   return IA::UNKNOWN;
       }
   }

@


1.7
log
@Get rid of redundant scalar-set operations in preparation for operator
table.
@
text
@d10 4
d165 3
d183 3
d202 3
d220 3
d238 3
@


1.6
log
@Added predicate sets.
@
text
@d10 3
d254 1
a254 1
IA_Set<T> IA_Set<T>::operator| (const IA_Set<T> &rhs) const
d256 1
a256 1
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
d258 1
a258 1
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
d270 1
a270 1
IA_Set<T> IA_Set<T>::operator& (const IA_Set<T> &rhs) const
d272 1
a272 1
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
d274 1
a274 1
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
d286 1
a286 1
IA_Set<T> IA_Set<T>::operator/ (const IA_Set<T> &rhs) const
d288 1
a288 1
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
d290 1
a290 1
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
d302 1
a302 1
IA_Set<T> IA_Set<T>::operator^ (const IA_Set<T> &rhs) const
d304 1
a304 1
    if (bsp->type()==IA_ValueSet<T>::s_type() &&
d306 1
a306 1
	IA_ValueSet<T>	*lhs_ = (IA_ValueSet<T>*)bsp;
d321 2
d328 1
a328 1
	return new IA_ValueSet<T>(lhs | *rhs_);
d342 1
a342 1
	return new IA_ValueSet<T>(lhs & *rhs_);
d356 1
a356 1
	return new IA_ValueSet<T>(lhs / *rhs_);
d370 1
a370 1
	return new IA_ValueSet<T>(lhs ^ *rhs_);
d438 1
@


1.5
log
@Put wrapper IA_NO_VOLATILE_FUNCTIONS ifdef blocks where appropriate.
Also commented out the slack function at the end of the file.
@
text
@d10 4
d35 1
d111 9
d176 1
d227 1
d229 3
d248 1
d261 1
a261 2
	IA_Set<T> tmp;
	return tmp;
d277 1
a277 2
	IA_Set<T> tmp;
	return tmp;
d293 1
a293 2
	IA_Set<T> tmp;
	return tmp;
d309 1
a309 2
	IA_Set<T> tmp;
	return tmp;
d313 1
d316 1
d327 1
a327 2
	IA_Set<T> tmp;
	return tmp;
d341 1
a341 2
	IA_Set<T> tmp;
	return tmp;
d355 1
a355 2
	IA_Set<T> tmp;
	return tmp;
d369 1
a369 2
	IA_Set<T> tmp;
	return tmp;
d376 1
d387 1
a387 2
	IA_Set<T> tmp;
	return tmp;
d401 1
a401 2
	IA_Set<T> tmp;
	return tmp;
d415 1
a415 2
	IA_Set<T> tmp;
	return tmp;
d429 1
a429 2
	IA_Set<T> tmp;
	return tmp;
a432 9

//
//
//

#if 0
void slack() {
}
#endif
@


1.4
log
@SC++ doesn't deal with volatile correctly. . .
@
text
@d10 3
d126 3
d240 1
d243 1
d257 1
d260 1
d274 1
d277 1
d291 1
d294 1
d308 1
d311 1
d323 1
d326 1
d338 1
d341 1
d353 1
d356 1
d371 1
d374 1
d386 1
d389 1
d401 1
d404 1
d416 1
d419 1
d427 1
d430 1
@


1.3
log
@Changed IA::LatticeRelation to IA_LatticeRelation so that the
Symantec compiler will like it.
@
text
@d10 8
d234 2
d249 2
d264 2
d279 2
d294 2
d307 2
d320 2
d333 2
d349 2
d362 2
d375 2
d388 2
@


1.2
log
@Added compare function between Sets.
@
text
@d10 3
d198 1
a198 1
IA::LatticeRelation
a266 1

@


1.1
log
@Initial revision
@
text
@d9 4
a12 1
// $Log$
d193 16
@
