datasketches 0.1.0

data/vendor/datasketches-cpp/hll/include/HllSketchImpl-internal.hpp

@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _HLLSKETCHIMPL_INTERNAL_HPP_
+#define _HLLSKETCHIMPL_INTERNAL_HPP_
+
+#include "HllSketchImpl.hpp"
+#include "HllSketchImplFactory.hpp"
+
+namespace datasketches {
+
+template<typename A>
+HllSketchImpl<A>::HllSketchImpl(const int lgConfigK, const target_hll_type tgtHllType,
+                                const hll_mode mode, const bool startFullSize)
+  : lgConfigK(lgConfigK),
+    tgtHllType(tgtHllType),
+    mode(mode),
+    startFullSize(startFullSize)
+{
+}
+
+template<typename A>
+HllSketchImpl<A>::~HllSketchImpl() {
+}
+
+template<typename A>
+target_hll_type HllSketchImpl<A>::extractTgtHllType(const uint8_t modeByte) {
+  switch ((modeByte >> 2) & 0x3) {
+  case 0:
+    return target_hll_type::HLL_4;
+  case 1:
+    return target_hll_type::HLL_6;
+  case 2:
+    return target_hll_type::HLL_8;
+  default:
+    throw std::invalid_argument("Invalid target HLL type");
+  }
+}
+
+template<typename A>
+hll_mode HllSketchImpl<A>::extractCurMode(const uint8_t modeByte) {
+  switch (modeByte & 0x3) {
+  case 0:
+    return hll_mode::LIST;
+  case 1:
+    return hll_mode::SET;
+  case 2:
+    return hll_mode::HLL;
+  default:
+    throw std::invalid_argument("Invalid current sketch mode");
+  }
+}
+
+template<typename A>
+uint8_t HllSketchImpl<A>::makeFlagsByte(const bool compact) const {
+  uint8_t flags(0);
+  flags |= (isEmpty() ? HllUtil<A>::EMPTY_FLAG_MASK : 0);
+  flags |= (compact ? HllUtil<A>::COMPACT_FLAG_MASK : 0);
+  flags |= (isOutOfOrderFlag() ? HllUtil<A>::OUT_OF_ORDER_FLAG_MASK : 0);
+  flags |= (startFullSize ? HllUtil<A>::FULL_SIZE_FLAG_MASK : 0);
+  return flags;
+}
+
+// lo2bits = curMode, next 2 bits = tgtHllType
+// Dec  Lo4Bits TgtHllType, CurMode
+//   0     0000      HLL_4,    LIST
+//   1     0001      HLL_4,     SET
+//   2     0010      HLL_4,     HLL
+//   4     0100      HLL_6,    LIST
+//   5     0101      HLL_6,     SET
+//   6     0110      HLL_6,     HLL
+//   8     1000      HLL_8,    LIST
+//   9     1001      HLL_8,     SET
+//  10     1010      HLL_8,     HLL
+template<typename A>
+uint8_t HllSketchImpl<A>::makeModeByte() const {
+  uint8_t byte = 0;
+
+  switch (mode) {
+  case LIST:
+    byte = 0;
+    break;
+  case SET:
+    byte = 1;
+    break;
+  case HLL:
+    byte = 2;
+    break;
+  }
+
+  switch (tgtHllType) {
+  case HLL_4:
+    byte |= (0 << 2);  // for completeness
+    break;
+  case HLL_6:
+    byte |= (1 << 2);
+    break;
+  case HLL_8:
+    byte |= (2 << 2); 
+    break;
+  }
+
+  return byte;
+}
+
+template<typename A>
+HllSketchImpl<A>* HllSketchImpl<A>::reset() {
+  return HllSketchImplFactory<A>::reset(this, startFullSize);
+}
+
+template<typename A>
+target_hll_type HllSketchImpl<A>::getTgtHllType() const {
+  return tgtHllType;
+}
+
+template<typename A>
+int HllSketchImpl<A>::getLgConfigK() const {
+  return lgConfigK;
+}
+
+template<typename A>
+hll_mode HllSketchImpl<A>::getCurMode() const {
+  return mode;
+}
+
+template<typename A>
+bool HllSketchImpl<A>::isStartFullSize() const {
+  return startFullSize;
+}
+
+}
+
+#endif // _HLLSKETCHIMPL_INTERNAL_HPP_

data/vendor/datasketches-cpp/hll/include/HllSketchImpl.hpp

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _HLLSKETCHIMPL_HPP_
+#define _HLLSKETCHIMPL_HPP_
+
+#include "HllUtil.hpp"
+#include "hll.hpp" // for TgtHllType
+
+#include <memory>
+
+namespace datasketches {
+
+template<typename A = std::allocator<char>>
+class HllSketchImpl {
+  public:
+    HllSketchImpl(int lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
+    virtual ~HllSketchImpl();
+
+    virtual void serialize(std::ostream& os, bool compact) const = 0;
+    virtual vector_u8<A> serialize(bool compact, unsigned header_size_bytes) const = 0;
+
+    virtual HllSketchImpl* copy() const = 0;
+    virtual HllSketchImpl* copyAs(target_hll_type tgtHllType) const = 0;
+    HllSketchImpl<A>* reset();
+
+    virtual std::function<void(HllSketchImpl<A>*)> get_deleter() const = 0;
+
+    virtual HllSketchImpl* couponUpdate(int coupon) = 0;
+
+    hll_mode getCurMode() const;
+
+    virtual double getEstimate() const = 0;
+    virtual double getCompositeEstimate() const = 0;
+    virtual double getUpperBound(int numStdDev) const = 0;
+    virtual double getLowerBound(int numStdDev) const = 0;
+
+    inline int getLgConfigK() const;
+
+    virtual int getMemDataStart() const = 0;
+
+    virtual int getPreInts() const = 0;
+
+    target_hll_type getTgtHllType() const;
+
+    virtual int getUpdatableSerializationBytes() const = 0;
+    virtual int getCompactSerializationBytes() const = 0;
+
+    virtual bool isCompact() const = 0;
+    virtual bool isEmpty() const = 0;
+    virtual bool isOutOfOrderFlag() const = 0;
+    virtual void putOutOfOrderFlag(bool oooFlag) = 0;
+    bool isStartFullSize() const;
+
+  protected:
+    static target_hll_type extractTgtHllType(uint8_t modeByte);
+    static hll_mode extractCurMode(uint8_t modeByte);
+    uint8_t makeFlagsByte(bool compact) const;
+    uint8_t makeModeByte() const;
+
+    const int lgConfigK;
+    const target_hll_type tgtHllType;
+    const hll_mode mode;
+    const bool startFullSize;
+};
+
+}
+
+#endif // _HLLSKETCHIMPL_HPP_

data/vendor/datasketches-cpp/hll/include/HllSketchImplFactory.hpp

@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _HLLSKETCHIMPLFACTORY_HPP_
+#define _HLLSKETCHIMPLFACTORY_HPP_
+
+#include "HllUtil.hpp"
+#include "HllSketchImpl.hpp"
+#include "CouponList.hpp"
+#include "CouponHashSet.hpp"
+#include "HllArray.hpp"
+#include "Hll4Array.hpp"
+#include "Hll6Array.hpp"
+#include "Hll8Array.hpp"
+
+namespace datasketches {
+
+template<typename A = std::allocator<char>>
+class HllSketchImplFactory final {
+public:
+  static HllSketchImpl<A>* deserialize(std::istream& os);
+  static HllSketchImpl<A>* deserialize(const void* bytes, size_t len);
+
+  static CouponHashSet<A>* promoteListToSet(const CouponList<A>& list);
+  static HllArray<A>* promoteListOrSetToHll(const CouponList<A>& list);
+  static HllArray<A>* newHll(int lgConfigK, target_hll_type tgtHllType, bool startFullSize = false);
+  
+  // resets the input impl, deleting the input pointer and returning a new pointer
+  static HllSketchImpl<A>* reset(HllSketchImpl<A>* impl, bool startFullSize);
+
+  static Hll4Array<A>* convertToHll4(const HllArray<A>& srcHllArr);
+  static Hll6Array<A>* convertToHll6(const HllArray<A>& srcHllArr);
+  static Hll8Array<A>* convertToHll8(const HllArray<A>& srcHllArr);
+};
+
+template<typename A>
+CouponHashSet<A>* HllSketchImplFactory<A>::promoteListToSet(const CouponList<A>& list) {
+  typedef typename std::allocator_traits<A>::template rebind_alloc<CouponHashSet<A>> chsAlloc;
+  CouponHashSet<A>* chSet = new (chsAlloc().allocate(1)) CouponHashSet<A>(list.getLgConfigK(), list.getTgtHllType());
+  for (auto coupon: list) {
+    chSet->couponUpdate(coupon);
+  }
+  return chSet;
+}
+
+template<typename A>
+HllArray<A>* HllSketchImplFactory<A>::promoteListOrSetToHll(const CouponList<A>& src) {
+  HllArray<A>* tgtHllArr = HllSketchImplFactory<A>::newHll(src.getLgConfigK(), src.getTgtHllType());
+  tgtHllArr->putKxQ0(1 << src.getLgConfigK());
+  for (auto coupon: src) {
+    tgtHllArr->couponUpdate(coupon);
+  }
+  tgtHllArr->putHipAccum(src.getEstimate());
+  tgtHllArr->putOutOfOrderFlag(false);
+  return tgtHllArr;
+}
+
+template<typename A>
+HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(std::istream& is) {
+  // we'll hand off the sketch based on PreInts so we don't need
+  // to move the stream pointer back and forth -- perhaps somewhat fragile?
+  const int preInts = is.peek();
+  if (preInts == HllUtil<A>::HLL_PREINTS) {
+    return HllArray<A>::newHll(is);
+  } else if (preInts == HllUtil<A>::HASH_SET_PREINTS) {
+    return CouponHashSet<A>::newSet(is);
+  } else if (preInts == HllUtil<A>::LIST_PREINTS) {
+    return CouponList<A>::newList(is);
+  } else {
+    throw std::invalid_argument("Attempt to deserialize unknown object type");
+  }
+}
+
+template<typename A>
+HllSketchImpl<A>* HllSketchImplFactory<A>::deserialize(const void* bytes, size_t len) {
+  // read current mode directly
+  const int preInts = static_cast<const uint8_t*>(bytes)[0];
+  if (preInts == HllUtil<A>::HLL_PREINTS) {
+    return HllArray<A>::newHll(bytes, len);
+  } else if (preInts == HllUtil<A>::HASH_SET_PREINTS) {
+    return CouponHashSet<A>::newSet(bytes, len);
+  } else if (preInts == HllUtil<A>::LIST_PREINTS) {
+    return CouponList<A>::newList(bytes, len);
+  } else {
+    throw std::invalid_argument("Attempt to deserialize unknown object type");
+  }
+}
+
+template<typename A>
+HllArray<A>* HllSketchImplFactory<A>::newHll(int lgConfigK, target_hll_type tgtHllType, bool startFullSize) {
+  switch (tgtHllType) {
+    case HLL_8:
+      typedef typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>> hll8Alloc;
+      return new (hll8Alloc().allocate(1)) Hll8Array<A>(lgConfigK, startFullSize);
+    case HLL_6:
+      typedef typename std::allocator_traits<A>::template rebind_alloc<Hll6Array<A>> hll6Alloc;
+      return new (hll6Alloc().allocate(1)) Hll6Array<A>(lgConfigK, startFullSize);
+    case HLL_4:
+      typedef typename std::allocator_traits<A>::template rebind_alloc<Hll4Array<A>> hll4Alloc;
+      return new (hll4Alloc().allocate(1)) Hll4Array<A>(lgConfigK, startFullSize);
+  }
+  throw std::logic_error("Invalid target_hll_type");
+}
+
+template<typename A>
+HllSketchImpl<A>* HllSketchImplFactory<A>::reset(HllSketchImpl<A>* impl, bool startFullSize) {
+  if (startFullSize) {
+    HllArray<A>* hll = newHll(impl->getLgConfigK(), impl->getTgtHllType(), startFullSize);
+    impl->get_deleter()(impl);
+    return hll;
+  } else {
+    typedef typename std::allocator_traits<A>::template rebind_alloc<CouponList<A>> clAlloc;
+    CouponList<A>* cl = new (clAlloc().allocate(1)) CouponList<A>(impl->getLgConfigK(), impl->getTgtHllType(), hll_mode::LIST);
+    impl->get_deleter()(impl);
+    return cl;
+  }
+}
+
+template<typename A>
+Hll4Array<A>* HllSketchImplFactory<A>::convertToHll4(const HllArray<A>& srcHllArr) {
+  const int lgConfigK = srcHllArr.getLgConfigK();
+  typedef typename std::allocator_traits<A>::template rebind_alloc<Hll4Array<A>> hll4Alloc;
+  Hll4Array<A>* hll4Array = new (hll4Alloc().allocate(1)) Hll4Array<A>(lgConfigK, srcHllArr.isStartFullSize());
+  hll4Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
+  hll4Array->mergeHll(srcHllArr);
+  hll4Array->putHipAccum(srcHllArr.getHipAccum());
+  return hll4Array;
+}
+
+template<typename A>
+Hll6Array<A>* HllSketchImplFactory<A>::convertToHll6(const HllArray<A>& srcHllArr) {
+  const int lgConfigK = srcHllArr.getLgConfigK();
+  typedef typename std::allocator_traits<A>::template rebind_alloc<Hll6Array<A>> hll6Alloc;
+  Hll6Array<A>* hll6Array = new (hll6Alloc().allocate(1)) Hll6Array<A>(lgConfigK, srcHllArr.isStartFullSize());
+  hll6Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
+  hll6Array->mergeHll(srcHllArr);
+  hll6Array->putHipAccum(srcHllArr.getHipAccum());
+  return hll6Array;
+}
+
+template<typename A>
+Hll8Array<A>* HllSketchImplFactory<A>::convertToHll8(const HllArray<A>& srcHllArr) {
+  const int lgConfigK = srcHllArr.getLgConfigK();
+  typedef typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>> hll8Alloc;
+  Hll8Array<A>* hll8Array = new (hll8Alloc().allocate(1)) Hll8Array<A>(lgConfigK, srcHllArr.isStartFullSize());
+  hll8Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
+  hll8Array->mergeHll(srcHllArr);
+  hll8Array->putHipAccum(srcHllArr.getHipAccum());
+  return hll8Array;
+}
+
+}
+
+#endif /* _HLLSKETCHIMPLFACTORY_HPP_ */

data/vendor/datasketches-cpp/hll/include/HllUnion-internal.hpp

@@ -0,0 +1,287 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _HLLUNION_INTERNAL_HPP_
+#define _HLLUNION_INTERNAL_HPP_
+
+#include "hll.hpp"
+
+#include "HllSketchImpl.hpp"
+#include "HllArray.hpp"
+#include "HllUtil.hpp"
+
+#include <stdexcept>
+#include <string>
+
+namespace datasketches {
+
+template<typename A>
+hll_union_alloc<A>::hll_union_alloc(const int lg_max_k):
+  lg_max_k(HllUtil<A>::checkLgK(lg_max_k)),
+  gadget(lg_max_k, target_hll_type::HLL_8)
+{}
+
+template<typename A>
+hll_sketch_alloc<A> hll_union_alloc<A>::get_result(target_hll_type target_type) const {
+  return hll_sketch_alloc<A>(gadget, target_type);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const hll_sketch_alloc<A>& sketch) {
+  if (sketch.is_empty()) return;
+  union_impl(sketch, lg_max_k);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(hll_sketch_alloc<A>&& sketch) {
+  if (sketch.is_empty()) return;
+  if (gadget.is_empty() && sketch.get_target_type() == HLL_8 && sketch.get_lg_config_k() <= lg_max_k) {
+    if (sketch.get_current_mode() == HLL || sketch.get_lg_config_k() == lg_max_k) {
+      gadget = std::move(sketch);
+    }
+  }
+  union_impl(sketch, lg_max_k);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const std::string& datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const uint64_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const uint32_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const uint16_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const uint8_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const int64_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const int32_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const int16_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const int8_t datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const double datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const float datum) {
+  gadget.update(datum);
+}
+
+template<typename A>
+void hll_union_alloc<A>::update(const void* data, const size_t length_bytes) {
+  gadget.update(data, length_bytes);
+}
+
+template<typename A>
+void hll_union_alloc<A>::coupon_update(const int coupon) {
+  if (coupon == HllUtil<A>::EMPTY) { return; }
+  HllSketchImpl<A>* result = gadget.sketch_impl->coupon_update(coupon);
+  if (result != gadget.sketch_impl) {
+    if (gadget.sketch_impl != nullptr) { gadget.sketch_impl->get_deleter()(gadget.sketch_impl); }
+    gadget.sketch_impl = result;
+  }
+}
+
+template<typename A>
+double hll_union_alloc<A>::get_estimate() const {
+  return gadget.get_estimate();
+}
+
+template<typename A>
+double hll_union_alloc<A>::get_composite_estimate() const {
+  return gadget.get_composite_estimate();
+}
+
+template<typename A>
+double hll_union_alloc<A>::get_lower_bound(const int num_std_dev) const {
+  return gadget.get_lower_bound(num_std_dev);
+}
+
+template<typename A>
+double hll_union_alloc<A>::get_upper_bound(const int num_std_dev) const {
+  return gadget.get_upper_bound(num_std_dev);
+}
+
+template<typename A>
+int hll_union_alloc<A>::get_compact_serialization_bytes() const {
+  return gadget.get_compact_serialization_bytes();
+}
+
+template<typename A>
+int hll_union_alloc<A>::get_updatable_serialization_bytes() const {
+  return gadget.get_updatable_serialization_bytes();
+}
+
+template<typename A>
+int hll_union_alloc<A>::get_lg_config_k() const {
+  return gadget.get_lg_config_k();
+}
+
+template<typename A>
+void hll_union_alloc<A>::reset() {
+  gadget.reset();
+}
+
+template<typename A>
+bool hll_union_alloc<A>::is_compact() const {
+  return gadget.is_compact();
+}
+
+template<typename A>
+bool hll_union_alloc<A>::is_empty() const {
+  return gadget.is_empty();
+}
+
+template<typename A>
+bool hll_union_alloc<A>::is_out_of_order_flag() const {
+  return gadget.is_out_of_order_flag();
+}
+
+template<typename A>
+hll_mode hll_union_alloc<A>::get_current_mode() const {
+  return gadget.get_current_mode();
+}
+
+template<typename A>
+bool hll_union_alloc<A>::is_estimation_mode() const {
+  return gadget.is_estimation_mode();
+}
+
+template<typename A>
+int hll_union_alloc<A>::get_serialization_version() const {
+  return HllUtil<A>::SER_VER;
+}
+
+template<typename A>
+target_hll_type hll_union_alloc<A>::get_target_type() const {
+  return target_hll_type::HLL_8;
+}
+
+template<typename A>
+int hll_union_alloc<A>::get_max_serialization_bytes(const int lg_k) {
+  return hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(lg_k, target_hll_type::HLL_8);
+}
+
+template<typename A>
+double hll_union_alloc<A>::get_rel_err(const bool upper_bound, const bool unioned,
+                           const int lg_config_k, const int num_std_dev) {
+  return HllUtil<A>::getRelErr(upper_bound, unioned, lg_config_k, num_std_dev);
+}
+
+template<typename A>
+HllSketchImpl<A>* hll_union_alloc<A>::copy_or_downsample(const HllSketchImpl<A>* src_impl, const int tgt_lg_k) {
+  if (src_impl->getCurMode() != HLL) {
+    throw std::logic_error("Attempt to downsample non-HLL sketch");
+  }
+  const HllArray<A>* src = static_cast<const HllArray<A>*>(src_impl);
+  const int src_lg_k = src->getLgConfigK();
+  if (src_lg_k <= tgt_lg_k) {
+    return src->copyAs(HLL_8);
+  }
+  typedef typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>> hll8Alloc;
+  Hll8Array<A>* tgtHllArr = new (hll8Alloc().allocate(1)) Hll8Array<A>(tgt_lg_k, false);
+  tgtHllArr->mergeHll(*src);
+  //both of these are required for isomorphism
+  tgtHllArr->putHipAccum(src->getHipAccum());
+  tgtHllArr->putOutOfOrderFlag(src->isOutOfOrderFlag());
+  return tgtHllArr;
+}
+
+template<typename A>
+inline HllSketchImpl<A>* hll_union_alloc<A>::leak_free_coupon_update(HllSketchImpl<A>* impl, const int coupon) {
+  HllSketchImpl<A>* result = impl->couponUpdate(coupon);
+  if (result != impl) {
+    impl->get_deleter()(impl);
+  }
+  return result;
+}
+
+template<typename A>
+void hll_union_alloc<A>::union_impl(const hll_sketch_alloc<A>& sketch, const int lg_max_k) {
+  const HllSketchImpl<A>* src_impl = sketch.sketch_impl; //default
+  HllSketchImpl<A>* dst_impl = gadget.sketch_impl; //default
+  if (src_impl->getCurMode() == LIST || src_impl->getCurMode() == SET) {
+    if (dst_impl->isEmpty() && src_impl->getLgConfigK() == dst_impl->getLgConfigK()) {
+      dst_impl = src_impl->copyAs(HLL_8);
+      gadget.sketch_impl->get_deleter()(gadget.sketch_impl); // gadget to be replaced
+    } else {
+      const CouponList<A>* src = static_cast<const CouponList<A>*>(src_impl);
+      for (auto coupon: *src) {
+        dst_impl = leak_free_coupon_update(dst_impl, coupon); //assignment required
+      }
+    }
+  } else if (!dst_impl->isEmpty()) { // src is HLL
+    if (dst_impl->getCurMode() == LIST || dst_impl->getCurMode() == SET) {
+      // swap so that src is LIST or SET, tgt is HLL
+      // use lg_max_k because LIST has effective K of 2^26
+      const CouponList<A>* src = static_cast<const CouponList<A>*>(dst_impl);
+      dst_impl = copy_or_downsample(src_impl, lg_max_k);
+      static_cast<Hll8Array<A>*>(dst_impl)->mergeList(*src);
+      gadget.sketch_impl->get_deleter()(gadget.sketch_impl); // gadget to be replaced
+    } else { // gadget is HLL
+      if (src_impl->getLgConfigK() < dst_impl->getLgConfigK()) {
+        dst_impl = copy_or_downsample(dst_impl, sketch.get_lg_config_k());
+        gadget.sketch_impl->get_deleter()(gadget.sketch_impl); // gadget to be replaced
+      }
+      const HllArray<A>* src = static_cast<const HllArray<A>*>(src_impl);
+      static_cast<Hll8Array<A>*>(dst_impl)->mergeHll(*src);
+      dst_impl->putOutOfOrderFlag(true);
+      static_cast<Hll8Array<A>*>(dst_impl)->putHipAccum(0);
+    }
+  } else { // src is HLL, gadget is empty
+    dst_impl = copy_or_downsample(src_impl, lg_max_k);
+    gadget.sketch_impl->get_deleter()(gadget.sketch_impl); // gadget to be replaced
+  }
+  gadget.sketch_impl = dst_impl; // gadget replaced
+}
+
+}
+
+#endif // _HLLUNION_INTERNAL_HPP_