This is an automated email from the ASF dual-hosted git repository.
placave pushed a commit to branch reverse-order
in repository https://gitbox.apache.org/repos/asf/datasketches-go.git
The following commit(s) were added to refs/heads/reverse-order by this push:
new 06418d2 rename the type utility struct to Ops class
06418d2 is described below
commit 06418d2616f910029c74d2132f3eaa5f668c2396
Author: Pierre Lacave <[email protected]>
AuthorDate: Wed Mar 20 22:57:53 2024 +0100
rename the type utility struct to Ops class
---
...of_doubles_serde.go => array_of_doubles_ops.go} | 18 ++--
...ray_of_longs_serde.go => array_of_longs_ops.go} | 18 ++--
...of_strings_serde.go => array_of_strings_ops.go} | 18 ++--
examples/frequency_example_test.go | 2 +-
examples/kll_example_test.go | 2 +-
frequencies/items_sketch_test.go | 46 +++++-----
frequencies/serde_compat_test.go | 4 +-
frequencies/sketch_serialization_test.go | 18 ++--
kll/items_sketch_test.go | 100 ++++++++++-----------
kll/items_sletch_serialization_test.go | 8 +-
10 files changed, 117 insertions(+), 117 deletions(-)
diff --git a/common/array_of_doubles_serde.go b/common/array_of_doubles_ops.go
similarity index 74%
rename from common/array_of_doubles_serde.go
rename to common/array_of_doubles_ops.go
index 628266e..54dd408 100644
--- a/common/array_of_doubles_serde.go
+++ b/common/array_of_doubles_ops.go
@@ -23,22 +23,22 @@ import (
"math"
)
-type ArrayOfDoublesSerDe struct {
+type ArrayOfDoublesOps struct {
ReverseOrder bool
scratch [8]byte
}
-func (f ArrayOfDoublesSerDe) Identity() float64 {
+func (f ArrayOfDoublesOps) Identity() float64 {
return 0
}
-func (f ArrayOfDoublesSerDe) Hash(item float64) uint64 {
+func (f ArrayOfDoublesOps) Hash(item float64) uint64 {
binary.LittleEndian.PutUint64(f.scratch[:], math.Float64bits(item))
return murmur3.SeedSum64(_DEFAULT_SERDE_HASH_SEED, f.scratch[:])
}
-func (f ArrayOfDoublesSerDe) LessFn() LessFn[float64] {
+func (f ArrayOfDoublesOps) LessFn() LessFn[float64] {
return func(a float64, b float64) bool {
if f.ReverseOrder {
return a > b
@@ -47,21 +47,21 @@ func (f ArrayOfDoublesSerDe) LessFn() LessFn[float64] {
}
}
-func (f ArrayOfDoublesSerDe) SizeOf(item float64) int {
+func (f ArrayOfDoublesOps) SizeOf(item float64) int {
return 8
}
-func (f ArrayOfDoublesSerDe) SizeOfMany(mem []byte, offsetBytes int, numItems
int) (int, error) {
+func (f ArrayOfDoublesOps) SizeOfMany(mem []byte, offsetBytes int, numItems
int) (int, error) {
return numItems * 8, nil
}
-func (f ArrayOfDoublesSerDe) SerializeOneToSlice(item float64) []byte {
+func (f ArrayOfDoublesOps) SerializeOneToSlice(item float64) []byte {
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, math.Float64bits(item))
return bytes
}
-func (f ArrayOfDoublesSerDe) SerializeManyToSlice(item []float64) []byte {
+func (f ArrayOfDoublesOps) SerializeManyToSlice(item []float64) []byte {
if len(item) == 0 {
return []byte{}
}
@@ -74,7 +74,7 @@ func (f ArrayOfDoublesSerDe) SerializeManyToSlice(item
[]float64) []byte {
return bytes
}
-func (f ArrayOfDoublesSerDe) DeserializeManyFromSlice(mem []byte, offsetBytes
int, numItems int) ([]float64, error) {
+func (f ArrayOfDoublesOps) DeserializeManyFromSlice(mem []byte, offsetBytes
int, numItems int) ([]float64, error) {
if numItems == 0 {
return []float64{}, nil
}
diff --git a/common/array_of_longs_serde.go b/common/array_of_longs_ops.go
similarity index 75%
rename from common/array_of_longs_serde.go
rename to common/array_of_longs_ops.go
index 7e14b40..e30129e 100644
--- a/common/array_of_longs_serde.go
+++ b/common/array_of_longs_ops.go
@@ -22,22 +22,22 @@ import (
"github.com/twmb/murmur3"
)
-type ArrayOfLongsSerDe struct {
+type ArrayOfLongsOps struct {
ReverseOrder bool
scratch [8]byte
}
-func (f ArrayOfLongsSerDe) Identity() int64 {
+func (f ArrayOfLongsOps) Identity() int64 {
return 0
}
-func (f ArrayOfLongsSerDe) Hash(item int64) uint64 {
+func (f ArrayOfLongsOps) Hash(item int64) uint64 {
binary.LittleEndian.PutUint64(f.scratch[:], uint64(item))
return murmur3.SeedSum64(_DEFAULT_SERDE_HASH_SEED, f.scratch[:])
}
-func (f ArrayOfLongsSerDe) LessFn() LessFn[int64] {
+func (f ArrayOfLongsOps) LessFn() LessFn[int64] {
return func(a int64, b int64) bool {
if f.ReverseOrder {
return a > b
@@ -46,21 +46,21 @@ func (f ArrayOfLongsSerDe) LessFn() LessFn[int64] {
}
}
-func (f ArrayOfLongsSerDe) SizeOf(item int64) int {
+func (f ArrayOfLongsOps) SizeOf(item int64) int {
return 8
}
-func (f ArrayOfLongsSerDe) SizeOfMany(mem []byte, offsetBytes int, numItems
int) (int, error) {
+func (f ArrayOfLongsOps) SizeOfMany(mem []byte, offsetBytes int, numItems int)
(int, error) {
return numItems * 8, nil
}
-func (f ArrayOfLongsSerDe) SerializeOneToSlice(item int64) []byte {
+func (f ArrayOfLongsOps) SerializeOneToSlice(item int64) []byte {
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, uint64(item))
return bytes
}
-func (f ArrayOfLongsSerDe) SerializeManyToSlice(item []int64) []byte {
+func (f ArrayOfLongsOps) SerializeManyToSlice(item []int64) []byte {
if len(item) == 0 {
return []byte{}
}
@@ -73,7 +73,7 @@ func (f ArrayOfLongsSerDe) SerializeManyToSlice(item []int64)
[]byte {
return bytes
}
-func (f ArrayOfLongsSerDe) DeserializeManyFromSlice(mem []byte, offsetBytes
int, numItems int) ([]int64, error) {
+func (f ArrayOfLongsOps) DeserializeManyFromSlice(mem []byte, offsetBytes int,
numItems int) ([]int64, error) {
if numItems == 0 {
return []int64{}, nil
}
diff --git a/common/array_of_strings_serde.go b/common/array_of_strings_ops.go
similarity index 83%
rename from common/array_of_strings_serde.go
rename to common/array_of_strings_ops.go
index 20410c8..87ad2af 100644
--- a/common/array_of_strings_serde.go
+++ b/common/array_of_strings_ops.go
@@ -25,20 +25,20 @@ import (
"github.com/twmb/murmur3"
)
-type ArrayOfStringsSerDe struct {
+type ArrayOfStringsOps struct {
ReverseOrder bool
}
-func (f ArrayOfStringsSerDe) Identity() string {
+func (f ArrayOfStringsOps) Identity() string {
return ""
}
-func (f ArrayOfStringsSerDe) Hash(item string) uint64 {
+func (f ArrayOfStringsOps) Hash(item string) uint64 {
datum := unsafe.Slice(unsafe.StringData(item), len(item))
return murmur3.SeedSum64(_DEFAULT_SERDE_HASH_SEED, datum[:])
}
-func (f ArrayOfStringsSerDe) LessFn() LessFn[string] {
+func (f ArrayOfStringsOps) LessFn() LessFn[string] {
return func(a string, b string) bool {
if f.ReverseOrder {
return a > b
@@ -47,14 +47,14 @@ func (f ArrayOfStringsSerDe) LessFn() LessFn[string] {
}
}
-func (f ArrayOfStringsSerDe) SizeOf(item string) int {
+func (f ArrayOfStringsOps) SizeOf(item string) int {
if len(item) == 0 {
return int(unsafe.Sizeof(uint32(0)))
}
return len(item) + int(unsafe.Sizeof(uint32(0)))
}
-func (f ArrayOfStringsSerDe) SizeOfMany(mem []byte, offsetBytes int, numItems
int) (int, error) {
+func (f ArrayOfStringsOps) SizeOfMany(mem []byte, offsetBytes int, numItems
int) (int, error) {
if numItems <= 0 {
return 0, nil
}
@@ -75,7 +75,7 @@ func (f ArrayOfStringsSerDe) SizeOfMany(mem []byte,
offsetBytes int, numItems in
return offset - offsetBytes, nil
}
-func (f ArrayOfStringsSerDe) SerializeOneToSlice(item string) []byte {
+func (f ArrayOfStringsOps) SerializeOneToSlice(item string) []byte {
if len(item) == 0 {
return []byte{}
}
@@ -86,7 +86,7 @@ func (f ArrayOfStringsSerDe) SerializeOneToSlice(item string)
[]byte {
return bytesOut
}
-func (f ArrayOfStringsSerDe) SerializeManyToSlice(item []string) []byte {
+func (f ArrayOfStringsOps) SerializeManyToSlice(item []string) []byte {
if len(item) == 0 {
return []byte{}
}
@@ -109,7 +109,7 @@ func (f ArrayOfStringsSerDe) SerializeManyToSlice(item
[]string) []byte {
return bytesOut
}
-func (f ArrayOfStringsSerDe) DeserializeManyFromSlice(mem []byte, offsetBytes
int, numItems int) ([]string, error) {
+func (f ArrayOfStringsOps) DeserializeManyFromSlice(mem []byte, offsetBytes
int, numItems int) ([]string, error) {
if numItems <= 0 {
return []string{}, nil
}
diff --git a/examples/frequency_example_test.go
b/examples/frequency_example_test.go
index aae3b65..5ea401d 100644
--- a/examples/frequency_example_test.go
+++ b/examples/frequency_example_test.go
@@ -26,7 +26,7 @@ import (
func TestFrequencyItemsSketch(t *testing.T) {
// Create a new sketch with a maximum of 16 items
- sketch, err :=
frequencies.NewFrequencyItemsSketchWithMaxMapSize[string](16,
common.ArrayOfStringsSerDe{})
+ sketch, err :=
frequencies.NewFrequencyItemsSketchWithMaxMapSize[string](16,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
// Update the sketch with some items
diff --git a/examples/kll_example_test.go b/examples/kll_example_test.go
index 80dcb00..2cae93e 100644
--- a/examples/kll_example_test.go
+++ b/examples/kll_example_test.go
@@ -27,7 +27,7 @@ import (
func TestKllItemsSketch(t *testing.T) {
// Create a new KLL sketch
- sketch, err :=
kll.NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch, err :=
kll.NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
// Update the sketch with 1000 items
diff --git a/frequencies/items_sketch_test.go b/frequencies/items_sketch_test.go
index 6eba843..179c22d 100644
--- a/frequencies/items_sketch_test.go
+++ b/frequencies/items_sketch_test.go
@@ -26,7 +26,7 @@ import (
)
func TestEmpty(t *testing.T) {
- h := common.ArrayOfStringsSerDe{}
+ h := common.ArrayOfStringsOps{}
sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE, h)
assert.NoError(t, err)
assert.True(t, sketch.IsEmpty())
@@ -41,7 +41,7 @@ func TestEmpty(t *testing.T) {
}
func TestOneItem(t *testing.T) {
- sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch.Update("a")
assert.NoError(t, err)
@@ -57,7 +57,7 @@ func TestOneItem(t *testing.T) {
}
func TestSeveralItem(t *testing.T) {
- sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch.Update("a")
assert.NoError(t, err)
@@ -106,7 +106,7 @@ func TestSeveralItem(t *testing.T) {
}
func TestEstimationMode(t *testing.T) {
- sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sketch, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
err = sketch.UpdateMany(1, 10)
assert.NoError(t, err)
@@ -166,10 +166,10 @@ func TestEstimationMode(t *testing.T) {
}
func TestSerializeStringDeserializeEmpty(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
bytes := sketch1.ToSlice()
- sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.True(t, sketch2.IsEmpty())
assert.Equal(t, sketch2.GetNumActiveItems(), 0)
@@ -177,7 +177,7 @@ func TestSerializeStringDeserializeEmpty(t *testing.T) {
}
func TestSerializeDeserializeUtf8Strings(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch1.Update("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
assert.NoError(t, err)
@@ -189,7 +189,7 @@ func TestSerializeDeserializeUtf8Strings(t *testing.T) {
assert.NoError(t, err)
bytes := sketch1.ToSlice()
- sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch2.Update("bbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
assert.NoError(t, err)
@@ -216,14 +216,14 @@ func TestSerializeDeserializeUtf8Strings(t *testing.T) {
}
func TestSerializeDeserializeLong(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
sketch1.Update(1)
sketch1.Update(2)
sketch1.Update(3)
sketch1.Update(4)
bytes := sketch1.ToSlice()
- sketch2, err := NewFrequencyItemsSketchFromSlice[int64](bytes,
common.ArrayOfLongsSerDe{})
+ sketch2, err := NewFrequencyItemsSketchFromSlice[int64](bytes,
common.ArrayOfLongsOps{})
sketch2.Update(2)
sketch2.Update(3)
sketch2.Update(2)
@@ -246,7 +246,7 @@ func TestSerializeDeserializeLong(t *testing.T) {
}
func TestResize(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](2<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](2<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
for i := 0; i < 32; i++ {
err = sketch1.UpdateMany(strconv.Itoa(i), int64(i*i))
assert.NoError(t, err)
@@ -254,7 +254,7 @@ func TestResize(t *testing.T) {
}
func TestMergeExact(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch1.Update("a")
assert.NoError(t, err)
@@ -265,7 +265,7 @@ func TestMergeExact(t *testing.T) {
err = sketch1.Update("d")
assert.NoError(t, err)
- sketch2, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch2, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch2.Update("b")
assert.NoError(t, err)
@@ -294,20 +294,20 @@ func TestMergeExact(t *testing.T) {
}
func TestNullMapReturns(t *testing.T) {
- map1, err := newReversePurgeItemHashMap[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ map1, err := newReversePurgeItemHashMap[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
assert.Nil(t, map1.getActiveKeys())
assert.Nil(t, map1.getActiveValues())
}
func TestMisc(t *testing.T) {
- sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
assert.Equal(t, sk1.GetCurrentMapCapacity(), 6)
est, err := sk1.GetEstimate(1)
assert.NoError(t, err)
assert.Equal(t, est, int64(0))
- sk2, err := NewFrequencyItemsSketchWithMaxMapSize[int64](8,
common.ArrayOfLongsSerDe{})
+ sk2, err := NewFrequencyItemsSketchWithMaxMapSize[int64](8,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
_, err = sk1.Merge(sk2)
assert.NoError(t, err)
@@ -328,14 +328,14 @@ func TestMisc(t *testing.T) {
}
func TestToString(t *testing.T) {
- sk, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sk, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
err = sk.Update(1)
t.Log(sk.ToString())
}
func TestFrequentItems1(t *testing.T) {
- fis, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ fis, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
fis.Update(1)
rows, err := fis.GetFrequentItems(ErrorTypeEnum.NoFalsePositives)
@@ -352,14 +352,14 @@ func TestFrequentItems1(t *testing.T) {
}
func TestUpdateExceptions(t *testing.T) {
- sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
err = sk1.UpdateMany(1, -1)
assert.Error(t, err)
}
func TestMemExceptions(t *testing.T) {
- sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsSerDe{})
+ sk1, err :=
NewFrequencyItemsSketchWithMaxMapSize[int64](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
sk1.Update(1)
bytes := sk1.ToSlice()
@@ -379,7 +379,7 @@ func TestMemExceptions(t *testing.T) {
}
func TestOneItemUtf8(t *testing.T) {
- sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](1<<_LG_MIN_MAP_SIZE,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
err = sketch1.Update("\u5fb5")
assert.NoError(t, err)
@@ -391,7 +391,7 @@ func TestOneItemUtf8(t *testing.T) {
assert.Equal(t, est, int64(1))
bytes := sketch1.ToSlice()
- sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.False(t, sketch2.IsEmpty())
assert.Equal(t, sketch2.GetNumActiveItems(), 1)
@@ -418,7 +418,7 @@ func TestItemGetAprioriError(t *testing.T) {
}
func BenchmarkItemSketch(b *testing.B) {
- sketch, err := NewFrequencyItemsSketch[int64](128, 8,
common.ArrayOfLongsSerDe{})
+ sketch, err := NewFrequencyItemsSketch[int64](128, 8,
common.ArrayOfLongsOps{})
assert.NoError(b, err)
for i := 0; i < b.N; i++ {
sketch.Update(int64(i))
diff --git a/frequencies/serde_compat_test.go b/frequencies/serde_compat_test.go
index f32b635..c420fe8 100644
--- a/frequencies/serde_compat_test.go
+++ b/frequencies/serde_compat_test.go
@@ -24,7 +24,7 @@ import (
)
func TestItemsToLongs(t *testing.T) {
- sketch1, err := NewFrequencyItemsSketchWithMaxMapSize[int64](8,
common.ArrayOfLongsSerDe{})
+ sketch1, err := NewFrequencyItemsSketchWithMaxMapSize[int64](8,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
sketch1.Update(1)
sketch1.Update(2)
@@ -64,7 +64,7 @@ func TestLongToItems(t *testing.T) {
sketch1.Update(4)
bytes := sketch1.ToSlice()
- sketch2, err := NewFrequencyItemsSketchFromSlice[int64](bytes,
common.ArrayOfLongsSerDe{})
+ sketch2, err := NewFrequencyItemsSketchFromSlice[int64](bytes,
common.ArrayOfLongsOps{})
assert.NoError(t, err)
sketch2.Update(2)
sketch2.Update(3)
diff --git a/frequencies/sketch_serialization_test.go
b/frequencies/sketch_serialization_test.go
index 3967670..f4010e4 100644
--- a/frequencies/sketch_serialization_test.go
+++ b/frequencies/sketch_serialization_test.go
@@ -66,7 +66,7 @@ func
TestGenerateGoBinariesForCompatibilityTestingLongsSketch(t *testing.T) {
t.Run("String Frequency", func(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
for _, n := range nArr {
- sk, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](64, common.ArrayOfStringsSerDe{})
+ sk, err :=
NewFrequencyItemsSketchWithMaxMapSize[string](64, common.ArrayOfStringsOps{})
assert.NoError(t, err)
for i := 1; i <= n; i++ {
err = sk.Update(strconv.Itoa(i))
@@ -94,7 +94,7 @@ func
TestGenerateGoBinariesForCompatibilityTestingLongsSketch(t *testing.T) {
})
t.Run("String ut8", func(t *testing.T) {
- sk, err := NewFrequencyItemsSketchWithMaxMapSize[string](64,
common.ArrayOfStringsSerDe{})
+ sk, err := NewFrequencyItemsSketchWithMaxMapSize[string](64,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.NoError(t, sk.UpdateMany("абвгд", 1))
@@ -116,7 +116,7 @@ func
TestGenerateGoBinariesForCompatibilityTestingLongsSketch(t *testing.T) {
})
t.Run("String ascii", func(t *testing.T) {
- sk, err := NewFrequencyItemsSketchWithMaxMapSize[string](64,
common.ArrayOfStringsSerDe{})
+ sk, err := NewFrequencyItemsSketchWithMaxMapSize[string](64,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.NoError(t,
sk.UpdateMany("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1))
@@ -166,7 +166,7 @@ func TestJavaCompat(t *testing.T) {
for _, n := range nArr {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_n%d_java.sk", internal.JavaPath, n))
assert.NoError(t, err)
- sketch, err :=
NewFrequencyItemsSketchFromSlice[string](bytes, common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewFrequencyItemsSketchFromSlice[string](bytes, common.ArrayOfStringsOps{})
if err != nil {
return
}
@@ -188,7 +188,7 @@ func TestJavaCompat(t *testing.T) {
t.Run("String utf8", func(t *testing.T) {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_utf8_java.sk", internal.JavaPath))
assert.NoError(t, err)
- sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
if err != nil {
return
}
@@ -221,7 +221,7 @@ func TestJavaCompat(t *testing.T) {
t.Run("String ascii", func(t *testing.T) {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_ascii_java.sk", internal.JavaPath))
assert.NoError(t, err)
- sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
if err != nil {
return
}
@@ -273,7 +273,7 @@ func TestCppCompat(t *testing.T) {
for _, n := range nArr {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_n%d_cpp.sk", internal.CppPath, n))
assert.NoError(t, err)
- sketch, err :=
NewFrequencyItemsSketchFromSlice[string](bytes, common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewFrequencyItemsSketchFromSlice[string](bytes, common.ArrayOfStringsOps{})
if err != nil {
return
}
@@ -295,7 +295,7 @@ func TestCppCompat(t *testing.T) {
t.Run("String utf8", func(t *testing.T) {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_utf8_cpp.sk", internal.CppPath))
assert.NoError(t, err)
- sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
if err != nil {
return
}
@@ -328,7 +328,7 @@ func TestCppCompat(t *testing.T) {
t.Run("String ascii", func(t *testing.T) {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/frequent_string_ascii_cpp.sk", internal.CppPath))
assert.NoError(t, err)
- sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewFrequencyItemsSketchFromSlice[string](bytes,
common.ArrayOfStringsOps{})
if err != nil {
return
}
diff --git a/kll/items_sketch_test.go b/kll/items_sketch_test.go
index f20598b..83d4d8a 100644
--- a/kll/items_sketch_test.go
+++ b/kll/items_sketch_test.go
@@ -35,16 +35,16 @@ const (
)
func TestItemsSketch_KLimits(t *testing.T) {
- _, err := NewKllItemsSketch[string](_MIN_K, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ _, err := NewKllItemsSketch[string](_MIN_K, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
- _, err = NewKllItemsSketch[string](uint16(_MAX_K), _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ _, err = NewKllItemsSketch[string](uint16(_MAX_K), _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
- _, err = NewKllItemsSketch[string](_MIN_K-1, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ _, err = NewKllItemsSketch[string](_MIN_K-1, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.Error(t, err)
}
func TestItemsSketch_Empty(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.True(t, sketch.IsEmpty())
assert.False(t, sketch.IsEstimationMode())
@@ -66,7 +66,7 @@ func TestItemsSketch_Empty(t *testing.T) {
}
func TestItemsSketch_BadQuantile(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sketch.Update("") // has to be non-empty to reach the check
_, err = sketch.GetQuantile(-1, true)
@@ -74,7 +74,7 @@ func TestItemsSketch_BadQuantile(t *testing.T) {
}
func TestItemsSketch_OneValue(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](200, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sketch.Update("A")
assert.False(t, sketch.IsEmpty())
@@ -104,7 +104,7 @@ func TestItemsSketch_OneValue(t *testing.T) {
func TestItemsSketch_TenValues(t *testing.T) {
tenStr := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J"}
- sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
strLen := len(tenStr)
dblStrLen := float64(strLen)
@@ -179,7 +179,7 @@ func TestItemsSketch_TenValues(t *testing.T) {
}
func TestItemsSketch_ManyValuesEstimationMode(T *testing.T) {
- sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(T, err)
n := 1_000_000
digits := numDigits(n)
@@ -239,7 +239,7 @@ func TestItemsSketch_ManyValuesEstimationMode(T *testing.T)
{
}
func TestItemsSketch_GetRankGetCdfGetPmfConsistency(t *testing.T) {
- sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 1000
digits := numDigits(n)
@@ -286,9 +286,9 @@ func TestItemsSketch_GetRankGetCdfGetPmfConsistency(t
*testing.T) {
}
func TestItemsSketch_Merge(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 10000
digits := numDigits(2 * n)
@@ -329,9 +329,9 @@ func TestItemsSketch_Merge(t *testing.T) {
}
func TestItemsSketch_MergeLowerK(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 10000
digits := numDigits(2 * n)
@@ -377,9 +377,9 @@ func TestItemsSketch_MergeLowerK(t *testing.T) {
}
func TestItemsSketch_MergeEmptyLowerK(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 10000
digits := numDigits(n)
@@ -438,9 +438,9 @@ func TestItemsSketch_MergeEmptyLowerK(t *testing.T) {
}
func TestItemsSketch_MergeExactModeLowerK(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch2, err := NewKllItemsSketch[string](_DEFAULT_K/2, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 10000
digits := numDigits(n)
@@ -456,9 +456,9 @@ func TestItemsSketch_MergeExactModeLowerK(t *testing.T) {
}
func TestItemsSketch_MergeMinMinValueFromOther(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
sketch1.Update(intToFixedLengthString(1, 1))
sketch2.Update(intToFixedLengthString(2, 1))
@@ -469,9 +469,9 @@ func TestItemsSketch_MergeMinMinValueFromOther(t
*testing.T) {
}
func TestItemsSketch_MergeMinAndMaxFromOther(t *testing.T) {
- sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
- sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch2, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 1_000_000
digits := numDigits(n)
@@ -488,12 +488,12 @@ func TestItemsSketch_MergeMinAndMaxFromOther(t
*testing.T) {
}
func TestItemsSketch_KTooSmall(t *testing.T) {
- _, err := NewKllItemsSketch[string](_MIN_K-1, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ _, err := NewKllItemsSketch[string](_MIN_K-1, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.Error(t, err)
}
func TestItemsSketch_MinK(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](uint16(8), _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](uint16(8), _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 1000
digits := numDigits(n)
@@ -510,7 +510,7 @@ func TestItemsSketch_MinK(t *testing.T) {
}
func TestItemsSketch_MaxK(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](uint16(_MAX_K), _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](uint16(_MAX_K), _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 1000
digits := numDigits(n)
@@ -527,7 +527,7 @@ func TestItemsSketch_MaxK(t *testing.T) {
}
func TestItemsSketch_OutOfOrderSplitPoints(t *testing.T) {
- sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
s0 := intToFixedLengthString(0, 1)
s1 := intToFixedLengthString(1, 1)
@@ -537,7 +537,7 @@ func TestItemsSketch_OutOfOrderSplitPoints(t *testing.T) {
}
func TestItemsSketch_DuplicateSplitPoints(t *testing.T) {
- sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sketch, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
sketch.Update("A")
sketch.Update("B")
@@ -552,7 +552,7 @@ func TestItemsSketch_DuplicateSplitPoints(t *testing.T) {
}
func TestItemsSketch_CheckReset(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 100
digits := numDigits(n)
@@ -579,7 +579,7 @@ func TestItemsSketch_CheckReset(t *testing.T) {
}
func TestItemsSketch_SortedView(t *testing.T) {
- sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sketch.Update("A")
sketch.Update("AB")
@@ -612,7 +612,7 @@ func TestItemsSketch_CDF_PDF(t *testing.T) {
pmfI := []float64{.25, .25, .25, .25, 0.0}
pmfE := []float64{0.0, .25, .25, .25, .25}
toll := 1e-10
- sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sketch, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
strIn := []string{"A", "AB", "ABC", "ABCD"}
for i := 0; i < len(strIn); i++ {
@@ -649,17 +649,17 @@ func TestItemsSketch_CDF_PDF(t *testing.T) {
}
func TestItemsSketch_DeserializeEmpty(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsSerDe{})
+ memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, memVal.sketchStructure, _COMPACT_EMPTY)
assert.Equal(t, len(mem), 8)
- sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsSerDe{})
+ sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, sk2.GetN(), uint64(0))
_, err = sk2.GetMinItem()
@@ -669,16 +669,16 @@ func TestItemsSketch_DeserializeEmpty(t *testing.T) {
}
func TestItemsSketch_DeserializeSingleItem(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sk1.Update("A")
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsSerDe{})
+ memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, memVal.sketchStructure, _COMPACT_SINGLE)
- sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsSerDe{})
+ sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, sk2.GetN(), uint64(1))
minV, err := sk2.GetMinItem()
@@ -690,7 +690,7 @@ func TestItemsSketch_DeserializeSingleItem(t *testing.T) {
}
func TestItemsSketch_FewItems(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sk1.Update("A")
sk1.Update("AB")
@@ -698,14 +698,14 @@ func TestItemsSketch_FewItems(t *testing.T) {
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsSerDe{})
+ memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, memVal.sketchStructure, _COMPACT_FULL)
assert.Equal(t, len(mem), memVal.sketchBytes)
}
func TestItemsSketch_ManyItems(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 109
digits := numDigits(n)
@@ -715,14 +715,14 @@ func TestItemsSketch_ManyItems(t *testing.T) {
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsSerDe{})
+ memVal, err := newItemsSketchMemoryValidate[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
assert.Equal(t, memVal.sketchStructure, _COMPACT_FULL)
assert.Equal(t, len(mem), memVal.sketchBytes)
}
func TestItemsSketch_SortedViewAfterReset(t *testing.T) {
- sk, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sk.Update("1")
sv, err := sk.GetSortedView()
@@ -736,12 +736,12 @@ func TestItemsSketch_SortedViewAfterReset(t *testing.T) {
}
func TestItemsSketch_SerializeDeserializeEmpty(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsSerDe{})
+ sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
s, err := sk1.GetSerializedSizeBytes()
assert.NoError(t, err)
@@ -765,13 +765,13 @@ func TestItemsSketch_SerializeDeserializeEmpty(t
*testing.T) {
}
func TestItemsSketch_SerializeDeserializeOneValue(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsSerDe{})
+ sk1, err := NewKllItemsSketch[string](20, _DEFAULT_M,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
sk1.Update(" 1")
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsSerDe{})
+ sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
s1SizeBytes, err := sk1.GetSerializedSizeBytes()
assert.Equal(t, len(mem), s1SizeBytes)
@@ -796,7 +796,7 @@ func TestItemsSketch_SerializeDeserializeOneValue(t
*testing.T) {
}
func TestItemsSketch_SerializeDeserializeMultipleValue(t *testing.T) {
- sk1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sk1, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
assert.NoError(t, err)
n := 1000
for i := 0; i < n; i++ {
@@ -811,7 +811,7 @@ func TestItemsSketch_SerializeDeserializeMultipleValue(t
*testing.T) {
mem, err := sk1.ToSlice()
assert.NoError(t, err)
assert.NotNil(t, mem)
- sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsSerDe{})
+ sk2, err := NewKllItemsSketchFromSlice[string](mem,
common.ArrayOfStringsOps{})
assert.NoError(t, err)
s1, err := sk2.GetSerializedSizeBytes()
assert.NoError(t, err)
@@ -835,7 +835,7 @@ func TestItemsSketch_SerializeDeserializeMultipleValue(t
*testing.T) {
func TestSerializeDeserializeString(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
- serde := common.ArrayOfStringsSerDe{}
+ serde := common.ArrayOfStringsOps{}
for _, n := range nArr {
digits := numDigits(n)
sk, err := NewKllItemsSketchWithDefault[string](serde)
@@ -889,7 +889,7 @@ func TestSerializeDeserializeString(t *testing.T) {
func TestSerializeDeserializeFloat(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
- serde := common.ArrayOfDoublesSerDe{}
+ serde := common.ArrayOfDoublesOps{}
for _, n := range nArr {
sk, err := NewKllItemsSketchWithDefault[float64](serde)
assert.NoError(t, err)
@@ -944,11 +944,11 @@ func TestSerializeDeserializeFloat(t *testing.T) {
// The issue is, during a merge, L0 must be sorted prior to a compaction to a
higher level.
// Otherwise the higher levels would not be sorted properly.
func TestL0SortDuringMerge(t *testing.T) {
- sk1, err := NewKllItemsSketch[string](8, _DEFAULT_M,
common.ArrayOfStringsSerDe{
+ sk1, err := NewKllItemsSketch[string](8, _DEFAULT_M,
common.ArrayOfStringsOps{
ReverseOrder: true,
})
assert.NoError(t, err)
- sk2, err := NewKllItemsSketch[string](8, _DEFAULT_M,
common.ArrayOfStringsSerDe{
+ sk2, err := NewKllItemsSketch[string](8, _DEFAULT_M,
common.ArrayOfStringsOps{
ReverseOrder: true,
})
assert.NoError(t, err)
diff --git a/kll/items_sletch_serialization_test.go
b/kll/items_sletch_serialization_test.go
index 83db088..7c61660 100644
--- a/kll/items_sletch_serialization_test.go
+++ b/kll/items_sletch_serialization_test.go
@@ -36,7 +36,7 @@ func TestGenerateGoFiles(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
for _, n := range nArr {
digits := numDigits(n)
- sk, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsSerDe{})
+ sk, err :=
NewKllItemsSketchWithDefault[string](common.ArrayOfStringsOps{})
sk.deterministicOffsetForTest = true
assert.NoError(t, err)
for i := 1; i <= n; i++ {
@@ -49,7 +49,7 @@ func TestGenerateGoFiles(t *testing.T) {
}
for _, n := range nArr {
- sk, err :=
NewKllItemsSketchWithDefault[float64](common.ArrayOfDoublesSerDe{})
+ sk, err :=
NewKllItemsSketchWithDefault[float64](common.ArrayOfDoublesOps{})
sk.deterministicOffsetForTest = true
assert.NoError(t, err)
for i := 1; i <= n; i++ {
@@ -65,7 +65,7 @@ func TestGenerateGoFiles(t *testing.T) {
func TestJavaCompat(t *testing.T) {
t.Run("Java KLL String", func(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
- serde := common.ArrayOfStringsSerDe{}
+ serde := common.ArrayOfStringsOps{}
for _, n := range nArr {
digits := numDigits(n)
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/kll_string_n%d_java.sk", internal.JavaPath, n))
@@ -113,7 +113,7 @@ func TestJavaCompat(t *testing.T) {
t.Run("Java KLL Double", func(t *testing.T) {
nArr := []int{0, 1, 10, 100, 1000, 10000, 100000, 1000000}
- serde := common.ArrayOfDoublesSerDe{}
+ serde := common.ArrayOfDoublesOps{}
for _, n := range nArr {
bytes, err :=
os.ReadFile(fmt.Sprintf("%s/kll_double_n%d_java.sk", internal.JavaPath, n))
assert.NoError(t, err)
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
