diff --git a/src/main/java/org/apache/datasketches/common/Util.java b/src/main/java/org/apache/datasketches/common/Util.java
index 35f8a9be1..729b92f3f 100644
--- a/src/main/java/org/apache/datasketches/common/Util.java
+++ b/src/main/java/org/apache/datasketches/common/Util.java
@@ -290,67 +290,45 @@ public static boolean isMultipleOf8AndGT0(final long v) {
   //Powers of 2 or powers of base related
 
   /**
-   * Returns true if given int argument is exactly a positive power of 2 and greater than zero.
+   * Returns true if given long argument is exactly a positive power of 2.
    *
-   * @param powerOf2 The input argument.
-   * @return true if argument is exactly a positive power of 2 and greater than zero.
-   */
-  public static boolean isIntPowerOf2(final int powerOf2) {
-    return powerOf2 > 0 && (powerOf2 & powerOf2 - 1) == 0; //or (v > 0) && ((v & -v) == v)
-  }
-
-  /**
-   * Returns true if given long argument is exactly a positive power of 2 and greater than zero.
-   *
-   * @param powerOf2 The input argument.
-   * @return true if argument is exactly a positive power of 2 and greater than zero.
-   */
-  public static boolean isLongPowerOf2(final long powerOf2) {
-    return powerOf2 > 0 && (powerOf2 & powerOf2 - 1L) == 0; //or (v > 0) && ((v & -v) == v)
-  }
-
-  /**
-   * Checks the given int argument to make sure it is a positive power of 2 and greater than zero.
-   * If not it throws an exception with the user supplied local argument name.
-   * @param powerOf2 The input int argument must be a power of 2 and greater than zero.
-   * @param argName Used in the thrown exception.
-   * @throws SketchesArgumentException if not a power of 2 nor greater than zero.
+   * @param n The input argument.
+   * @return true if argument is exactly a positive power of 2.
    */
-  public static void checkIfIntPowerOf2(final int powerOf2, final String argName) {
-    if (isIntPowerOf2(powerOf2)) { return; }
-    throw new SketchesArgumentException("The value of the int argument \"" + argName + "\""
-        + " must be a positive integer-power of 2" + " and greater than 0: " + powerOf2);
+  public static boolean isPowerOf2(final long n) {
+    return (n > 0) && ((n & (n - 1L)) == 0); //or (n > 0) && ((n & -n) == n)
   }
 
   /**
-   * Checks the given long argument to make sure it is a positive power of 2 and greater than zero.
-   * If not, it throws an exception with the user supplied local argument name.
-   * @param powerOf2 The input long argument must be a power of 2 and greater than zero.
-   * @param argName Used in the thrown exception.
-   * @throws SketchesArgumentException if not a power of 2 nor greater than zero.
+   * Checks the given long argument if it is a positive integer power of 2.
+   * If not, it throws an exception with the user supplied local argument name, if not null.
+   * @param n The input long argument must be a positive integer power of 2.
+   * @param argName Used in the thrown exception. It may be null.
+   * @throws SketchesArgumentException if not a positive integer power of 2.
    */
-  public static void checkIfLongPowerOf2(final long powerOf2, final String argName) {
-    if (isLongPowerOf2(powerOf2)) { return; }
-    throw new SketchesArgumentException("The value of the int argument \"" + argName + "\""
-        + " must be a positive integer-power of 2" + " and greater than 0: " + powerOf2);
+  public static void checkIfPowerOf2(final long n, String argName) {
+    if (isPowerOf2(n)) { return; }
+    argName = (argName == null) ? "" : argName;
+    throw new SketchesArgumentException("The value of the argument \"" + argName + "\""
+        + " must be a positive integer power of 2: " + n);
   }
 
   /**
    * Computes the int ceiling power of 2 within the range [1, 2^30]. This is the smallest positive power
-   * of 2 that is equal to or greater than the given n and a mathematical integer.
+   * of 2 that is equal to or greater than the given n and a positive integer.
    *
    * <p>For:
    * <ul>
    * <li>n &le; 1: returns 1</li>
    * <li>2^30 &le; n &le; 2^31 -1 : returns 2^30</li>
    * <li>n == an exact power of 2 : returns n</li>
-   * <li>otherwise returns the smallest power of 2 &ge; n and equal to a mathematical integer</li>
+   * <li>otherwise returns the smallest power of 2 &ge; n and equal to a positive integer</li>
    * </ul>
    *
    * @param n The input int argument.
    * @return the ceiling power of 2.
    */
-  public static int ceilingIntPowerOf2(final int n) {
+  public static int ceilingPowerOf2(final int n) {
     if (n <= 1) { return 1; }
     final int topIntPwrOf2 = 1 << 30;
     return n >= topIntPwrOf2 ? topIntPwrOf2 : Integer.highestOneBit(n - 1 << 1);
@@ -358,20 +336,20 @@ public static int ceilingIntPowerOf2(final int n) {
 
   /**
    * Computes the long ceiling power of 2 within the range [1, 2^62]. This is the smallest positive power
-   * of 2 that is equal to or greater than the given n and a mathematical long.
+   * of 2 that is equal to or greater than the given n and a positive long.
    *
    * <p>For:
    * <ul>
    * <li>n &le; 1: returns 1</li>
    * <li>2^62 &le; n &le; 2^63 -1 : returns 2^62</li>
    * <li>n == an exact power of 2 : returns n</li>
-   * <li>otherwise returns the smallest power of 2 &ge; n and equal to a mathematical integer</li>
+   * <li>otherwise returns the smallest power of 2 &ge; n and equal to a positive long</li>
    * </ul>
    *
    * @param n The input long argument.
    * @return the ceiling power of 2.
    */
-  public static long ceilingLongPowerOf2(final long n) {
+  public static long ceilingPowerOf2(final long n) {
     if (n <= 1L) { return 1L; }
     final long topIntPwrOf2 = 1L << 62;
     return n >= topIntPwrOf2 ? topIntPwrOf2 : Long.highestOneBit(n - 1L << 1);
@@ -380,7 +358,7 @@ public static long ceilingLongPowerOf2(final long n) {
   /**
    * Computes the floor power of 2 given <i>n</i> is in the range [1, 2^31-1].
    * This is the largest positive power of 2 that equal to or less than the given n and equal
-   * to a mathematical integer.
+   * to a positive integer.
    *
    * <p>For:
    * <ul>
@@ -402,7 +380,7 @@ public static int floorPowerOf2(final int n) {
   /**
    * Computes the floor power of 2 given <i>n</i> is in the range [1, 2^63-1].
    * This is the largest positive power of 2 that is equal to or less than the given <i>n</i> and
-   * equal to a mathematical integer.
+   * equal to a positive integer.
    *
    * <p>For:
    * <ul>
@@ -534,7 +512,7 @@ public static double powerSeriesNextDouble(final int ppb, final double curPoint,
    * Returns the ceiling of a given <i>n</i> given a <i>base</i>, where the ceiling is an integral power of the base.
    * This is the smallest positive power of <i>base</i> that is equal to or greater than the given <i>n</i>
    * and equal to a mathematical integer.
-   * The result of this function is consistent with {@link #ceilingIntPowerOf2(int)} for values
+   * The result of this function is consistent with {@link #ceilingPowerOf2(int)} for values
    * less than one. I.e., if <i>n &lt; 1,</i> the result is 1.
    *
    * <p>The formula is: <i>base<sup>ceiling(log<sub>base</sub>(x))</sup></i></p>
@@ -622,7 +600,7 @@ public static int numberOfLeadingOnes(final long v) {
    * @throws SketchesArgumentException if not a power of 2 nor greater than zero.
    */
   public static int exactLog2OfInt(final int powerOf2, final String argName) {
-    checkIfIntPowerOf2(powerOf2, argName);
+    checkIfPowerOf2(powerOf2, argName);
     return Integer.numberOfTrailingZeros(powerOf2);
   }
 
@@ -635,7 +613,7 @@ public static int exactLog2OfInt(final int powerOf2, final String argName) {
    * @throws SketchesArgumentException if not a power of 2 nor greater than zero.
    */
   public static int exactLog2OfLong(final long powerOf2, final String argName) {
-    checkIfLongPowerOf2(powerOf2, argName);
+    checkIfPowerOf2(powerOf2, argName);
     return Long.numberOfTrailingZeros(powerOf2);
   }
 
@@ -646,7 +624,7 @@ public static int exactLog2OfLong(final long powerOf2, final String argName) {
    * @return the log2 of the given int value if it is an exact power of 2 and greater than zero.
    */
   public static int exactLog2OfInt(final int powerOf2) {
-    if (!isIntPowerOf2(powerOf2)) {
+    if (!isPowerOf2(powerOf2)) {
       throw new SketchesArgumentException("Argument 'powerOf2' must be a positive power of 2.");
     }
     return Long.numberOfTrailingZeros(powerOf2);
@@ -659,7 +637,7 @@ public static int exactLog2OfInt(final int powerOf2) {
    * @return the log2 of the given long value if it is an exact power of 2 and greater than zero.
    */
   public static int exactLog2OfLong(final long powerOf2) {
-    if (!isLongPowerOf2(powerOf2)) {
+    if (!isPowerOf2(powerOf2)) {
       throw new SketchesArgumentException("Argument 'powerOf2' must be a positive power of 2.");
     }
     return Long.numberOfTrailingZeros(powerOf2);
diff --git a/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java b/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
index 0205c252f..183dcee33 100644
--- a/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
+++ b/src/main/java/org/apache/datasketches/cpc/CompressionCharacterization.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.cpc;
 
 import static org.apache.datasketches.common.Util.INVERSE_GOLDEN_U64;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.log2;
 import static org.apache.datasketches.common.Util.powerSeriesNextDouble;
 import static org.apache.datasketches.cpc.CompressedState.importFromMemory;
@@ -109,7 +109,7 @@ private void doRangeOfNAtLgK(final int lgK) {
 
     while (n <= maxN) {
       final double lgT = (slope * log2(n)) + lgMaxT;
-      final int totTrials = Math.max(ceilingIntPowerOf2((int) Math.pow(2.0, lgT)), (1 << lgMinT));
+      final int totTrials = Math.max(ceilingPowerOf2((int) Math.pow(2.0, lgT)), (1 << lgMinT));
       doTrialsAtLgKAtN(lgK, n, totTrials);
       n = Math.round(powerSeriesNextDouble(uPPO, n, true, 2.0));
     }
diff --git a/src/main/java/org/apache/datasketches/fdt/PostProcessor.java b/src/main/java/org/apache/datasketches/fdt/PostProcessor.java
index e3d96e080..4d4df39a2 100644
--- a/src/main/java/org/apache/datasketches/fdt/PostProcessor.java
+++ b/src/main/java/org/apache/datasketches/fdt/PostProcessor.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.fdt;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.thetacommon.HashOperations.hashSearchOrInsert;
 import static org.apache.datasketches.tuple.Util.stringHash;
 
@@ -64,7 +64,7 @@ public PostProcessor(final FdtSketch sketch, final Group group, final char sep)
     this.sketch = sketch.copy();
     this.sep = sep;
     final int numEntries = sketch.getRetainedEntries();
-    mapArrSize = ceilingIntPowerOf2((int)(numEntries / 0.75));
+    mapArrSize = ceilingPowerOf2((int)(numEntries / 0.75));
     hashArr = new long[mapArrSize];
     priKeyArr = new String[mapArrSize];
     counterArr = new int[mapArrSize];
diff --git a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
index a4cffa38b..7c5bc770d 100644
--- a/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
@@ -22,7 +22,7 @@
 import static org.apache.datasketches.common.Util.LS;
 import static org.apache.datasketches.common.Util.checkBounds;
 import static org.apache.datasketches.common.Util.exactLog2OfInt;
-import static org.apache.datasketches.common.Util.isIntPowerOf2;
+import static org.apache.datasketches.common.Util.isPowerOf2;
 import static org.apache.datasketches.frequencies.PreambleUtil.EMPTY_FLAG_MASK;
 import static org.apache.datasketches.frequencies.PreambleUtil.SER_VER;
 import static org.apache.datasketches.frequencies.PreambleUtil.extractActiveItems;
@@ -321,7 +321,7 @@ public int getCurrentMapCapacity() {
    * @return epsilon used to compute <i>a priori</i> error.
    */
   public static double getEpsilon(final int maxMapSize) {
-    if (!isIntPowerOf2(maxMapSize)) {
+    if (!isPowerOf2(maxMapSize)) {
       throw new SketchesArgumentException("maxMapSize is not a power of 2.");
     }
     return 3.5 / maxMapSize;
diff --git a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
index 6afc33ad4..30452a1b5 100644
--- a/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
+++ b/src/main/java/org/apache/datasketches/frequencies/LongsSketch.java
@@ -22,7 +22,7 @@
 import static org.apache.datasketches.common.Util.LS;
 import static org.apache.datasketches.common.Util.checkBounds;
 import static org.apache.datasketches.common.Util.exactLog2OfInt;
-import static org.apache.datasketches.common.Util.isIntPowerOf2;
+import static org.apache.datasketches.common.Util.isPowerOf2;
 import static org.apache.datasketches.frequencies.PreambleUtil.EMPTY_FLAG_MASK;
 import static org.apache.datasketches.frequencies.PreambleUtil.SER_VER;
 import static org.apache.datasketches.frequencies.PreambleUtil.extractActiveItems;
@@ -363,7 +363,7 @@ public int getCurrentMapCapacity() {
    * @return epsilon used to compute <i>a priori</i> error.
    */
   public static double getEpsilon(final int maxMapSize) {
-    if (!isIntPowerOf2(maxMapSize)) {
+    if (!isPowerOf2(maxMapSize)) {
       throw new SketchesArgumentException("maxMapSize is not a power of 2.");
     }
     return 3.5 / maxMapSize;
diff --git a/src/main/java/org/apache/datasketches/hash/MurmurHash3Adaptor.java b/src/main/java/org/apache/datasketches/hash/MurmurHash3Adaptor.java
index 083301b47..feecdba97 100644
--- a/src/main/java/org/apache/datasketches/hash/MurmurHash3Adaptor.java
+++ b/src/main/java/org/apache/datasketches/hash/MurmurHash3Adaptor.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.hash;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.hash.MurmurHash3.hash;
 
 import java.nio.ByteBuffer;
@@ -368,7 +368,7 @@ private static int asInteger(final long[] data, final int n) {
       throw new SketchesStateException(
           "Internal Error: Failed to find integer &lt; n within 10000 iterations.");
     }
-    final long mask = ceilingIntPowerOf2(n) - 1;
+    final long mask = ceilingPowerOf2(n) - 1;
     while (++cnt < 10000) {
       final long[] h = MurmurHash3.hash(data, seed);
       t = (int) (h[0] & mask);
diff --git a/src/main/java/org/apache/datasketches/hll/PreambleUtil.java b/src/main/java/org/apache/datasketches/hll/PreambleUtil.java
index 66334da3c..dfa1bfcb6 100644
--- a/src/main/java/org/apache/datasketches/hll/PreambleUtil.java
+++ b/src/main/java/org/apache/datasketches/hll/PreambleUtil.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.hll;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.exactLog2OfLong;
 import static org.apache.datasketches.common.Util.zeroPad;
 import static org.apache.datasketches.hll.HllUtil.LG_AUX_ARR_INTS;
@@ -460,7 +460,7 @@ static int computeLgArr(final Memory mem, final int count, final int lgConfigK)
     //value is missing, recompute
     final CurMode curMode = extractCurMode(mem);
     if (curMode == CurMode.LIST) { return HllUtil.LG_INIT_LIST_SIZE; }
-    int ceilPwr2 = ceilingIntPowerOf2(count);
+    int ceilPwr2 = ceilingPowerOf2(count);
     if ((RESIZE_DENOM * count) > (RESIZE_NUMER * ceilPwr2)) { ceilPwr2 <<= 1; }
     if (curMode == CurMode.SET) {
       return Math.max(LG_INIT_SET_SIZE, exactLog2OfLong(ceilPwr2));
diff --git a/src/main/java/org/apache/datasketches/hllmap/CouponHashMap.java b/src/main/java/org/apache/datasketches/hllmap/CouponHashMap.java
index 26e23e649..ecacc4d19 100644
--- a/src/main/java/org/apache/datasketches/hllmap/CouponHashMap.java
+++ b/src/main/java/org/apache/datasketches/hllmap/CouponHashMap.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.hllmap;
 
-import static org.apache.datasketches.common.Util.checkIfIntPowerOf2;
+import static org.apache.datasketches.common.Util.checkIfPowerOf2;
 import static org.apache.datasketches.common.Util.invPow2;
 
 import java.util.Arrays;
@@ -266,7 +266,7 @@ int getCapacityCouponsPerEntry() {
   }
 
   private static final void checkMaxCouponsPerKey(final int maxCouponsPerKey) {
-    checkIfIntPowerOf2(maxCouponsPerKey, "maxCouponsPerKey");
+    checkIfPowerOf2(maxCouponsPerKey, "maxCouponsPerKey");
     final int cpk = maxCouponsPerKey;
     if ((cpk < 16) || (cpk > 256)) {
       throw new SketchesArgumentException(
diff --git a/src/main/java/org/apache/datasketches/quantiles/ClassicUtil.java b/src/main/java/org/apache/datasketches/quantiles/ClassicUtil.java
index ebd431a0b..44c3179b7 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ClassicUtil.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ClassicUtil.java
@@ -27,8 +27,8 @@
 import static java.lang.Math.min;
 import static java.lang.Math.pow;
 import static java.lang.Math.round;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
-import static org.apache.datasketches.common.Util.isIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
+import static org.apache.datasketches.common.Util.isPowerOf2;
 import static org.apache.datasketches.quantiles.PreambleUtil.COMPACT_FLAG_MASK;
 import static org.apache.datasketches.quantiles.PreambleUtil.EMPTY_FLAG_MASK;
 import static org.apache.datasketches.quantiles.PreambleUtil.ORDERED_FLAG_MASK;
@@ -104,7 +104,7 @@ public static int getKFromEpsilon(final double epsilon, final boolean pmf) {
    * @param k must be greater than 1 and less than 65536 and a power of 2.
    */
   static void checkK(final int k) {
-    if ((k < MIN_K) || (k > MAX_K) || !isIntPowerOf2(k)) {
+    if ((k < MIN_K) || (k > MAX_K) || !isPowerOf2(k)) {
       throw new SketchesArgumentException(
           "K must be >= " + MIN_K + " and <= " + MAX_K + " and a power of 2: " + k);
     }
@@ -210,7 +210,7 @@ static int computeCombinedBufferItemCapacity(final int k, final long n) {
     final int totLevels = computeNumLevelsNeeded(k, n);
     if (totLevels == 0) {
       final int bbItems = computeBaseBufferItems(k, n);
-      return Math.max(2 * MIN_K, ceilingIntPowerOf2(bbItems));
+      return Math.max(2 * MIN_K, ceilingPowerOf2(bbItems));
     }
     return (2 + totLevels) * k;
   }
diff --git a/src/main/java/org/apache/datasketches/quantiles/DoublesMergeImpl.java b/src/main/java/org/apache/datasketches/quantiles/DoublesMergeImpl.java
index 9e207fc0b..cc8f427c0 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DoublesMergeImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DoublesMergeImpl.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.quantiles;
 
-import static org.apache.datasketches.common.Util.checkIfIntPowerOf2;
+import static org.apache.datasketches.common.Util.checkIfPowerOf2;
 import static org.apache.datasketches.quantiles.PreambleUtil.EMPTY_FLAG_MASK;
 import static org.apache.datasketches.quantiles.PreambleUtil.FLAGS_BYTE;
 
@@ -151,7 +151,7 @@ static void downSamplingMergeInto(final DoublesSketch src, final UpdateDoublesSk
     }
 
     final int downFactor = sourceK / targetK;
-    checkIfIntPowerOf2(downFactor, "source.getK()/target.getK() ratio");
+    checkIfPowerOf2(downFactor, "source.getK()/target.getK() ratio");
     final int lgDownFactor = Integer.numberOfTrailingZeros(downFactor);
 
     if (src.isEmpty()) { return; }
diff --git a/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java b/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
index bbcdf44f7..dc583fb7d 100644
--- a/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
+++ b/src/main/java/org/apache/datasketches/quantiles/DoublesSketch.java
@@ -21,7 +21,7 @@
 
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.quantiles.ClassicUtil.MAX_PRELONGS;
 import static org.apache.datasketches.quantiles.ClassicUtil.MIN_K;
 import static org.apache.datasketches.quantiles.ClassicUtil.checkIsCompactMemory;
@@ -456,7 +456,7 @@ public static int getUpdatableStorageBytes(final int k, final long n) {
     final int metaPre = MAX_PRELONGS + 2; //plus min, max
     final int totLevels = computeNumLevelsNeeded(k, n);
     if (n <= k) {
-      final int ceil = Math.max(ceilingIntPowerOf2((int)n), MIN_K * 2);
+      final int ceil = Math.max(ceilingPowerOf2((int)n), MIN_K * 2);
       return metaPre + ceil << 3;
     }
     return metaPre + (2 + totLevels) * k << 3;
diff --git a/src/main/java/org/apache/datasketches/quantiles/ItemsMergeImpl.java b/src/main/java/org/apache/datasketches/quantiles/ItemsMergeImpl.java
index c6af57d2e..2c1566988 100644
--- a/src/main/java/org/apache/datasketches/quantiles/ItemsMergeImpl.java
+++ b/src/main/java/org/apache/datasketches/quantiles/ItemsMergeImpl.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.quantiles;
 
 import static java.lang.System.arraycopy;
-import static org.apache.datasketches.common.Util.checkIfIntPowerOf2;
+import static org.apache.datasketches.common.Util.checkIfPowerOf2;
 
 import java.util.Arrays;
 import java.util.Comparator;
@@ -144,7 +144,7 @@ static <T> void downSamplingMergeInto(final ItemsSketch<T> src, final ItemsSketc
     }
 
     final int downFactor = sourceK / targetK;
-    checkIfIntPowerOf2(downFactor, "source.getK()/target.getK() ratio");
+    checkIfPowerOf2(downFactor, "source.getK()/target.getK() ratio");
     final int lgDownFactor = Integer.numberOfTrailingZeros(downFactor);
 
     final Object[] sourceLevels     = src.getCombinedBuffer(); // aliasing is a bit dangerous
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
index dc21d5ef7..7b4855d81 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirItemsSketch.java
@@ -91,7 +91,7 @@ private ReservoirItemsSketch(final int k, final ResizeFactor rf) {
 
     itemsSeen_ = 0;
 
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(reservoirSize_), "reservoirSize_");
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(reservoirSize_), "reservoirSize_");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);
 
@@ -249,8 +249,8 @@ public static <T> ReservoirItemsSketch<T> heapify(final Memory srcMem,
     if (itemsSeen < k) {
       // under-full so determine size to allocate, using ceilingLog2(totalSeen) as minimum
       // casts to int are safe since under-full
-      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(k), "heapify");
-      final int minLgSize = Util.exactLog2OfInt(Util.ceilingIntPowerOf2((int) itemsSeen), "heapify");
+      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(k), "heapify");
+      final int minLgSize = Util.exactLog2OfInt(Util.ceilingPowerOf2((int) itemsSeen), "heapify");
       final int initialLgSize = SamplingUtil.startingSubMultiple(ceilingLgK, rf.lg(),
               Math.max(minLgSize, MIN_LG_ARR_ITEMS));
 
@@ -334,7 +334,7 @@ public void update(final T item) {
    * Resets this sketch to the empty state, but retains the original value of k.
    */
   public void reset() {
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(reservoirSize_), "ReservoirItemsSketch");
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(reservoirSize_), "ReservoirItemsSketch");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);
 
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
index acdfd303e..55d7463e0 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirLongsSketch.java
@@ -92,7 +92,7 @@ private ReservoirLongsSketch(final int k, final ResizeFactor rf) {
 
     itemsSeen_ = 0;
 
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(reservoirSize_), "ReservoirLongsSketch");
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(reservoirSize_), "ReservoirLongsSketch");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_LONGS);
 
@@ -229,8 +229,8 @@ public static ReservoirLongsSketch heapify(final Memory srcMem) {
     if (itemsSeen < k) {
       // under-full so determine size to allocate, using ceilingLog2(totalSeen) as minimum
       // casts to int are safe since under-full
-      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(k), "k");
-      final int minLgSize = Util.exactLog2OfInt(Util.ceilingIntPowerOf2((int) itemsSeen), "heapify");
+      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(k), "k");
+      final int minLgSize = Util.exactLog2OfInt(Util.ceilingPowerOf2((int) itemsSeen), "heapify");
       final int initialLgSize = SamplingUtil.startingSubMultiple(ceilingLgK, rf.lg(),
               Math.max(minLgSize, MIN_LG_ARR_LONGS));
 
@@ -334,7 +334,7 @@ public void update(final long item) {
    * Resets this sketch to the empty state, but retains the original value of k.
    */
   public void reset() {
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(reservoirSize_),
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(reservoirSize_),
             "ReservoirLongsSketch");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_LONGS);
diff --git a/src/main/java/org/apache/datasketches/sampling/ReservoirSize.java b/src/main/java/org/apache/datasketches/sampling/ReservoirSize.java
index 5b54e97d7..e6f361955 100644
--- a/src/main/java/org/apache/datasketches/sampling/ReservoirSize.java
+++ b/src/main/java/org/apache/datasketches/sampling/ReservoirSize.java
@@ -79,7 +79,7 @@ public static short computeSize(final int k) {
     final int p = Util.exactLog2OfInt(Util.floorPowerOf2(k), "computeSize: p");
 
     // because of floor() + 1 below, need to check power of 2 here
-    if (Util.isIntPowerOf2(k)) {
+    if (Util.isPowerOf2(k)) {
       return (short) (((p & EXPONENT_MASK) << EXPONENT_SHIFT) & OUTPUT_MASK);
     }
 
diff --git a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
index e43ff6907..b2b106bc3 100644
--- a/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
+++ b/src/main/java/org/apache/datasketches/sampling/VarOptItemsSketch.java
@@ -136,7 +136,7 @@ private VarOptItemsSketch(final int k, final ResizeFactor rf) {
     totalWtR_ = 0;
     numMarksInH_ = 0;
 
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(k_), "VarOptItemsSketch");
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(k_), "VarOptItemsSketch");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);
 
@@ -347,8 +347,8 @@ public static <T> VarOptItemsSketch<T> heapify(final Memory srcMem,
 
     if (rCount == 0) {
       // Not in sampling mode, so determine size to allocate, using ceilingLog2(hCount) as minimum
-      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(k), "heapify");
-      final int minLgSize = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(hCount), "heapify");
+      final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(k), "heapify");
+      final int minLgSize = Util.exactLog2OfInt(Util.ceilingPowerOf2(hCount), "heapify");
       final int initialLgSize = SamplingUtil.startingSubMultiple(ceilingLgK, rf.lg(),
               Math.max(minLgSize, MIN_LG_ARR_ITEMS));
 
@@ -474,7 +474,7 @@ public void update(final T item, final double weight) {
    * Resets this sketch to the empty state, but retains the original value of k.
    */
   public void reset() {
-    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingIntPowerOf2(k_), "VarOptItemsSketch");
+    final int ceilingLgK = Util.exactLog2OfInt(Util.ceilingPowerOf2(k_), "VarOptItemsSketch");
     final int initialLgSize =
             SamplingUtil.startingSubMultiple(ceilingLgK, rf_.lg(), MIN_LG_ARR_ITEMS);
 
diff --git a/src/main/java/org/apache/datasketches/theta/JaccardSimilarity.java b/src/main/java/org/apache/datasketches/theta/JaccardSimilarity.java
index 92f347bc2..1f9e710c0 100644
--- a/src/main/java/org/apache/datasketches/theta/JaccardSimilarity.java
+++ b/src/main/java/org/apache/datasketches/theta/JaccardSimilarity.java
@@ -21,7 +21,7 @@
 
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInThetaSketchedSets.getEstimateOfBoverA;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInThetaSketchedSets.getLowerBoundForBoverA;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInThetaSketchedSets.getUpperBoundForBoverA;
@@ -65,7 +65,7 @@ public static double[] jaccard(final Sketch sketchA, final Sketch sketchB) {
     //Create the Union
     final int minK = 1 << ThetaUtil.MIN_LG_NOM_LONGS;
     final int maxK = 1 << ThetaUtil.MAX_LG_NOM_LONGS;
-    final int newK = max(min(ceilingIntPowerOf2(countA + countB), maxK), minK);
+    final int newK = max(min(ceilingPowerOf2(countA + countB), maxK), minK);
     final Union union =
         SetOperation.builder().setNominalEntries(newK).buildUnion();
     union.union(sketchA);
@@ -115,7 +115,7 @@ public static boolean exactlyEqual(final Sketch sketchA, final Sketch sketchB) {
 
     //Create the Union
     final Union union =
-        SetOperation.builder().setNominalEntries(ceilingIntPowerOf2(countA + countB)).buildUnion();
+        SetOperation.builder().setNominalEntries(ceilingPowerOf2(countA + countB)).buildUnion();
     union.union(sketchA);
     union.union(sketchB);
     final Sketch unionAB = union.getResult();
diff --git a/src/main/java/org/apache/datasketches/theta/SetOperation.java b/src/main/java/org/apache/datasketches/theta/SetOperation.java
index cc952ed48..4d8ebf0c4 100644
--- a/src/main/java/org/apache/datasketches/theta/SetOperation.java
+++ b/src/main/java/org/apache/datasketches/theta/SetOperation.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.theta;
 
 import static org.apache.datasketches.common.Family.idToFamily;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.theta.PreambleUtil.FAMILY_BYTE;
 import static org.apache.datasketches.theta.PreambleUtil.SER_VER_BYTE;
 
@@ -203,7 +203,7 @@ public static SetOperation wrap(final WritableMemory srcMem, final long expected
    * @return the maximum required storage bytes given a nomEntries parameter
    */
   public static int getMaxUnionBytes(final int nomEntries) {
-    final int nomEnt = ceilingIntPowerOf2(nomEntries);
+    final int nomEnt = ceilingPowerOf2(nomEntries);
     return (nomEnt << 4) + (Family.UNION.getMaxPreLongs() << 3);
   }
 
@@ -215,7 +215,7 @@ public static int getMaxUnionBytes(final int nomEntries) {
    * @return the maximum required storage bytes given a nomEntries parameter
    */
   public static int getMaxIntersectionBytes(final int nomEntries) {
-    final int nomEnt = ceilingIntPowerOf2(nomEntries);
+    final int nomEnt = ceilingPowerOf2(nomEntries);
     final int bytes = (nomEnt << 4) + (Family.INTERSECTION.getMaxPreLongs() << 3);
     return bytes;
   }
@@ -227,7 +227,7 @@ public static int getMaxIntersectionBytes(final int nomEntries) {
    * @return the maximum number of bytes.
    */
   public static int getMaxAnotBResultBytes(final int nomEntries) {
-    final int ceil = ceilingIntPowerOf2(nomEntries);
+    final int ceil = ceilingPowerOf2(nomEntries);
     return 24 + (15 * ceil);
   }
 
diff --git a/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java b/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
index 09384a025..d788418dc 100644
--- a/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
+++ b/src/main/java/org/apache/datasketches/theta/SetOperationBuilder.java
@@ -21,7 +21,7 @@
 
 import static org.apache.datasketches.common.Util.LS;
 import static org.apache.datasketches.common.Util.TAB;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 
 import org.apache.datasketches.common.Family;
 import org.apache.datasketches.common.ResizeFactor;
@@ -71,7 +71,7 @@ public SetOperationBuilder() {
    * @return this SetOperationBuilder
    */
   public SetOperationBuilder setNominalEntries(final int nomEntries) {
-    bLgNomLongs = Integer.numberOfTrailingZeros(ceilingIntPowerOf2(nomEntries));
+    bLgNomLongs = Integer.numberOfTrailingZeros(ceilingPowerOf2(nomEntries));
     if ((bLgNomLongs > ThetaUtil.MAX_LG_NOM_LONGS) || (bLgNomLongs < ThetaUtil.MIN_LG_NOM_LONGS)) {
       throw new SketchesArgumentException("Nominal Entries must be >= 16 and <= 67108864: "
         + nomEntries);
diff --git a/src/main/java/org/apache/datasketches/theta/Sketch.java b/src/main/java/org/apache/datasketches/theta/Sketch.java
index b780a9aeb..888116512 100644
--- a/src/main/java/org/apache/datasketches/theta/Sketch.java
+++ b/src/main/java/org/apache/datasketches/theta/Sketch.java
@@ -22,7 +22,7 @@
 import static org.apache.datasketches.common.Family.idToFamily;
 import static org.apache.datasketches.common.Util.LONG_MAX_VALUE_AS_DOUBLE;
 import static org.apache.datasketches.common.Util.LS;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.zeroPad;
 import static org.apache.datasketches.theta.PreambleUtil.COMPACT_FLAG_MASK;
 import static org.apache.datasketches.theta.PreambleUtil.FAMILY_BYTE;
@@ -196,7 +196,7 @@ public static Sketch wrap(final Memory srcMem, final long expectedSeed) {
    * Converts this sketch to a ordered CompactSketch.
    *
    * <p>If <i>this.isCompact() == true</i> this method returns <i>this</i>,
-   * otherwise, this method is equivalent to 
+   * otherwise, this method is equivalent to
    * {@link #compact(boolean, WritableMemory) compact(true, null)}.
    *
    * <p>A CompactSketch is always immutable.</p>
@@ -220,14 +220,14 @@ public CompactSketch compact() {
    * then <i>rebuild()</i> should be called on the <i>UpdateSketch</i> prior to calling this method.</p>
    *
    * <p>A <i>CompactSketch</i> is always immutable.</p>
-   * 
+   *
    * <p>A new <i>CompactSketch</i> object is created:</p>
    * <ul><li>if <i>dstMem != null</i></li>
    * <li>if <i>dstMem == null</i> and <i>this.hasMemory() == true</i></li>
    * <li>if <i>dstMem == null</i> and <i>this</i> has more than 1 item and <i>this.isOrdered() == false</i>
    * and <i>dstOrdered == true</i>.</li>
    *</ul>
-   * 
+   *
    * <p>Otherwise, this operation returns <i>this</i>.</p>
    *
    * @param dstOrdered assumed true if this sketch is empty or has only one value
@@ -313,7 +313,7 @@ public static int getMaxCompactSketchBytes(final int numberOfEntries) {
    * nomEntries
    */
   public static int getMaxUpdateSketchBytes(final int nomEntries) {
-    final int nomEnt = ceilingIntPowerOf2(nomEntries);
+    final int nomEnt = ceilingPowerOf2(nomEntries);
     return (nomEnt << 4) + (Family.QUICKSELECT.getMaxPreLongs() << 3);
   }
 
diff --git a/src/main/java/org/apache/datasketches/theta/UpdateSketchBuilder.java b/src/main/java/org/apache/datasketches/theta/UpdateSketchBuilder.java
index 2f6080916..eec91e881 100644
--- a/src/main/java/org/apache/datasketches/theta/UpdateSketchBuilder.java
+++ b/src/main/java/org/apache/datasketches/theta/UpdateSketchBuilder.java
@@ -21,7 +21,7 @@
 
 import static org.apache.datasketches.common.Util.LS;
 import static org.apache.datasketches.common.Util.TAB;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 
 import org.apache.datasketches.common.Family;
 import org.apache.datasketches.common.ResizeFactor;
@@ -139,7 +139,7 @@ public int getLgNominalEntries() {
    * @return this UpdateSketchBuilder
    */
   public UpdateSketchBuilder setLocalNominalEntries(final int nomEntries) {
-    bLocalLgNomLongs = Integer.numberOfTrailingZeros(ceilingIntPowerOf2(nomEntries));
+    bLocalLgNomLongs = Integer.numberOfTrailingZeros(ceilingPowerOf2(nomEntries));
     if ((bLocalLgNomLongs > ThetaUtil.MAX_LG_NOM_LONGS) || (bLocalLgNomLongs < ThetaUtil.MIN_LG_NOM_LONGS)) {
       throw new SketchesArgumentException(
           "Nominal Entries must be >= 16 and <= 67108864: " + nomEntries);
diff --git a/src/main/java/org/apache/datasketches/thetacommon/HashOperations.java b/src/main/java/org/apache/datasketches/thetacommon/HashOperations.java
index c4fad61ca..848bb47ed 100644
--- a/src/main/java/org/apache/datasketches/thetacommon/HashOperations.java
+++ b/src/main/java/org/apache/datasketches/thetacommon/HashOperations.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.thetacommon;
 
 import static java.lang.Math.max;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 
 import org.apache.datasketches.common.SketchesArgumentException;
 import org.apache.datasketches.common.SketchesStateException;
@@ -351,7 +351,7 @@ public static long[] convertToHashTable(
    */
   public static int minLgHashTableSize(final int count, final double rebuild_threshold) {
     final int upperCount = (int) Math.ceil(count / rebuild_threshold);
-    final int arrLongs = max(ceilingIntPowerOf2(upperCount), 1 << ThetaUtil.MIN_LG_ARR_LONGS);
+    final int arrLongs = max(ceilingPowerOf2(upperCount), 1 << ThetaUtil.MIN_LG_ARR_LONGS);
     final int newLgArrLongs = Integer.numberOfTrailingZeros(arrLongs);
     return newLgArrLongs;
   }
diff --git a/src/main/java/org/apache/datasketches/thetacommon/ThetaUtil.java b/src/main/java/org/apache/datasketches/thetacommon/ThetaUtil.java
index 23fa17129..be209ece1 100644
--- a/src/main/java/org/apache/datasketches/thetacommon/ThetaUtil.java
+++ b/src/main/java/org/apache/datasketches/thetacommon/ThetaUtil.java
@@ -140,7 +140,7 @@ public static int startingSubMultiple(final int lgTarget, final int lgRF,
    * @return The Log2 of the ceiling power of 2 of the given nomLongs.
    */
   public static int checkNomLongs(final int nomLongs) {
-    final int lgNomLongs = Integer.numberOfTrailingZeros(Util.ceilingIntPowerOf2(nomLongs));
+    final int lgNomLongs = Integer.numberOfTrailingZeros(Util.ceilingPowerOf2(nomLongs));
     if (lgNomLongs > MAX_LG_NOM_LONGS || lgNomLongs < MIN_LG_NOM_LONGS) {
       throw new SketchesArgumentException("Nominal Entries must be >= 16 and <= 67108864: "
         + nomLongs);
diff --git a/src/main/java/org/apache/datasketches/tuple/HashTables.java b/src/main/java/org/apache/datasketches/tuple/HashTables.java
index eb672c9eb..bd42f4980 100644
--- a/src/main/java/org/apache/datasketches/tuple/HashTables.java
+++ b/src/main/java/org/apache/datasketches/tuple/HashTables.java
@@ -22,7 +22,7 @@
 import static java.lang.Math.ceil;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.thetacommon.HashOperations.hashInsertOnly;
 import static org.apache.datasketches.thetacommon.HashOperations.hashSearch;
 
@@ -162,7 +162,7 @@ void clear() {
   }
 
   static int getLgTableSize(final int count) {
-    final int tableSize = max(ceilingIntPowerOf2((int) ceil(count / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
+    final int tableSize = max(ceilingPowerOf2((int) ceil(count / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
     return Integer.numberOfTrailingZeros(tableSize);
   }
 
diff --git a/src/main/java/org/apache/datasketches/tuple/Intersection.java b/src/main/java/org/apache/datasketches/tuple/Intersection.java
index c9443acc5..b6f53249a 100644
--- a/src/main/java/org/apache/datasketches/tuple/Intersection.java
+++ b/src/main/java/org/apache/datasketches/tuple/Intersection.java
@@ -22,7 +22,7 @@
 import static java.lang.Math.ceil;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 
 import org.apache.datasketches.common.SketchesArgumentException;
 import org.apache.datasketches.common.SketchesStateException;
@@ -247,7 +247,7 @@ private void resetToEmpty() {
   }
 
   static int getLgTableSize(final int count) {
-    final int tableSize = max(ceilingIntPowerOf2((int) ceil(count / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
+    final int tableSize = max(ceilingPowerOf2((int) ceil(count / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
     return Integer.numberOfTrailingZeros(tableSize);
   }
 
diff --git a/src/main/java/org/apache/datasketches/tuple/JaccardSimilarity.java b/src/main/java/org/apache/datasketches/tuple/JaccardSimilarity.java
index 561773a8a..73c6c7fe0 100644
--- a/src/main/java/org/apache/datasketches/tuple/JaccardSimilarity.java
+++ b/src/main/java/org/apache/datasketches/tuple/JaccardSimilarity.java
@@ -21,7 +21,7 @@
 
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInTupleSketchedSets.getEstimateOfBoverA;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInTupleSketchedSets.getLowerBoundForBoverA;
 import static org.apache.datasketches.thetacommon.BoundsOnRatiosInTupleSketchedSets.getUpperBoundForBoverA;
@@ -74,7 +74,7 @@ public static <S extends Summary> double[] jaccard(
     //Create the Union
     final int minK = 1 << ThetaUtil.MIN_LG_NOM_LONGS;
     final int maxK = 1 << ThetaUtil.MAX_LG_NOM_LONGS;
-    final int newK = max(min(ceilingIntPowerOf2(countA + countB), maxK), minK);
+    final int newK = max(min(ceilingPowerOf2(countA + countB), maxK), minK);
     final Union<S> union = new Union<>(newK, summarySetOps);
     union.union(sketchA);
     union.union(sketchB);
@@ -142,7 +142,7 @@ public static <S extends Summary> double[] jaccard(
     //Create the Union
     final int minK = 1 << ThetaUtil.MIN_LG_NOM_LONGS;
     final int maxK = 1 << ThetaUtil.MAX_LG_NOM_LONGS;
-    final int newK = max(min(ceilingIntPowerOf2(countA + countB), maxK), minK);
+    final int newK = max(min(ceilingPowerOf2(countA + countB), maxK), minK);
     final Union<S> union = new Union<>(newK, summarySetOps);
     union.union(sketchA);
     union.union(sketchB, summary);
@@ -196,7 +196,7 @@ public static <S extends Summary> boolean exactlyEqual(
     final int countB = sketchB.getRetainedEntries();
 
     //Create the Union
-    final Union<S> union = new Union<>(ceilingIntPowerOf2(countA + countB), summarySetOps);
+    final Union<S> union = new Union<>(ceilingPowerOf2(countA + countB), summarySetOps);
     union.union(sketchA);
     union.union(sketchB);
     final Sketch<S> unionAB = union.getResult();
@@ -242,7 +242,7 @@ public static <S extends Summary> boolean exactlyEqual(
     final int countB = sketchB.getRetainedEntries(true);
 
     //Create the Union
-    final Union<S> union = new Union<>(ceilingIntPowerOf2(countA + countB), summarySetOps);
+    final Union<S> union = new Union<>(ceilingPowerOf2(countA + countB), summarySetOps);
     union.union(sketchA);
     union.union(sketchB, summary);
     final Sketch<S> unionAB = union.getResult();
diff --git a/src/main/java/org/apache/datasketches/tuple/QuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/QuickSelectSketch.java
index 640547bae..d1ac811d2 100644
--- a/src/main/java/org/apache/datasketches/tuple/QuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/QuickSelectSketch.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.tuple;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.checkBounds;
 import static org.apache.datasketches.common.Util.exactLog2OfLong;
 import static org.apache.datasketches.thetacommon.HashOperations.count;
@@ -124,7 +124,7 @@ private enum Flags { IS_BIG_ENDIAN, IS_IN_SAMPLING_MODE, IS_EMPTY, HAS_ENTRIES,
       final float samplingProbability,
       final SummaryFactory<S> summaryFactory,
       final int startingSize) {
-    nomEntries_ = ceilingIntPowerOf2(nomEntries);
+    nomEntries_ = ceilingPowerOf2(nomEntries);
     lgResizeFactor_ = lgResizeFactor;
     samplingProbability_ = samplingProbability;
     summaryFactory_ = summaryFactory; //super
diff --git a/src/main/java/org/apache/datasketches/tuple/Util.java b/src/main/java/org/apache/datasketches/tuple/Util.java
index 349d839af..c4f8ff55f 100644
--- a/src/main/java/org/apache/datasketches/tuple/Util.java
+++ b/src/main/java/org/apache/datasketches/tuple/Util.java
@@ -20,7 +20,7 @@
 package org.apache.datasketches.tuple;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.hash.MurmurHash3.hash;
 import static org.apache.datasketches.memory.XxHash.hashCharArr;
 import static org.apache.datasketches.memory.XxHash.hashString;
@@ -97,7 +97,7 @@ public static final void checkSeedHashes(final short seedHashA, final short seed
   public static int getStartingCapacity(final int nomEntries, final int lgResizeFactor) {
     return 1 << ThetaUtil.startingSubMultiple(
       // target table size is twice the number of nominal entries
-      Integer.numberOfTrailingZeros(ceilingIntPowerOf2(nomEntries) * 2),
+      Integer.numberOfTrailingZeros(ceilingPowerOf2(nomEntries) * 2),
       lgResizeFactor,
       ThetaUtil.MIN_LG_ARR_LONGS
     );
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketch.java
index c4a896a25..a6c536816 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/ArrayOfDoublesQuickSelectSketch.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.tuple.arrayofdoubles;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 
 import org.apache.datasketches.common.SketchesArgumentException;
 import org.apache.datasketches.memory.WritableMemory;
@@ -115,7 +115,7 @@ public int getCurrentBytes() {
    */
   static int getMaxBytes(final int nomEntries, final int numValues) {
     return ENTRIES_START
-        + (SIZE_OF_KEY_BYTES + SIZE_OF_VALUE_BYTES * numValues) * ceilingIntPowerOf2(nomEntries) * 2;
+        + (SIZE_OF_KEY_BYTES + SIZE_OF_VALUE_BYTES * numValues) * ceilingPowerOf2(nomEntries) * 2;
   }
 
   // non-public methods below
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HashTables.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HashTables.java
index 004c3bdf0..0b93316b3 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HashTables.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HashTables.java
@@ -22,7 +22,7 @@
 import static java.lang.Math.ceil;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.thetacommon.HashOperations.hashInsertOnly;
 import static org.apache.datasketches.thetacommon.HashOperations.hashSearch;
 
@@ -123,7 +123,7 @@ void clear() {
   }
 
   static int getLgTableSize(final int numKeys) {
-    final int tableSize = max(ceilingIntPowerOf2((int) ceil(numKeys / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
+    final int tableSize = max(ceilingPowerOf2((int) ceil(numKeys / 0.75)), 1 << ThetaUtil.MIN_LG_NOM_LONGS);
     return Integer.numberOfTrailingZeros(tableSize);
   }
 
diff --git a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
index 3a788118f..9409a5828 100644
--- a/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
+++ b/src/main/java/org/apache/datasketches/tuple/arrayofdoubles/HeapArrayOfDoublesQuickSelectSketch.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.tuple.arrayofdoubles;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.exactLog2OfLong;
 
 import java.nio.ByteOrder;
@@ -66,7 +66,7 @@ final class HeapArrayOfDoublesQuickSelectSketch extends ArrayOfDoublesQuickSelec
   HeapArrayOfDoublesQuickSelectSketch(final int nomEntries, final int lgResizeFactor,
       final float samplingProbability, final int numValues, final long seed) {
     super(numValues, seed);
-    lgNomEntries_ = exactLog2OfLong(ceilingIntPowerOf2(nomEntries));
+    lgNomEntries_ = exactLog2OfLong(ceilingPowerOf2(nomEntries));
     lgResizeFactor_ = lgResizeFactor;
     samplingProbability_ = samplingProbability;
     thetaLong_ = (long) (Long.MAX_VALUE * (double) samplingProbability);
diff --git a/src/test/java/org/apache/datasketches/common/UtilTest.java b/src/test/java/org/apache/datasketches/common/UtilTest.java
index 50112a315..ca83dadd6 100644
--- a/src/test/java/org/apache/datasketches/common/UtilTest.java
+++ b/src/test/java/org/apache/datasketches/common/UtilTest.java
@@ -23,13 +23,11 @@
 import static org.apache.datasketches.common.Util.bytesToInt;
 import static org.apache.datasketches.common.Util.bytesToLong;
 import static org.apache.datasketches.common.Util.bytesToString;
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
-import static org.apache.datasketches.common.Util.ceilingLongPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.common.Util.ceilingPowerBaseOfDouble;
 import static org.apache.datasketches.common.Util.characterPad;
 import static org.apache.datasketches.common.Util.checkBounds;
-import static org.apache.datasketches.common.Util.checkIfIntPowerOf2;
-import static org.apache.datasketches.common.Util.checkIfLongPowerOf2;
+import static org.apache.datasketches.common.Util.checkIfPowerOf2;
 import static org.apache.datasketches.common.Util.checkIfMultipleOf8AndGT0;
 import static org.apache.datasketches.common.Util.checkProbability;
 import static org.apache.datasketches.common.Util.convertToLongArray;
@@ -40,9 +38,8 @@
 import static org.apache.datasketches.common.Util.intToBytes;
 import static org.apache.datasketches.common.Util.invPow2;
 import static org.apache.datasketches.common.Util.isEven;
-import static org.apache.datasketches.common.Util.isIntPowerOf2;
 import static org.apache.datasketches.common.Util.isLessThanUnsigned;
-import static org.apache.datasketches.common.Util.isLongPowerOf2;
+import static org.apache.datasketches.common.Util.isPowerOf2;
 import static org.apache.datasketches.common.Util.isMultipleOf8AndGT0;
 import static org.apache.datasketches.common.Util.isOdd;
 import static org.apache.datasketches.common.Util.longToBytes;
@@ -92,48 +89,23 @@ public void checkBoundsTest() {
   }
 
   @Test
-  public void checkIsIntPowerOf2() {
-    Assert.assertEquals(isIntPowerOf2(0), false);
-    Assert.assertEquals(isIntPowerOf2(1), true);
-    Assert.assertEquals(isIntPowerOf2(2), true);
-    Assert.assertEquals(isIntPowerOf2(4), true);
-    Assert.assertEquals(isIntPowerOf2(8), true);
-    Assert.assertEquals(isIntPowerOf2(1 << 30), true);
-    Assert.assertEquals(isIntPowerOf2(3), false);
-    Assert.assertEquals(isIntPowerOf2(5), false);
-    Assert.assertEquals(isIntPowerOf2( -1), false);
+  public void checkIsPowerOf2() {
+    Assert.assertEquals(isPowerOf2(0), false);
+    Assert.assertEquals(isPowerOf2(1), true);
+    Assert.assertEquals(isPowerOf2(2), true);
+    Assert.assertEquals(isPowerOf2(4), true);
+    Assert.assertEquals(isPowerOf2(8), true);
+    Assert.assertEquals(isPowerOf2(1L << 62), true);
+    Assert.assertEquals(isPowerOf2(3), false);
+    Assert.assertEquals(isPowerOf2(5), false);
+    Assert.assertEquals(isPowerOf2( -1), false);
   }
 
   @Test
-  public void checkIsLongPowerOf2() {
-    Assert.assertEquals(isLongPowerOf2(0), false);
-    Assert.assertEquals(isLongPowerOf2(1), true);
-    Assert.assertEquals(isLongPowerOf2(2), true);
-    Assert.assertEquals(isLongPowerOf2(4), true);
-    Assert.assertEquals(isLongPowerOf2(8), true);
-    Assert.assertEquals(isLongPowerOf2(1L << 62), true);
-    Assert.assertEquals(isLongPowerOf2(3), false);
-    Assert.assertEquals(isLongPowerOf2(5), false);
-    Assert.assertEquals(isLongPowerOf2( -1), false);
-  }
-
-  @Test
-  public void checkCheckIfIntPowerOf2() {
-    checkIfIntPowerOf2(8, "Test 8");
-    try {
-      checkIfIntPowerOf2(7, "Test 7");
-      Assert.fail("Expected SketchesArgumentException");
-    }
-    catch (final SketchesArgumentException e) {
-      //pass
-    }
-  }
-
-  @Test
-  public void checkCheckIfLongPowerOf2() {
-    checkIfLongPowerOf2(8L, "Test 8");
+  public void checkCheckIfPowerOf2() {
+    checkIfPowerOf2(8L, "Test 8");
     try {
-      checkIfLongPowerOf2(7L, "Test 7");
+      checkIfPowerOf2(7L, "Test 7");
       Assert.fail("Expected SketchesArgumentException");
     }
     catch (final SketchesArgumentException e) {
@@ -143,22 +115,22 @@ public void checkCheckIfLongPowerOf2() {
 
   @Test
   public void checkCeilingIntPowerOf2() {
-    Assert.assertEquals(ceilingIntPowerOf2(Integer.MAX_VALUE), 1 << 30);
-    Assert.assertEquals(ceilingIntPowerOf2(1 << 30), 1 << 30);
-    Assert.assertEquals(ceilingIntPowerOf2(64), 64);
-    Assert.assertEquals(ceilingIntPowerOf2(65), 128);
-    Assert.assertEquals(ceilingIntPowerOf2(0), 1);
-    Assert.assertEquals(ceilingIntPowerOf2( -1), 1);
+    Assert.assertEquals(ceilingPowerOf2(Integer.MAX_VALUE), 1 << 30);
+    Assert.assertEquals(ceilingPowerOf2(1 << 30), 1 << 30);
+    Assert.assertEquals(ceilingPowerOf2(64), 64);
+    Assert.assertEquals(ceilingPowerOf2(65), 128);
+    Assert.assertEquals(ceilingPowerOf2(0), 1);
+    Assert.assertEquals(ceilingPowerOf2( -1), 1);
   }
 
   @Test
   public void checkCeilingLongPowerOf2() {
-    Assert.assertEquals(ceilingLongPowerOf2(Long.MAX_VALUE), 1L << 62);
-    Assert.assertEquals(ceilingLongPowerOf2(1L << 62), 1L << 62);
-    Assert.assertEquals(ceilingLongPowerOf2(64), 64);
-    Assert.assertEquals(ceilingLongPowerOf2(65), 128);
-    Assert.assertEquals(ceilingLongPowerOf2(0), 1L);
-    Assert.assertEquals(ceilingLongPowerOf2( -1L), 1L);
+    Assert.assertEquals(ceilingPowerOf2(Long.MAX_VALUE), 1L << 62);
+    Assert.assertEquals(ceilingPowerOf2(1L << 62), 1L << 62);
+    Assert.assertEquals(ceilingPowerOf2(64L), 64L);
+    Assert.assertEquals(ceilingPowerOf2(65L), 128L);
+    Assert.assertEquals(ceilingPowerOf2(0L), 1L);
+    Assert.assertEquals(ceilingPowerOf2( -1L), 1L);
   }
 
 
diff --git a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
index bc003fbee..ad396e9e8 100644
--- a/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
+++ b/src/test/java/org/apache/datasketches/frequencies/LongsSketchTest.java
@@ -464,7 +464,7 @@ public void checkSortItems() {
     int numSketches = 1;
     int n = 2222;
     double error_tolerance = 1.0/100;
-    int sketchSize = Util.ceilingIntPowerOf2((int) (1.0 /(error_tolerance*ReversePurgeLongHashMap.getLoadFactor())));
+    int sketchSize = Util.ceilingPowerOf2((int) (1.0 /(error_tolerance*ReversePurgeLongHashMap.getLoadFactor())));
     //println("sketchSize: "+sketchSize);
 
     LongsSketch[] sketches = new LongsSketch[numSketches];
@@ -608,7 +608,7 @@ static void println(String s) {
 
   private static LongsSketch newFrequencySketch(double eps) {
     double loadFactor = ReversePurgeLongHashMap.getLoadFactor();
-    int maxMapSize = Util.ceilingIntPowerOf2((int) (1.0 /(eps*loadFactor)));
+    int maxMapSize = Util.ceilingPowerOf2((int) (1.0 /(eps*loadFactor)));
     return new LongsSketch(maxMapSize);
   }
 
diff --git a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
index 7166b22c0..34283b2dc 100644
--- a/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
+++ b/src/test/java/org/apache/datasketches/quantiles/DirectUpdateDoublesSketchTest.java
@@ -19,7 +19,7 @@
 
 package org.apache.datasketches.quantiles;
 
-import static org.apache.datasketches.common.Util.ceilingIntPowerOf2;
+import static org.apache.datasketches.common.Util.ceilingPowerOf2;
 import static org.apache.datasketches.quantiles.ClassicUtil.LS;
 import static org.apache.datasketches.quantilescommon.QuantileSearchCriteria.EXCLUSIVE;
 import static org.testng.Assert.assertEquals;
@@ -157,7 +157,7 @@ public void checkMisc() {
     int n2 = (int)qs.getN();
     assertEquals(n2, n);
     combBuf = qs.getCombinedBuffer();
-    assertEquals(combBuf.length, ceilingIntPowerOf2(n)); // since n < k
+    assertEquals(combBuf.length, ceilingPowerOf2(n)); // since n < k
     println(qs.toString(true, true));
     qs.reset();
     assertEquals(qs.getN(), 0);