[MLIR][Presburger][NFC] Use "disjunct" to refer to disjuncts in PresburgerRelation

[Groverkss]

Summary

This patch modifies the name "integerRelations" and "relation" to refer to the
disjuncts in PresburgerRelation to "disjunct(s)". This is done to be
consistent with the rest of the interface.

mlir/include/mlir/Analysis/Presburger/PresburgerRelation.h

 /// heuristic. It is built from a `PresburgerRelation` and has the `coalesce()`
 /// function as its main API.
 class SetCoalescer;
 
 /// A PresburgerRelation represents a union of IntegerRelations that live in
 /// the same PresburgerSpace with support for union, intersection, subtraction,
 /// and complement operations, as well as sampling.
 ///
-/// The IntegerRelations (relations) are stored in a vector, and the set
+/// The IntegerRelations (disjuncts) are stored in a vector, and the set
 /// represents the union of these relations. An empty list corresponds to
 /// the empty set.
 ///
-/// Note that there are no invariants guaranteed on the list of relations
+/// Note that there are no invariants guaranteed on the list of disjuncts
 /// other than that they are all in the same PresburgerSpace. For example, the
 /// relations may overlap with each other.
 class PresburgerRelation : public PresburgerSpace {
 public:
   /// Return a universe set of the specified type that contains all points.
   static PresburgerRelation getUniverse(const PresburgerSpace &space);
 
   /// Return an empty set of the specified type that contains no points.
   static PresburgerRelation getEmpty(const PresburgerSpace &space);
 
   explicit PresburgerRelation(const IntegerRelation &disjunct);
 
-  /// Return the number of Disjuncts in the union.
+  /// Return the number of disjuncts in the union.
   unsigned getNumDisjuncts() const;
 
-  /// Return a reference to the list of IntegerRelations.
+  /// Return a reference to the list of disjuncts.
   ArrayRef<IntegerRelation> getAllDisjuncts() const;
 
-  /// Return the IntegerRelation at the specified index.
+  /// Return the disjunct at the specified index.
   const IntegerRelation &getDisjunct(unsigned index) const;
 
   /// Mutate this set, turning it into the union of this set and the given
-  /// IntegerRelation.
+  /// disjunct.
   void unionInPlace(const IntegerRelation &disjunct);
 
   /// Mutate this set, turning it into the union of this set and the given set.
   void unionInPlace(const PresburgerRelation &set);
 
   /// Return the union of this set and the given set.
   PresburgerRelation unionSet(const PresburgerRelation &set) const;
 
protected:
   /// Construct an empty PresburgerRelation with the specified number of
   /// dimension and symbols.
   PresburgerRelation(const PresburgerSpace &space) : PresburgerSpace(space) {
     assert(space.getNumLocalIds() == 0 &&
            "PresburgerRelation cannot have local ids.");
   }
 
   /// The list of disjuncts that this set is the union of.
-  SmallVector<IntegerRelation, 2> integerRelations;
+  SmallVector<IntegerRelation, 2> disjuncts;
 
   friend class SetCoalescer;
 };
 
 class PresburgerSet : public PresburgerRelation {
 public:
   /// Return a universe set of the specified type that contains all points.
   static PresburgerSet getUniverse(const PresburgerSpace &space);

mlir/lib/Analysis/Presburger/PresburgerRelation.cpp

 using namespace presburger;
 
 PresburgerRelation::PresburgerRelation(const IntegerRelation &disjunct)
     : PresburgerSpace(disjunct.getCompatibleSpace()) {
   unionInPlace(disjunct);
 }
 
 unsigned PresburgerRelation::getNumDisjuncts() const {
-  return integerRelations.size();
+  return disjuncts.size();
 }
 
 ArrayRef<IntegerRelation> PresburgerRelation::getAllDisjuncts() const {
-  return integerRelations;
+  return disjuncts;
 }
 
 const IntegerRelation &PresburgerRelation::getDisjunct(unsigned index) const {
-  assert(index < integerRelations.size() && "index out of bounds!");
-  return integerRelations[index];
+  assert(index < disjuncts.size() && "index out of bounds!");
+  return disjuncts[index];
 }
 
 /// Mutate this set, turning it into the union of this set and the given
 /// IntegerRelation.
 void PresburgerRelation::unionInPlace(const IntegerRelation &disjunct) {
   assert(isSpaceCompatible(disjunct) && "Spaces should match");
-  integerRelations.push_back(disjunct);
+  disjuncts.push_back(disjunct);
 }
 
 /// Mutate this set, turning it into the union of this set and the given set.
 ///
 /// This is accomplished by simply adding all the disjuncts of the given set
 /// to this set.
 void PresburgerRelation::unionInPlace(const PresburgerRelation &set) {
   assert(isSpaceCompatible(set) && "Spaces should match");
-  for (const IntegerRelation &disjunct : set.integerRelations)
+  for (const IntegerRelation &disjunct : set.disjuncts)
     unionInPlace(disjunct);
 }
 
 /// Return the union of this set and the given set.
 PresburgerRelation
 PresburgerRelation::unionSet(const PresburgerRelation &set) const {
   assert(isSpaceCompatible(set) && "Spaces should match");
   PresburgerRelation result = *this;
   result.unionInPlace(set);
   return result;
 }
 
 /// A point is contained in the union iff any of the parts contain the point.
 bool PresburgerRelation::containsPoint(ArrayRef<int64_t> point) const {
-  return llvm::any_of(integerRelations, [&](const IntegerRelation &disjunct) {
+  return llvm::any_of(disjuncts, [&](const IntegerRelation &disjunct) {
     return (disjunct.containsPoint(point));
   });
 }
 
 PresburgerRelation
 PresburgerRelation::getUniverse(const PresburgerSpace &space) {
   PresburgerRelation result(space);
   result.unionInPlace(IntegerRelation::getUniverse(space));

 //
 // If S_i or T_j have local variables, then S_i and T_j contains the local
 // variables of both.
 PresburgerRelation
 PresburgerRelation::intersect(const PresburgerRelation &set) const {
   assert(isSpaceCompatible(set) && "Spaces should match");
 
   PresburgerRelation result(getSpace());
-  for (const IntegerRelation &csA : integerRelations) {
-    for (const IntegerRelation &csB : set.integerRelations) {
+  for (const IntegerRelation &csA : disjuncts) {
+    for (const IntegerRelation &csB : set.disjuncts) {
       IntegerRelation intersection = csA.intersect(csB);
       if (!intersection.isEmpty())
         result.unionInPlace(intersection);
     }
   }
   return result;
 }
 

 
 /// Return the result of subtract the given set from this set, i.e.,
 /// return `this \ set`.
 PresburgerRelation
 PresburgerRelation::subtract(const PresburgerRelation &set) const {
   assert(isSpaceCompatible(set) && "Spaces should match");
   PresburgerRelation result(getSpace());
   // We compute (U_i t_i) \ (U_i set_i) as U_i (t_i \ V_i set_i).
-  for (const IntegerRelation &disjunct : integerRelations)
+  for (const IntegerRelation &disjunct : disjuncts)
     result.unionInPlace(getSetDifference(disjunct, set));
   return result;
 }
 
 /// T is a subset of S iff T \ S is empty, since if T \ S contains a
 /// point then this is a point that is contained in T but not S, and
 /// if T contains a point that is not in S, this also lies in T \ S.
 bool PresburgerRelation::isSubsetOf(const PresburgerRelation &set) const {
   return this->subtract(set).isIntegerEmpty();
 }
 
 /// Two sets are equal iff they are subsets of each other.
 bool PresburgerRelation::isEqual(const PresburgerRelation &set) const {
   assert(isSpaceCompatible(set) && "Spaces should match");
   return this->isSubsetOf(set) && set.isSubsetOf(*this);
 }
 
 /// Return true if all the sets in the union are known to be integer empty,
 /// false otherwise.
 bool PresburgerRelation::isIntegerEmpty() const {
   // The set is empty iff all of the disjuncts are empty.
-  return llvm::all_of(integerRelations,
-                      std::mem_fn(&IntegerRelation::isIntegerEmpty));
+  return llvm::all_of(disjuncts, std::mem_fn(&IntegerRelation::isIntegerEmpty));
 }
 
 bool PresburgerRelation::findIntegerSample(SmallVectorImpl<int64_t> &sample) {
   // A sample exists iff any of the disjuncts contains a sample.
-  for (const IntegerRelation &disjunct : integerRelations) {
+  for (const IntegerRelation &disjunct : disjuncts) {
     if (Optional<SmallVector<int64_t, 8>> opt = disjunct.findIntegerSample()) {
       sample = std::move(*opt);
       return true;
     }
   }
   return false;
 }
 
 Optional<uint64_t> PresburgerRelation::computeVolume() const {
   assert(getNumSymbolIds() == 0 && "Symbols are not yet supported!");
   // The sum of the volumes of the disjuncts is a valid overapproximation of the
   // volume of their union, even if they overlap.
   uint64_t result = 0;
-  for (const IntegerRelation &disjunct : integerRelations) {
+  for (const IntegerRelation &disjunct : disjuncts) {
     Optional<uint64_t> volume = disjunct.computeVolume();
     if (!volume)
       return {};
     result += *volume;
   }
   return result;
 }
 
private:
   /// disjuncts in `disjuncts` left.
   LogicalResult coalescePair(unsigned i, unsigned j);
 };
 
 /// Constructs a `SetCoalescer` from a `PresburgerRelation`. Only adds non-empty
 /// `IntegerRelation`s to the `disjuncts` vector.
 SetCoalescer::SetCoalescer(const PresburgerRelation &s) {
 
-  disjuncts = s.integerRelations;
+  disjuncts = s.disjuncts;
 
   simplices.reserve(s.getNumDisjuncts());
   // Note that disjuncts.size() changes during the loop.
   for (unsigned i = 0; i < disjuncts.size();) {
     disjuncts[i].removeRedundantConstraints();
     Simplex simp(disjuncts[i]);
     if (simp.isEmpty()) {
       disjuncts[i] = disjuncts[disjuncts.size() - 1];

 }
 
 PresburgerRelation PresburgerRelation::coalesce() const {
   return SetCoalescer(*this).coalesce();
 }
 
 void PresburgerRelation::print(raw_ostream &os) const {
   os << "Number of Disjuncts: " << getNumDisjuncts() << "\n";
-  for (const IntegerRelation &disjunct : integerRelations) {
+  for (const IntegerRelation &disjunct : disjuncts) {
     disjunct.print(os);
     os << '\n';
   }
 }
 
 void PresburgerRelation::dump() const { print(llvm::errs()); }
 
 PresburgerSet PresburgerSet::getUniverse(const PresburgerSpace &space) {