datasketches 0.3.1 → 0.4.0

data/vendor/datasketches-cpp/python/tests/theta_test.py

@@ -1,146 +0,0 @@
-# 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.
- 
-import unittest
-
-from datasketches import theta_sketch, update_theta_sketch
-from datasketches import compact_theta_sketch, theta_union
-from datasketches import theta_intersection, theta_a_not_b
-from datasketches import theta_jaccard_similarity
-
-class ThetaTest(unittest.TestCase):
-    def test_theta_basic_example(self):
-        k = 12      # 2^k = 4096 rows in the table
-        n = 1 << 18 # ~256k unique values
-
-        # create a sketch and inject some values
-        sk = self.generate_theta_sketch(n, k)
-
-        # we can check that the upper and lower bounds bracket the
-        # estimate, without needing to know the exact value.
-        self.assertLessEqual(sk.get_lower_bound(1), sk.get_estimate())
-        self.assertGreaterEqual(sk.get_upper_bound(1), sk.get_estimate())
-
-        # because this sketch is deterministically generated, we can
-        # also compare against the exact value
-        self.assertLessEqual(sk.get_lower_bound(1), n)
-        self.assertGreaterEqual(sk.get_upper_bound(1), n)
-
-        # compact and serialize for storage, then reconstruct
-        sk_bytes = sk.compact().serialize()
-        new_sk = compact_theta_sketch.deserialize(sk_bytes)
-
-        # estimate remains unchanged
-        self.assertFalse(sk.is_empty())
-        self.assertEqual(sk.get_estimate(), new_sk.get_estimate())
-
-    def test_theta_set_operations(self):
-        k = 12      # 2^k = 4096 rows in the table
-        n = 1 << 18 # ~256k unique values
-
-        # we'll have 1/4 of the values overlap
-        offset = int(3 * n / 4) # it's a float w/o cast
-
-        # create a couple sketches and inject some values
-        sk1 = self.generate_theta_sketch(n, k)
-        sk2 = self.generate_theta_sketch(n, k, offset)
-
-        # UNIONS
-        # create a union object
-        union = theta_union(k)
-        union.update(sk1)
-        union.update(sk2)
-
-        # getting result from union returns a compact_theta_sketch
-        # compact theta sketches can be used in additional unions
-        # or set operations but cannot accept further item updates
-        result = union.get_result()
-        self.assertTrue(isinstance(result, compact_theta_sketch))
-
-        # since our process here is deterministic, we have
-        # checked and know the exact answer is within one
-        # standard deviation of the estimate
-        self.assertLessEqual(result.get_lower_bound(1), 7 * n / 4)
-        self.assertGreaterEqual(result.get_upper_bound(1), 7 * n / 4)
-
-
-        # INTERSECTIONS
-        # create an intersection object
-        intersect = theta_intersection() # no lg_k
-        intersect.update(sk1)
-        intersect.update(sk2)
-
-        # has_result() indicates the intersection has been used,
-        # although the result may be the empty set
-        self.assertTrue(intersect.has_result())
-
-        # as with unions, the result is a compact sketch
-        result = intersect.get_result()
-        self.assertTrue(isinstance(result, compact_theta_sketch))
-
-        # we know the sets overlap by 1/4
-        self.assertLessEqual(result.get_lower_bound(1), n / 4)
-        self.assertGreaterEqual(result.get_upper_bound(1), n / 4)
-
-
-        # A NOT B
-        # create an a_not_b object
-        anb = theta_a_not_b() # no lg_k
-        result = anb.compute(sk1, sk2)
-
-        # as with unions, the result is a compact sketch
-        self.assertTrue(isinstance(result, compact_theta_sketch))
-
-        # we know the sets overlap by 1/4, so the remainder is 3/4
-        self.assertLessEqual(result.get_lower_bound(1), 3 * n / 4)
-        self.assertGreaterEqual(result.get_upper_bound(1), 3 * n / 4)
-
-
-        # JACCARD SIMILARITY
-        # Jaccard Similarity measure returns (lower_bound, estimate, upper_bound)
-        jac = theta_jaccard_similarity.jaccard(sk1, sk2)
-
-        # we can check that results are in the expected order
-        self.assertLess(jac[0], jac[1])
-        self.assertLess(jac[1], jac[2])
-
-        # checks for sketch equivalency
-        self.assertTrue(theta_jaccard_similarity.exactly_equal(sk1, sk1))
-        self.assertFalse(theta_jaccard_similarity.exactly_equal(sk1, sk2))
-
-        # we can apply a check for similarity or dissimilarity at a
-        # given threshhold, at 97.7% confidence.
-
-        # check that the Jaccard Index is at most (upper bound) 0.2.
-        # exact result would be 1/7
-        self.assertTrue(theta_jaccard_similarity.dissimilarity_test(sk1, sk2, 0.2))
-
-        # check that the Jaccard Index is at least (lower bound) 0.7
-        # exact result would be 3/4, using result from A NOT B test
-        self.assertTrue(theta_jaccard_similarity.similarity_test(sk1, result, 0.7))
-
-
-    def generate_theta_sketch(self, n, k, offset=0):
-      sk = update_theta_sketch(k)
-      for i in range(0, n):
-        sk.update(i + offset)
-      return sk
-        
-if __name__ == '__main__':
-    unittest.main()
-
-  

data/vendor/datasketches-cpp/python/tests/vector_of_kll_test.py

@@ -1,148 +0,0 @@
-# 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.
-
-import unittest
-from datasketches import (vector_of_kll_ints_sketches,
-                          vector_of_kll_floats_sketches)
-import numpy as np
-
-class VectorOfKllSketchesTest(unittest.TestCase):
-    def test_vector_of_kll_floats_sketches_example(self):
-      k = 200
-      d = 3
-      n = 2 ** 20
-
-      # create a sketch and inject ~1 million N(0,1) points
-      kll = vector_of_kll_floats_sketches(k, d)
-      # Track the min/max for each sketch to test later
-      smin = np.zeros(d) + np.inf
-      smax = np.zeros(d) - np.inf
-
-      for i in range(0, n):
-        dat  = np.random.randn(d)
-        smin = np.amin([smin, dat], axis=0)
-        smax = np.amax([smax, dat], axis=0)
-        kll.update(dat)
-
-      # 0 should be near the median
-      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.035)
-      # the median should be near 0
-      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.035)
-      # we also track the min/max independently from the rest of the data
-      # which lets us know the full observed data range
-      np.testing.assert_allclose(kll.get_min_values(), smin)
-      np.testing.assert_allclose(kll.get_max_values(), smax)
-      np.testing.assert_array_less(kll.get_min_values(), kll.get_quantiles(0.01)[:,0])
-      np.testing.assert_array_less(kll.get_quantiles(0.99)[:,0], kll.get_max_values())
-
-      # we can also extract a list of values at a time,
-      # here the values should give us something close to [-2, -1, 0, 1, 2].
-      # then get the CDF, which will return something close to
-      # the original values used in get_quantiles()
-      # finally, can check the normalized rank error bound
-      pts = kll.get_quantiles([0.0228, 0.1587, 0.5, 0.8413, 0.9772])
-      # use the mean pts for the CDF, include 1.0 at end to account for all probability mass
-      meanpts = np.mean(pts, axis=0)
-      cdf = kll.get_cdf(meanpts)
-      self.assertEqual(cdf.shape[0], pts.shape[0])
-      self.assertEqual(cdf.shape[1], pts.shape[1]+1)
-
-      # and a few basic queries about the sketch
-      self.assertFalse(np.all(kll.is_empty()))
-      self.assertTrue(np.all(kll.is_estimation_mode()))
-      self.assertTrue(np.all(kll.get_n() == n))
-      self.assertTrue(np.all(kll.get_num_retained() < n))
-
-      # we can combine sketches across all dimensions and get the reuslt
-      result = kll.collapse()
-      self.assertEqual(result.get_n(), d * n)
-
-      # merging a copy of itself will double the number of items the sketch has seen
-      kll_copy = vector_of_kll_floats_sketches(kll)
-      kll.merge(kll_copy)
-      np.testing.assert_equal(kll.get_n(), 2*n)
-
-      # we can then serialize and reconstruct the sketch
-      kll_bytes = kll.serialize() # serializes each sketch as a list
-      new_kll = vector_of_kll_floats_sketches(k, d)
-      for s in range(len(kll_bytes)):
-        new_kll.deserialize(kll_bytes[s], s)
-
-      # everything should be exactly equal
-      np.testing.assert_equal(kll.get_num_retained(), new_kll.get_num_retained())
-      np.testing.assert_equal;(kll.get_min_values(), new_kll.get_min_values())
-      np.testing.assert_equal(kll.get_max_values(), new_kll.get_max_values())
-      np.testing.assert_equal(kll.get_quantiles(0.7), new_kll.get_quantiles(0.7))
-      np.testing.assert_equal(kll.get_ranks(0.0), new_kll.get_ranks(0.0))
-
-    def test_kll_ints_sketches(self):
-      # already tested floats and it's templatized, so just make sure it instantiates properly
-      k = 100
-      d = 5
-      kll = vector_of_kll_ints_sketches(k, d)
-      self.assertTrue(np.all(kll.is_empty()))
-
-    def test_kll_2Dupdates(self):
-      # 1D case tested in the first example
-      # 2D case will follow same idea, but focusing on update()
-      k = 200
-      d = 3
-      # we'll do ~250k updates of 4 values each (total ~1mil updates, as above)
-      n = 2 ** 18
-      nbatch = 4
-
-      # create a sketch and inject ~1 million N(0,1) points
-      kll = vector_of_kll_floats_sketches(k, d)
-      # Track the min/max for each sketch to test later
-      smin = np.zeros(d) + np.inf
-      smax = np.zeros(d) - np.inf
-
-      for i in range(0, n):
-        dat  = np.random.randn(nbatch, d)
-        smin = np.amin(np.row_stack((smin, dat)), axis=0)
-        smax = np.amax(np.row_stack((smax, dat)), axis=0)
-        kll.update(dat)
-
-      # 0 should be near the median
-      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.035)
-      # the median should be near 0
-      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.035)
-      # we also track the min/max independently from the rest of the data
-      # which lets us know the full observed data range
-      np.testing.assert_allclose(kll.get_min_values(), smin)
-      np.testing.assert_allclose(kll.get_max_values(), smax)
-
-    def test_kll_3Dupdates(self):
-      # now test 3D update, which should fail
-      k = 200
-      d = 3
-
-      # create a sketch
-      kll = vector_of_kll_floats_sketches(k, d)
-
-      # we'll try 1 3D update
-      dat = np.random.randn(10, 7, d)
-      try:
-        kll.update(dat)
-      except:
-        # this is what we expect
-        pass
-      # the sketches should still be empty
-      self.assertTrue(np.all(kll.is_empty()))
-
-if __name__ == '__main__':
-    unittest.main()

data/vendor/datasketches-cpp/python/tests/vo_test.py

@@ -1,125 +0,0 @@
-# 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.
- 
-import unittest
-from datasketches import var_opt_sketch, var_opt_union, PyIntsSerDe, PyStringsSerDe
-
-class VoTest(unittest.TestCase):
-  def test_vo_example(self):
-    k = 50  # a small value so we can easily fill the sketch
-    vo = var_opt_sketch(k)
-
-    # varopt sampling reduces to standard reservoir sampling
-    # if the items are all equally weighted, although the
-    # algorithm will be significantly slower than an optimized
-    # reservoir sampler
-    n = 5 * k
-    for i in range(0, n):
-      vo.update(i)
-
-    # we can also add a heavy item, using a negative weight for
-    # easy filtering later.  keep in mind that "heavy" is a
-    # relative concept, so using a fixed multiple of n may not
-    # be considered a heavy item for larger values of n
-    vo.update(-1, 1000 * n)
-    self.assertEqual(k, vo.k)
-    self.assertEqual(k, vo.num_samples)
-    self.assertEqual(n + 1, vo.n)
-    self.assertFalse(vo.is_empty())
-
-    # we can easily get the list of items in the sample
-    items = vo.get_samples()
-    self.assertEqual(len(items), k)
-
-    # we can also apply a predicate to the sketch to get an estimate
-    # (with optimally minimal variance) of the subset sum of items
-    # matching that predicate among the entire population
-
-    # we'll use a lambda here, but any function operating on a single
-    # item which returns a boolean value should work
-    summary = vo.estimate_subset_sum(lambda x: x < 0)
-    self.assertEqual(summary['estimate'], 1000 * n)
-    self.assertEqual(summary['total_sketch_weight'], 1001 * n)
-
-    # a regular function is similarly handled
-    def geq_zero(x):
-      return x >= 0
-    summary = vo.estimate_subset_sum(geq_zero)
-    self.assertEqual(summary['estimate'], n)
-    self.assertEqual(summary['total_sketch_weight'], 1001 * n)
-
-    # next we'll create a second, smaller sketch with
-    # only heavier items relative to the previous sketch,
-    # but with the sketch in sampling mode
-    k2 = 5
-    vo2 = var_opt_sketch(k2)
-    # for weight, use the estimate of all items >=0 from before
-    wt = summary['estimate']
-    for i in range(0, k2 + 1):
-      vo2.update((2 * n) + i, wt)
-
-    # now union the sketches, demonstrating how the
-    # union's k may not be equal to that of either
-    # input value
-    union = var_opt_union(k)
-    union.update(vo)
-    union.update(vo2)
-
-    result = union.get_result()
-    self.assertEqual(n + k2 + 2, result.n)
-    self.assertFalse(result.is_empty())
-    self.assertGreater(result.k, k2)
-    self.assertLess(result.k, k)
-
-    # we can compare what information is available from both
-    # the union and a sketch.
-    print(union)
-
-    # if we want to print the list of items, there must be a
-    # __str__() method for each item (which need not be the same
-    # type; they're all generic python objects when used from
-    # python), otherwise you may trigger an exception.
-    # to_string() is provided as a convenience to avoid direct
-    # calls to __str__() with parameters.
-    print(result.to_string(True))
-
-    # finally, we can serialize the sketch by providing an
-    # appropriate serde class.
-    expected_size = result.get_serialized_size_bytes(PyIntsSerDe())
-    b = result.serialize(PyIntsSerDe())
-    self.assertEqual(expected_size, len(b))
-
-    # if we try to deserialize with the wrong serde, things break
-    try:
-      var_opt_sketch.deserialize(b, PyStringsSerDe())
-      self.fail()
-    except:
-      # expected; do nothing
-      self.assertTrue(True)
-      
-    # using the correct serde gives us back a copy of the original
-    rebuilt = var_opt_sketch.deserialize(b, PyIntsSerDe())
-    self.assertEqual(result.k, rebuilt.k)
-    self.assertEqual(result.num_samples, rebuilt.num_samples)
-    self.assertEqual(result.n, rebuilt.n)
-    summary1 = result.estimate_subset_sum(geq_zero)
-    summary2 = rebuilt.estimate_subset_sum(geq_zero)
-    self.assertEqual(summary1['estimate'], summary2['estimate'])
-    self.assertEqual(summary1['total_sketch_weight'], summary2['total_sketch_weight'])
-
-if __name__ == '__main__':
-  unittest.main()

data/vendor/datasketches-cpp/sampling/test/binaries_from_java.txt

@@ -1,67 +0,0 @@
-/*
- * 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.
- */
-
-Code snippets used to generate to generate the binary images from Java.
-Heavy items have negative weights to allow a simple predicate to filter
-heavy vs light sketch entires.
-
-
-varopt_sketch_long_sampling.bin:
-final VarOptItemsSketch<String> sk = VarOptItemsSketch.newInstance(1024);
-for (int i = 1; i <= 200; ++i) {
-    sk.update(Integer.toString(i), 1000.0 / i);
-}
-byte[] bytes = sk.toByteArray(new ArrayOfStringsSerDe());
-
-
-varopt_sketch_string_exact.bin:
-final VarOptItemsSketch<Long> sk = VarOptItemsSketch.newInstance(1024);
-for (long i = 0; i < 2000; ++i) {
-  sk.update(i, 1.0);
-}
-sk.update(-1L, 100000.0);
-sk.update(-2L, 110000.0);
-sk.update(-3L, 120000.0);
-byte[] bytes = sk.toByteArray(new ArrayOfLongsSerDe());
-
-
-varopt_union_double_sampling.bin:
-// parallels small samplign sketch test
-final int kSmall = 16;
-final int n1 = 32;
-final int n2 = 64;
-final int kMax = 128;
-
-// small k sketch, but sampling
-VarOptItemsSketch<Double> sketch = VarOptItemsSketch.newInstance(kSmall);
-for (int i = 0; i < n1; ++i) {
-  sketch.update(1.0 * i, 1.0);
-}
-sketch.update(-1.0, n1 * n1); // add a heavy item
-
-final VarOptItemsUnion<Double> union = VarOptItemsUnion.newInstance(kMax);
-union.update(sketch);
-
-// another one, but different n to get a different per-item weight
-sketch = VarOptItemsSketch.newInstance(kSmall);
-for (int i = 0; i < n2; ++i) {
-  sketch.update(1.0 * i, 1.0);
-}
-union.update(sketch);
-byte[] bytes = union.toByteArray(new ArrayOfDoublesSerDe());

data/vendor/datasketches-cpp/setup.py

@@ -1,110 +0,0 @@
-# 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.
-
-# Modified from:
-# http://www.benjack.io/2018/02/02/python-cpp-revisited.html
-
-import os
-import sys
-import platform
-import subprocess
-import re
-from datetime import datetime, timezone
-
-from setuptools import setup, find_packages, Extension
-from setuptools.command.build_ext import build_ext
-
-class CMakeExtension(Extension):
-    def __init__(self, name, sourcedir=''):
-        Extension.__init__(self, name, sources=[])
-        self.sourcedir = os.path.abspath(sourcedir)
-
-class CMakeBuild(build_ext):
-    def run(self):
-        try:
-            subprocess.check_output(['cmake', '--version'])
-        except OSError:
-            raise RuntimeError(
-                "CMake >= 3.12 must be installed to build the following extensions: " +
-                ", ".join(e.name for e in self.extensions))
-
-        for ext in self.extensions:
-            self.build_extension(ext)
-
-    def build_extension(self, ext):
-        extdir = os.path.abspath(
-            os.path.dirname(self.get_ext_fullpath(ext.name)))
-        cmake_args =  ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir]
-        cmake_args += ['-DWITH_PYTHON=True']
-        cmake_args += ['-DCMAKE_CXX_STANDARD=11']
-        # ensure we use a consistent python version
-        cmake_args += ['-DPython3_EXECUTABLE=' + sys.executable]
-        cfg = 'Debug' if self.debug else 'Release'
-        build_args = ['--config', cfg]
-
-        if platform.system() == "Windows":
-            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(
-                           cfg.upper(),
-                           extdir)]
-            if sys.maxsize > 2**32:
-                cmake_args += ['-T', 'host=x64']
-                cmake_args += ['-DCMAKE_GENERATOR_PLATFORM=x64']
-                build_args += ['--', '/m']
-        else:
-            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
-            build_args += ['--', '-j2']
-
-        env = os.environ.copy()
-        env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format(
-            env.get('CXXFLAGS', ''),
-            self.distribution.get_version())
-        if not os.path.exists(self.build_temp):
-            os.makedirs(self.build_temp)
-        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args,
-                              cwd=self.build_temp, env=env)
-        subprocess.check_call(['cmake', '--build', '.', '--target', 'python'] + build_args,
-                              cwd=self.build_temp, env=env)
-        print() # add an empty line to pretty print
-
-# Read and parse the version format
-# @DT@ -> datestamp
-# @HHMM@ -> .devHHMM to indicate development version
-# Releases should have a fixed version with no @ variables
-with open('version.cfg.in', 'r') as file:
-    ds_version = file.read().rstrip()
-dt = datetime.now(timezone.utc)
-ds_version = re.sub('@DT@', dt.strftime('%Y%m%d'), ds_version)
-ds_version = re.sub('@HHMM@', 'dev' + dt.strftime('%H%M'), ds_version)
-
-setup(
-    name='datasketches',
-    version=ds_version,
-    author='Apache Software Foundation',
-    author_email='dev@datasketches.apache.org',
-    description='The Apache DataSketches Library for Python',
-    license='Apache License 2.0',
-    url='http://datasketches.apache.org',
-    long_description=open('python/README.md').read(),
-    long_description_content_type='text/markdown',
-    packages=find_packages(where='python',exclude=['src','*tests*']), # src not needed if only the .so
-    package_dir={'':'python'},
-    # may need to add all source paths for sdist packages w/o MANIFEST.in
-    ext_modules=[CMakeExtension('datasketches')],
-    cmdclass={'build_ext': CMakeBuild},
-    install_requires=['numpy'],
-    zip_safe=False
-)

data/vendor/datasketches-cpp/tuple/include/array_of_doubles_intersection.hpp

@@ -1,52 +0,0 @@
-/*
- * 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 ARRAY_OF_DOUBLES_INTERSECTION_HPP_
-#define ARRAY_OF_DOUBLES_INTERSECTION_HPP_
-
-#include <vector>
-#include <memory>
-
-#include "array_of_doubles_sketch.hpp"
-#include "tuple_intersection.hpp"
-
-namespace datasketches {
-
-template<
-  typename Policy,
-  typename Allocator = std::allocator<double>
->
-class array_of_doubles_intersection: public tuple_intersection<aod<Allocator>, Policy, AllocAOD<Allocator>> {
-public:
-  using Summary = aod<Allocator>;
-  using AllocSummary = AllocAOD<Allocator>;
-  using Base = tuple_intersection<Summary, Policy, AllocSummary>;
-  using CompactSketch = compact_array_of_doubles_sketch_alloc<Allocator>;
-  using resize_factor = theta_constants::resize_factor;
-
-  explicit array_of_doubles_intersection(uint64_t seed = DEFAULT_SEED, const Policy& policy = Policy(), const Allocator& allocator = Allocator());
-
-  CompactSketch get_result(bool ordered = true) const;
-};
-
-} /* namespace datasketches */
-
-#include "array_of_doubles_intersection_impl.hpp"
-
-#endif