[MLIR][Presburger] Clean PresburgerSet identifier interface to match IntegerPolyhedron's interface

[Groverkss]

Summary

This patch changes names of identifiers and their corresponding getters in
PresburgerSet to match those of IntegerPolyhedron.

mlir/include/mlir/Analysis/Presburger/PresburgerSet.h

 class PresburgerSet {
 public:
   explicit PresburgerSet(const IntegerPolyhedron &poly);
 
   /// Return the number of Polys in the union.
   unsigned getNumPolys() const;
 
   /// Return the number of real dimensions.
-  unsigned getNumDims() const;
+  unsigned getNumDimIds() const;
 
   /// Return the number of symbolic dimensions.
-  unsigned getNumSyms() const;
+  unsigned getNumSymbolIds() const;
 
   /// Return a reference to the list of IntegerPolyhedrons.
   ArrayRef<IntegerPolyhedron> getAllIntegerPolyhedron() const;
 
   /// Return the IntegerPolyhedron at the specified index.
   const IntegerPolyhedron &getIntegerPolyhedron(unsigned index) const;
 
   /// Mutate this set, turning it into the union of this set and the given
public:
   /// divisions.
   PresburgerSet subtract(const PresburgerSet &set) const;
 
   /// Return true if this set is equal to the given set, and false otherwise.
   /// All local variables in both sets must correspond to floor divisions.
   bool isEqual(const PresburgerSet &set) const;
 
   /// Return a universe set of the specified type that contains all points.
-  static PresburgerSet getUniverse(unsigned nDim = 0, unsigned nSym = 0);
+  static PresburgerSet getUniverse(unsigned numDims = 0,
+                                   unsigned numSymbols = 0);
   /// Return an empty set of the specified type that contains no points.
-  static PresburgerSet getEmptySet(unsigned nDim = 0, unsigned nSym = 0);
+  static PresburgerSet getEmptySet(unsigned numDims = 0,
+                                   unsigned numSymbols = 0);
 
   /// Return true if all the sets in the union are known to be integer empty
   /// false otherwise.
   bool isIntegerEmpty() const;
 
   /// Find an integer sample from the given set. This should not be called if
   /// any of the Polys in the union are unbounded.
   bool findIntegerSample(SmallVectorImpl<int64_t> &sample);
 
   /// Simplifies the representation of a PresburgerSet.
   ///
   /// In particular, removes all Polys which are subsets of other Polys in the
   /// union.
   PresburgerSet coalesce() const;
 
 private:
   /// Construct an empty PresburgerSet.
-  PresburgerSet(unsigned nDim = 0, unsigned nSym = 0)
-      : nDim(nDim), nSym(nSym) {}
+  PresburgerSet(unsigned numDims = 0, unsigned numSymbols = 0)
+      : numDims(numDims), numSymbols(numSymbols) {}
 
   /// Return the set difference poly \ set.
   static PresburgerSet getSetDifference(IntegerPolyhedron poly,
                                         const PresburgerSet &set);
 
   /// Number of identifiers corresponding to real dimensions.
-  unsigned nDim;
+  unsigned numDims;
 
   /// Number of symbolic dimensions, unknown but constant for analysis, as in
   /// IntegerPolyhedron.
-  unsigned nSym;
+  unsigned numSymbols;
 
   /// The list of integerPolyhedrons that this set is the union of.
   SmallVector<IntegerPolyhedron, 2> integerPolyhedrons;
 };
 
 } // namespace mlir
 
 #endif // MLIR_ANALYSIS_PRESBURGER_PRESBURGERSET_H

mlir/lib/Analysis/Presburger/PresburgerSet.cpp

 #include "mlir/Analysis/Presburger/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 using namespace mlir;
 using namespace presburger_utils;
 
 PresburgerSet::PresburgerSet(const IntegerPolyhedron &poly)
-    : nDim(poly.getNumDimIds()), nSym(poly.getNumSymbolIds()) {
+    : numDims(poly.getNumDimIds()), numSymbols(poly.getNumSymbolIds()) {
   unionPolyInPlace(poly);
 }
 
 unsigned PresburgerSet::getNumPolys() const {
   return integerPolyhedrons.size();
 }
 
-unsigned PresburgerSet::getNumDims() const { return nDim; }
+unsigned PresburgerSet::getNumDimIds() const { return numDims; }
 
-unsigned PresburgerSet::getNumSyms() const { return nSym; }
+unsigned PresburgerSet::getNumSymbolIds() const { return numSymbols; }
 
 ArrayRef<IntegerPolyhedron> PresburgerSet::getAllIntegerPolyhedron() const {
   return integerPolyhedrons;
 }
 
 const IntegerPolyhedron &
 PresburgerSet::getIntegerPolyhedron(unsigned index) const {
   assert(index < integerPolyhedrons.size() && "index out of bounds!");
   return integerPolyhedrons[index];
 }
 
 /// Assert that the IntegerPolyhedron and PresburgerSet live in
 /// compatible spaces.
 static void assertDimensionsCompatible(const IntegerPolyhedron &poly,
                                        const PresburgerSet &set) {
-  assert(poly.getNumDimIds() == set.getNumDims() &&
+  assert(poly.getNumDimIds() == set.getNumDimIds() &&
          "Number of dimensions of the IntegerPolyhedron and PresburgerSet"
          "do not match!");
-  assert(poly.getNumSymbolIds() == set.getNumSyms() &&
+  assert(poly.getNumSymbolIds() == set.getNumSymbolIds() &&
          "Number of symbols of the IntegerPolyhedron and PresburgerSet"
          "do not match!");
 }
 
 /// Assert that the two PresburgerSets live in compatible spaces.
 static void assertDimensionsCompatible(const PresburgerSet &setA,
                                        const PresburgerSet &setB) {
-  assert(setA.getNumDims() == setB.getNumDims() &&
+  assert(setA.getNumDimIds() == setB.getNumDimIds() &&
          "Number of dimensions of the PresburgerSets do not match!");
-  assert(setA.getNumSyms() == setB.getNumSyms() &&
+  assert(setA.getNumSymbolIds() == setB.getNumSymbolIds() &&
          "Number of symbols of the PresburgerSets do not match!");
 }
 
 /// Mutate this set, turning it into the union of this set and the given
 /// IntegerPolyhedron.
 void PresburgerSet::unionPolyInPlace(const IntegerPolyhedron &poly) {
   assertDimensionsCompatible(poly, *this);
   integerPolyhedrons.push_back(poly);

 
 /// A point is contained in the union iff any of the parts contain the point.
 bool PresburgerSet::containsPoint(ArrayRef<int64_t> point) const {
   return llvm::any_of(integerPolyhedrons, [&](const IntegerPolyhedron &poly) {
     return (poly.containsPoint(point));
   });
 }
 
-PresburgerSet PresburgerSet::getUniverse(unsigned nDim, unsigned nSym) {
-  PresburgerSet result(nDim, nSym);
-  result.unionPolyInPlace(IntegerPolyhedron::getUniverse(nDim, nSym));
+PresburgerSet PresburgerSet::getUniverse(unsigned numDims,
+                                         unsigned numSymbols) {
+  PresburgerSet result(numDims, numSymbols);
+  result.unionPolyInPlace(IntegerPolyhedron::getUniverse(numDims, numSymbols));
   return result;
 }
 
-PresburgerSet PresburgerSet::getEmptySet(unsigned nDim, unsigned nSym) {
-  return PresburgerSet(nDim, nSym);
+PresburgerSet PresburgerSet::getEmptySet(unsigned numDims,
+                                         unsigned numSymbols) {
+  return PresburgerSet(numDims, numSymbols);
 }
 
 // Return the intersection of this set with the given set.
 //
 // We directly compute (S_1 or S_2 ...) and (T_1 or T_2 ...)
 // as (S_1 and T_1) or (S_1 and T_2) or ...
 //
 // If S_i or T_j have local variables, then S_i and T_j contains the local
 // variables of both.
 PresburgerSet PresburgerSet::intersect(const PresburgerSet &set) const {
   assertDimensionsCompatible(set, *this);
 
-  PresburgerSet result(nDim, nSym);
+  PresburgerSet result(getNumDimIds(), getNumSymbolIds());
   for (const IntegerPolyhedron &csA : integerPolyhedrons) {
     for (const IntegerPolyhedron &csB : set.integerPolyhedrons) {
       IntegerPolyhedron csACopy = csA, csBCopy = csB;
       csACopy.mergeLocalIds(csBCopy);
       csACopy.append(csBCopy);
       if (!csACopy.isEmpty())
         result.unionPolyInPlace(csACopy);
     }
PresburgerSet PresburgerSet::getSetDifference(IntegerPolyhedron poly,
   Simplex simplex(poly);
   subtractRecursively(poly, simplex, set, 0, result);
   return result;
 }
 
 /// Return the complement of this set.
 PresburgerSet PresburgerSet::complement() const {
   return getSetDifference(
-      IntegerPolyhedron::getUniverse(getNumDims(), getNumSyms()), *this);
+      IntegerPolyhedron::getUniverse(getNumDimIds(), getNumSymbolIds()), *this);
 }
 
 /// Return the result of subtract the given set from this set, i.e.,
 /// return `this \ set`.
 PresburgerSet PresburgerSet::subtract(const PresburgerSet &set) const {
   assertDimensionsCompatible(set, *this);
-  PresburgerSet result(nDim, nSym);
+  PresburgerSet result(getNumDimIds(), getNumSymbolIds());
   // We compute (U_i t_i) \ (U_i set_i) as U_i (t_i \ V_i set_i).
   for (const IntegerPolyhedron &poly : integerPolyhedrons)
     result.unionSetInPlace(getSetDifference(poly, set));
   return result;
 }
 
 /// Two sets S and T are equal iff S contains T and T contains S.
 /// By "S contains T", we mean that S is a superset of or equal to T.
if (Optional<SmallVector<int64_t, 8>> opt = poly.findIntegerSample()) {
       sample = std::move(*opt);
       return true;
     }
   }
   return false;
 }
 
 PresburgerSet PresburgerSet::coalesce() const {
-  PresburgerSet newSet = PresburgerSet::getEmptySet(getNumDims(), getNumSyms());
+  PresburgerSet newSet =
+      PresburgerSet::getEmptySet(getNumDimIds(), getNumSymbolIds());
   llvm::SmallBitVector isRedundant(getNumPolys());
 
   for (unsigned i = 0, e = integerPolyhedrons.size(); i < e; ++i) {
     if (isRedundant[i])
       continue;
     Simplex simplex(integerPolyhedrons[i]);
 
     // Check whether the polytope of `simplex` is empty. If so, it is trivially