Forgot to stage the previous commit. All the classes affected by the

name changes for Theta.

Author: leerho

src/main/java/org/apache/datasketches/theta/CompactOperations.java

@@ -60,7 +60,7 @@ final class CompactOperations {
 
   private CompactOperations() {}
 
-  static CompactSketch componentsToCompact( //No error checking
+  static CompactThetaSketch componentsToCompact( //No error checking
       final long thetaLong,
       final int curCount,
       final short seedHash,
@@ -108,15 +108,15 @@ static CompactSketch componentsToCompact( //No error checking
   }
 
   /**
-   * Heapify or convert a source Theta Sketch MemorySegment image into a heap or target MemorySegment CompactSketch.
+   * Heapify or convert a source ThetaSketch MemorySegment image into a heap or target MemorySegment CompactThetaSketch.
    * This assumes hashSeed is OK; serVer = 3.
    * @param srcSeg the given input source MemorySegment image. Can be Read Only.
-   * @param dstOrdered the desired ordering of the resulting CompactSketch
-   * @param dstWSeg Used for the target CompactSketch if it is MemorySegment-based. Must be Writable.
-   * @return a CompactSketch of the correct form.
+   * @param dstOrdered the desired ordering of the resulting CompactThetaSketch
+   * @param dstWSeg Used for the target CompactThetaSketch if it is MemorySegment-based. Must be Writable.
+   * @return a CompactThetaSketch of the correct form.
    */
   @SuppressWarnings("unused")
-  static CompactSketch segmentToCompact(
+  static CompactThetaSketch segmentToCompact(
       final MemorySegment srcSeg,
       final boolean dstOrdered,
       final MemorySegment dstWSeg)
@@ -233,7 +233,7 @@ static MemorySegment loadCompactMemorySegment(
     }
     final byte famID = (byte) Family.COMPACT.getID();
 
-    //It is important to make sure that all byte fields are initialized, even those that are not used by the CompactSketch.
+    //It is important to make sure that all byte fields are initialized, even those that are not used by the CompactThetaSketch.
     // Otherwise, uninitialized fields could could cause other problems downstream.
     // As written below, all fields are initialized.
 
@@ -242,7 +242,7 @@ static MemorySegment loadCompactMemorySegment(
     insertSerVer(dstWSeg, SER_VER);
     insertFamilyID(dstWSeg, famID);
     //The following initializes the lgNomLongs and lgArrLongs to 0.
-    //They are not used in CompactSketches.
+    //They are not used in CompactThetaSketches.
     dstWSeg.set(JAVA_SHORT_UNALIGNED, LG_NOM_LONGS_BYTE, (short)0);
     insertFlags(dstWSeg, flags);
     insertSeedHash(dstWSeg, seedHash);
@@ -305,15 +305,15 @@ static long[] compactCache(final long[] srcCache, final int curCount,
    * Num Theta CurCount Empty State    Name, Comments
    *  0    1.0     0      T     OK     EMPTY: The Normal Empty State
    *  1    1.0     0      F   Internal This can occur internally as the result of an intersection of two exact,
-   *                                   disjoint sets, or AnotB of two exact, identical sets. There is no probability
+   *                                   disjoint sets, or ThetaAnotB of two exact, identical sets. There is no probability
    *                                   distribution, so this is converted internally to EMPTY {1.0, 0, T}.
-   *                                   This is handled in SetOperation.createCompactSketch().
+   *                                   This is handled in ThetaSetOperation.createCompactThetaSketch().
    *  2    1.0    !0      T   Error    Empty=T and curCount !0 should never coexist.
    *                                   This is checked in all compacting operations.
    *  3    1.0    !0      F     OK     EXACT: This corresponds to a sketch in exact mode
-   *  4   <1.0     0      T   Internal This can be an initial UpdateSketch state if p < 1.0,
+   *  4   <1.0     0      T   Internal This can be an initial UpdatableThetaSketch state if p < 1.0,
    *                                   so change theta to 1.0. Return {Th = 1.0, 0, T}.
-   *                                   This is handled in UpdateSketch.compact() and toByteArray().
+   *                                   This is handled in UpdatableThetaSketch.compact() and toByteArray().
    *  5   <1.0     0      F     OK     This can result from set operations
    *  6   <1.0    !0      T   Error    Empty=T and curCount !0 should never coexist.
    *                                   This is checked in all compacting operations.
@@ -324,11 +324,11 @@ static long[] compactCache(final long[] srcCache, final int curCount,
    */
 
   /**
-   * This corrects a temporary anomalous condition where compact() or toByteArray() is called on an UpdateSketch
+   * This corrects a temporary anomalous condition where compact() or toByteArray() is called on an UpdatableThetaSketch
    * that was initialized with p < 1.0 and update() was never called.  In this case Theta < 1.0,
    * curCount = 0, and empty = true.  The correction is to change Theta to 1.0, which makes the
    * returning sketch empty. This should only be used in the compaction or serialization of an
-   * UpdateSketch.
+   * UpdatableThetaSketch.
    * @param empty the given empty state
    * @param curCount the given curCount
    * @param thetaLong the given thetaLong
@@ -355,7 +355,7 @@ static void checkIllegalCurCountAndEmpty(final boolean empty, final int curCount
   /**
    * This compute number of preamble longs for a compact sketch based on <i>empty</i>,
    * <i>curCount</i> and <i>thetaLong</i>.
-   * This also accommodates for EmptyCompactSketch and SingleItemSketch.
+   * This also accommodates for EmptyCompactThetaSketch and SingleItemThetaSketch.
    * @param empty The given empty state
    * @param curCount The given current count (retained entries)
    * @param thetaLong the current thetaLong
@@ -367,7 +367,7 @@ static int computeCompactPreLongs(final boolean empty, final int curCount,
   }
 
   /**
-   * This checks for the singleItem Compact Sketch.
+   * This checks for the singleItem CompactThetaSketch.
    * @param empty the given empty state
    * @param curCount the given curCount
    * @param thetaLong the given thetaLong

src/main/java/org/apache/datasketches/theta/CompactThetaSketch.java

@@ -46,49 +46,49 @@
 import org.apache.datasketches.common.Util;
 
 /**
- * The parent class of all the CompactSketches. CompactSketches are never created directly.
- * They are created as a result of the compact() method of an UpdateSketch, a result of a
- * getResult() of a SetOperation, or from a heapify method.
+ * The parent class of all the CompactThetaSketches. CompactThetaSketches are never created directly.
+ * They are created as a result of the compact() method of an UpdatableThetaSketch, a result of a
+ * getResult() of a ThetaSetOperation, or from a heapify method.
  *
- * <p>A CompactSketch is the simplest form of a Theta Sketch. It consists of a compact list
+ * <p>A CompactThetaSketch is the simplest form of a ThetaSketches. It consists of a compact list
  * (i.e., no intervening spaces) of hash values, which may be ordered or not, a value for theta
- * and a seed hash.  A CompactSketch is immutable (read-only),
+ * and a seed hash.  A CompactThetaSketch is immutable (read-only),
  * and the space required when stored is only the space required for the hash values and 8 to 24
- * bytes of preamble. An empty CompactSketch consumes only 8 bytes.</p>
+ * bytes of preamble. An empty CompactThetaSketch consumes only 8 bytes.</p>
  *
  * @author Lee Rhodes
  */
-public abstract class CompactSketch extends ThetaSketch {
+public abstract class CompactThetaSketch extends ThetaSketch {
 
   /**
-   * Heapify takes a CompactSketch image in a MemorySegment and instantiates an on-heap CompactSketch.
+   * Heapify takes a CompactThetaSketch image in a MemorySegment and instantiates an on-heap CompactThetaSketch.
    *
    * <p>The resulting sketch will not retain any link to the source MemorySegment and all of its data will be
-   * copied to the heap CompactSketch.</p>
+   * copied to the heap CompactThetaSketch.</p>
    *
    * <p>The {@link Util#DEFAULT_UPDATE_SEED DEFAULT_UPDATE_SEED} is assumed.</p>
    *
-   * @param srcSeg an image of a CompactSketch.
-   * @return a CompactSketch on the heap.
+   * @param srcSeg an image of a CompactThetaSketch.
+   * @return a CompactThetaSketch on the heap.
    */
-  public static CompactSketch heapify(final MemorySegment srcSeg) {
+  public static CompactThetaSketch heapify(final MemorySegment srcSeg) {
     return heapify(srcSeg, Util.DEFAULT_UPDATE_SEED);
   }
 
   /**
-   * Heapify takes a CompactSketch image in a MemorySegment and instantiates an on-heap CompactSketch.
+   * Heapify takes a CompactThetaSketch image in a MemorySegment and instantiates an on-heap CompactThetaSketch.
    *
    * <p>The resulting sketch will not retain any link to the source MemorySegment and all of its data will be
-   * copied to the heap CompactSketch.</p>
+   * copied to the heap CompactThetaSketch.</p>
    *
    * <p>This method checks if the given expectedSeed was used to create the source MemorySegment image.</p>
    *
-   * @param srcSeg an image of a CompactSketch that was created using the given expectedSeed.
+   * @param srcSeg an image of a CompactThetaSketch that was created using the given expectedSeed.
    * @param expectedSeed the seed used to validate the given MemorySegment image.
    * <a href="{@docRoot}/resources/dictionary.html#seed">See Update Hash Seed</a>.
-   * @return a CompactSketch on the heap.
+   * @return a CompactThetaSketch on the heap.
    */
-  public static CompactSketch heapify(final MemorySegment srcSeg, final long expectedSeed) {
+  public static CompactThetaSketch heapify(final MemorySegment srcSeg, final long expectedSeed) {
     final int serVer = extractSerVer(srcSeg);
     final int familyID = extractFamilyID(srcSeg);
     final Family family = idToFamily(familyID);
@@ -111,7 +111,7 @@ public static CompactSketch heapify(final MemorySegment srcSeg, final long expec
   }
 
   /**
-   * Wrap takes the CompactSketch image in given MemorySegment and refers to it directly.
+   * Wrap takes the CompactThetaSketch image in given MemorySegment and refers to it directly.
    * There is no data copying onto the java heap.
    * The wrap operation enables fast read-only merging and access to all the public read-only API.
    *
@@ -121,10 +121,10 @@ public static CompactSketch heapify(final MemorySegment srcSeg, final long expec
    *
    * <p>The {@link Util#DEFAULT_UPDATE_SEED DEFAULT_UPDATE_SEED} is assumed.</p>
    *
-   * @param srcSeg an image of a Sketch.
-   * @return a CompactSketch backed by the given MemorySegment.
+   * @param srcSeg an image of a CompactThetaSketch.
+   * @return a CompactThetaSketch backed by the given MemorySegment.
    */
-  public static CompactSketch wrap(final MemorySegment srcSeg) {
+  public static CompactThetaSketch wrap(final MemorySegment srcSeg) {
     return wrap(srcSeg, Util.DEFAULT_UPDATE_SEED);
   }
 
@@ -139,12 +139,12 @@ public static CompactSketch wrap(final MemorySegment srcSeg) {
    *
    * <p>This method checks if the given expectedSeed was used to create the source MemorySegment image.</p>
    *
-   * @param srcSeg an image of a Sketch that was created using the given expectedSeed.
+   * @param srcSeg an image of a CompactThetaSketch that was created using the given expectedSeed.
    * @param expectedSeed the seed used to validate the given MemorySegment image.
    * <a href="{@docRoot}/resources/dictionary.html#seed">See Update Hash Seed</a>.
-   * @return a CompactSketch backed by the given MemorySegment.
+   * @return a CompactThetaketch backed by the given MemorySegment.
    */
-  public static CompactSketch wrap(final MemorySegment srcSeg, final long expectedSeed) {
+  public static CompactThetaSketch wrap(final MemorySegment srcSeg, final long expectedSeed) {
     final int serVer = extractSerVer(srcSeg);
     final int familyID = extractFamilyID(srcSeg);
     final Family family = Family.idToFamily(familyID);
@@ -196,11 +196,11 @@ public static CompactSketch wrap(final MemorySegment srcSeg, final long expected
    *
    * <p>This method checks if the DEFAULT_UPDATE_SEED was used to create the source byte array image.</p>
    *
-   * @param bytes a byte array image of a Sketch that was created using the DEFAULT_UPDATE_SEED.
+   * @param bytes a byte array image of a CompactThetaSketch that was created using the DEFAULT_UPDATE_SEED.
    *
-   * @return a CompactSketch backed by the given byte array except as above.
+   * @return a CompactThetaSketch backed by the given byte array except as above.
    */
-  public static CompactSketch wrap(final byte[] bytes) {
+  public static CompactThetaSketch wrap(final byte[] bytes) {
     return wrap(bytes, Util.DEFAULT_UPDATE_SEED);
   }
 
@@ -217,12 +217,12 @@ public static CompactSketch wrap(final byte[] bytes) {
    *
    * <p>This method checks if the given expectedSeed was used to create the source byte array image.</p>
    *
-   * @param bytes a byte array image of a Sketch that was created using the given expectedSeed.
+   * @param bytes a byte array image of a CompactThetaSketch that was created using the given expectedSeed.
    * @param expectedSeed the seed used to validate the given byte array image.
    * <a href="{@docRoot}/resources/dictionary.html#seed">See Update Hash Seed</a>.
-   * @return a CompactSketch backed by the given byte array except as above.
+   * @return a CompactThetaSketch backed by the given byte array except as above.
    */
-  public static CompactSketch wrap(final byte[] bytes, final long expectedSeed) {
+  public static CompactThetaSketch wrap(final byte[] bytes, final long expectedSeed) {
     final int serVer = bytes[PreambleUtil.SER_VER_BYTE];
     final int familyId = bytes[PreambleUtil.FAMILY_BYTE];
     final Family family = Family.idToFamily(familyId);
@@ -261,10 +261,10 @@ public static CompactSketch wrap(final byte[] bytes, final long expectedSeed) {
           "Corrupted: Serialization Version " + serVer + " not recognized.");
   }
 
-  //Sketch Overrides
+  //ThetaSketch Overrides
 
   @Override
-  public abstract CompactSketch compact(final boolean dstOrdered, final MemorySegment dstSeg);
+  public abstract CompactThetaSketch compact(final boolean dstOrdered, final MemorySegment dstSeg);
 
   @Override
   public int getCompactBytes() {
@@ -385,7 +385,7 @@ private byte[] toByteArrayV4() {
     return bytes;
   }
 
-  private static CompactSketch heapifyV4(final MemorySegment srcSeg, final long seed) {
+  private static CompactThetaSketch heapifyV4(final MemorySegment srcSeg, final long seed) {
     final int preLongs = ThetaSketch.getPreambleLongs(srcSeg);
     final int entryBits = extractEntryBitsV4(srcSeg);
     final int numEntriesBytes = extractNumEntriesBytesV4(srcSeg);

src/main/java/org/apache/datasketches/theta/ConcurrentBackgroundThetaPropagation.java

@@ -39,7 +39,7 @@ final class ConcurrentBackgroundThetaPropagation implements Runnable {
   // local buffer.  Updated when the propagation completes.
   private final AtomicBoolean localPropagationInProgress;
 
-  // Sketch to be propagated to shared sketch. Can be null if only a single hash is propagated
+  // ThetaSketch to be propagated to shared sketch. Can be null if only a single hash is propagated
   private final ThetaSketch sketchIn;
 
   // Hash of the datum to be propagated to shared sketch. Can be ConcurrentSharedThetaSketch.NOT_SINGLE_HASH

src/main/java/org/apache/datasketches/theta/ConcurrentDirectQuickSelectSketch.java

@@ -88,7 +88,7 @@ final class ConcurrentDirectQuickSelectSketch extends DirectQuickSelectSketch
     initBgPropagationService();
   }
 
-  ConcurrentDirectQuickSelectSketch(final UpdateSketch sketch, final long seed,
+  ConcurrentDirectQuickSelectSketch(final UpdatableThetaSketch sketch, final long seed,
       final double maxConcurrencyError, final MemorySegment dstSeg) {
     super(sketch.getLgNomLongs(), seed, 1.0F, //p
         ResizeFactor.X1, //rf,
@@ -109,7 +109,7 @@ final class ConcurrentDirectQuickSelectSketch extends DirectQuickSelectSketch
     updateEstimationSnapshot();
   }
 
-  //Sketch overrides
+  //ThetaSketch overrides
 
   @Override
   public double getEstimate() {
@@ -129,10 +129,10 @@ public byte[] toByteArray() {
     return res;
   }
 
-  //UpdateSketch overrides
+  //UpdatableThetaSketch overrides
 
   @Override
-  public UpdateSketch rebuild() {
+  public UpdatableThetaSketch rebuild() {
     super.rebuild();
     updateEstimationSnapshot();
     return this;

src/main/java/org/apache/datasketches/theta/ConcurrentHeapQuickSelectSketch.java

@@ -27,7 +27,7 @@
 import org.apache.datasketches.common.SuppressFBWarnings;
 
 /**
- * A concurrent shared sketch that is based on HeapQuickSelectSketch.
+ * A concurrent shared sketch that is based on HeapQuickSelectThetaSketch.
  * It reflects all data processed by a single or multiple update threads, and can serve queries at
  * any time.
  * Background propagation threads are used to propagate data from thread local buffers into this
@@ -82,7 +82,7 @@ final class ConcurrentHeapQuickSelectSketch extends HeapQuickSelectSketch
     initBgPropagationService();
   }
 
-  ConcurrentHeapQuickSelectSketch(final UpdateSketch sketch, final long seed,
+  ConcurrentHeapQuickSelectSketch(final UpdatableThetaSketch sketch, final long seed,
       final double maxConcurrencyError) {
     super(sketch.getLgNomLongs(), seed, 1.0F, //p
         ResizeFactor.X1, //rf,
@@ -101,7 +101,7 @@ final class ConcurrentHeapQuickSelectSketch extends HeapQuickSelectSketch
     updateEstimationSnapshot();
   }
 
-  //Sketch overrides
+  //ThetaSketch overrides
 
   @Override
   public double getEstimate() {
@@ -121,10 +121,10 @@ public byte[] toByteArray() {
     return res;
   }
 
-  //UpdateSketch overrides
+  //UpdatableThetaSketch overrides
 
   @Override
-  public UpdateSketch rebuild() {
+  public UpdatableThetaSketch rebuild() {
     super.rebuild();
     updateEstimationSnapshot();
     return this;

src/main/java/org/apache/datasketches/theta/ConcurrentHeapThetaBuffer.java

@@ -42,10 +42,10 @@
  * Propagation is done either synchronously by the updating thread, or asynchronously by a
  * background propagation thread.
  *
- * <p>This is a buffer, not a sketch, and it extends the <i>HeapQuickSelectSketch</i>
+ * <p>This is a buffer, not a sketch, and it extends the <i>HeapQuickSelectThetaSketch</i>
  * in order to leverage some of the sketch machinery to make its work simple. However, if this
  * buffer receives a query, like <i>getEstimate()</i>, the correct answer does not come from the super
- * <i>HeapQuickSelectSketch</i>, which knows nothing about the concurrency relationship to the
+ * <i>HeapQuickSelectThetaSketch</i>, which knows nothing about the concurrency relationship to the
  * shared concurrent sketch, it must come from the shared concurrent sketch. As a result nearly all
  * of the inherited sketch methods are redirected to the shared concurrent sketch.
  *
@@ -111,15 +111,15 @@ private void propagateToSharedSketch() {
     //no inspection StatementWithEmptyBody
     while (localPropagationInProgress.get()) { /* busy wait until previous propagation completed */ }
 
-    final CompactSketch compactSketch = compact(propagateOrderedCompact, null);
+    final CompactThetaSketch compactSketch = compact(propagateOrderedCompact, null);
     localPropagationInProgress.set(true);
     shared.propagate(localPropagationInProgress, compactSketch,
         ConcurrentSharedThetaSketch.NOT_SINGLE_HASH);
     super.reset();
     thetaLong_ = shared.getVolatileTheta();
   }
 
-  //Public Sketch overrides proxies to shared concurrent sketch
+  //Public ThetaSketch overrides proxies to shared ConcurrentThetaSketch
 
   @Override
   public int getCompactBytes() {
@@ -178,7 +178,7 @@ public byte[] toByteArray() {
     throw new UnsupportedOperationException("Local theta buffer need not be serialized");
   }
 
-  //Public UpdateSketch overrides
+  //Public UpdatableThetaSketch overrides
 
   @Override
   public void reset() {
@@ -187,7 +187,7 @@ public void reset() {
     localPropagationInProgress.set(false);
   }
 
-  //Restricted UpdateSketch overrides
+  //Restricted UpdatableThetaSketch overrides
 
   /**
    * Updates buffer with given hash value.