vec

package
v0.2.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2024 License: Apache-2.0 Imports: 14 Imported by: 0

Documentation

Overview

Copyright (c) 2020 Blockwatch Data Inc. Author: alex@blockwatch.cc

Index

Constants

This section is empty.

Variables

View Source 
var (
	ZeroInt128 = Int128{0, 0}
	OneInt128  = Int128{0, 1}
	MaxInt128  = Int128{0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}
	MinInt128  = Int128{0x8000000000000000, 0x0}
)
View Source 
var (
	ZeroInt256 = Int256{0, 0, 0, 0}
	OneInt256  = Int256{0, 0, 0, 1}
	MaxInt256  = Int256{0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF}
	MinInt256  = Int256{0x8000000000000000, 0x0, 0x0, 0x0}
)
View Source 
var Booleans = struct {
	Insert        func([]bool, int, ...bool) []bool
	Contains      func([]bool, bool) bool
	Index         func([]bool, bool, int) int
	MinMax        func([]bool) (bool, bool)
	ContainsRange func([]bool, bool, bool) bool
	Intersect     func([]bool, []bool, []bool) []bool
	MatchEqual    func([]bool, bool, *Bitset, *Bitset) *Bitset
}{
	Insert: func(s []bool, k int, v ...bool) []bool {
		return boolInsert(s, k, v...)
	},
	Contains: func(s []bool, v bool) bool {
		return boolContains(s, v)
	},
	Index: func(s []bool, v bool, last int) int {
		return boolIndex(s, v, last)
	},
	MinMax: func(s []bool) (bool, bool) {
		return boolMinMax(s)
	},
	ContainsRange: func(s []bool, from, to bool) bool {
		return boolContainsRange(s, from, to)
	},
	MatchEqual: func(s []bool, val bool, bits, mask *Bitset) *Bitset {
		return MatchBoolEqual(s, val, bits, mask)
	},
}
View Source 
var Bytes = struct {
	Sort          func([][]byte) [][]byte
	Unique        func([][]byte) [][]byte
	RemoveZeros   func([][]byte) [][]byte
	AddUnique     func([][]byte, []byte) [][]byte
	Insert        func([][]byte, int, ...[]byte) [][]byte
	Remove        func([][]byte, []byte) [][]byte
	Contains      func([][]byte, []byte) bool
	Index         func([][]byte, []byte, int) int
	MinMax        func([][]byte) ([]byte, []byte)
	ContainsRange func([][]byte, []byte, []byte) bool
	Intersect     func([][]byte, [][]byte, [][]byte) [][]byte
	MatchEqual    func([][]byte, []byte, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s [][]byte) [][]byte {
		return BytesSorter(s).Sort()
	},
	Unique: func(s [][]byte) [][]byte {
		return UniqueBytesSlice(s)
	},
	RemoveZeros: func(s [][]byte) [][]byte {
		s, _ = bytesRemoveZeros(s)
		return s
	},
	AddUnique: func(s [][]byte, v []byte) [][]byte {
		s, _ = bytesAddUnique(s, v)
		return s
	},
	Insert: func(s [][]byte, k int, v ...[]byte) [][]byte {
		return bytesInsert(s, k, v...)
	},
	Remove: func(s [][]byte, v []byte) [][]byte {
		s, _ = bytesRemove(s, v)
		return s
	},
	Contains: func(s [][]byte, v []byte) bool {
		return bytesContains(s, v)
	},
	Index: func(s [][]byte, v []byte, last int) int {
		return bytesIndex(s, v, last)
	},
	MinMax: func(s [][]byte) ([]byte, []byte) {
		return bytesMinMax(s)
	},
	ContainsRange: func(s [][]byte, from, to []byte) bool {
		return bytesContainsRange(s, from, to)
	},
	Intersect: func(x, y, out [][]byte) [][]byte {
		return IntersectSortedBytes(x, y, out)
	},
	MatchEqual: func(s [][]byte, val []byte, bits, mask *Bitset) *Bitset {
		return MatchBytesEqual(s, val, bits, mask)
	},
}
View Source 
var ErrInvalidNumber = errors.New("vec: invalid number")
View Source 
var Float32 = struct {
	Sort          func([]float32) []float32
	Unique        func([]float32) []float32
	RemoveZeros   func([]float32) []float32
	AddUnique     func([]float32, float32) []float32
	Insert        func([]float32, int, ...float32) []float32
	Remove        func([]float32, float32) []float32
	Contains      func([]float32, float32) bool
	Index         func([]float32, float32, int) int
	MinMax        func([]float32) (float32, float32)
	ContainsRange func([]float32, float32, float32) bool
	Intersect     func([]float32, []float32, []float32) []float32
	MatchEqual    func([]float32, float32, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []float32) []float32 {
		return Float32Sorter(s).Sort()
	},
	Unique: func(s []float32) []float32 {
		return UniqueFloat32Slice(s)
	},
	RemoveZeros: func(s []float32) []float32 {
		s, _ = float32RemoveZeros(s)
		return s
	},
	AddUnique: func(s []float32, v float32) []float32 {
		s, _ = float32AddUnique(s, v)
		return s
	},
	Insert: func(s []float32, k int, v ...float32) []float32 {
		return float32Insert(s, k, v...)
	},
	Remove: func(s []float32, v float32) []float32 {
		s, _ = float32Remove(s, v)
		return s
	},
	Contains: func(s []float32, v float32) bool {
		return float32Contains(s, v)
	},
	Index: func(s []float32, v float32, last int) int {
		return float32Index(s, v, last)
	},
	MinMax: func(s []float32) (float32, float32) {
		return float32MinMax(s)
	},
	ContainsRange: func(s []float32, from, to float32) bool {
		return float32ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []float32) []float32 {
		return IntersectSortedFloat32(x, y, out)
	},
	MatchEqual: func(s []float32, val float32, bits, mask *Bitset) *Bitset {
		return MatchFloat32Equal(s, val, bits, mask)
	},
}
View Source 
var Float64 = struct {
	Sort          func([]float64) []float64
	Unique        func([]float64) []float64
	RemoveZeros   func([]float64) []float64
	AddUnique     func([]float64, float64) []float64
	Insert        func([]float64, int, ...float64) []float64
	Remove        func([]float64, float64) []float64
	Contains      func([]float64, float64) bool
	Index         func([]float64, float64, int) int
	MinMax        func([]float64) (float64, float64)
	ContainsRange func([]float64, float64, float64) bool
	Intersect     func([]float64, []float64, []float64) []float64
	MatchEqual    func([]float64, float64, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []float64) []float64 {
		return Float64Sorter(s).Sort()
	},
	Unique: func(s []float64) []float64 {
		return UniqueFloat64Slice(s)
	},
	RemoveZeros: func(s []float64) []float64 {
		s, _ = float64RemoveZeros(s)
		return s
	},
	AddUnique: func(s []float64, v float64) []float64 {
		s, _ = float64AddUnique(s, v)
		return s
	},
	Insert: func(s []float64, k int, v ...float64) []float64 {
		return float64Insert(s, k, v...)
	},
	Remove: func(s []float64, v float64) []float64 {
		s, _ = float64Remove(s, v)
		return s
	},
	Contains: func(s []float64, v float64) bool {
		return float64Contains(s, v)
	},
	Index: func(s []float64, v float64, last int) int {
		return float64Index(s, v, last)
	},
	MinMax: func(s []float64) (float64, float64) {
		return float64MinMax(s)
	},
	ContainsRange: func(s []float64, from, to float64) bool {
		return float64ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []float64) []float64 {
		return IntersectSortedFloat64(x, y, out)
	},
	MatchEqual: func(s []float64, val float64, bits, mask *Bitset) *Bitset {
		return MatchFloat64Equal(s, val, bits, mask)
	},
}
View Source 
var Int16 = struct {
	Sort          func([]int16) []int16
	Unique        func([]int16) []int16
	RemoveZeros   func([]int16) []int16
	AddUnique     func([]int16, int16) []int16
	Insert        func([]int16, int, ...int16) []int16
	Remove        func([]int16, int16) []int16
	Contains      func([]int16, int16) bool
	Index         func([]int16, int16, int) int
	MinMax        func([]int16) (int16, int16)
	ContainsRange func([]int16, int16, int16) bool
	Intersect     func([]int16, []int16, []int16) []int16
	MatchEqual    func([]int16, int16, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []int16) []int16 {
		return Int16Sorter(s).Sort()
	},
	Unique: func(s []int16) []int16 {
		return UniqueInt16Slice(s)
	},
	RemoveZeros: func(s []int16) []int16 {
		s, _ = int16RemoveZeros(s)
		return s
	},
	AddUnique: func(s []int16, v int16) []int16 {
		s, _ = int16AddUnique(s, v)
		return s
	},
	Insert: func(s []int16, k int, v ...int16) []int16 {
		return int16Insert(s, k, v...)
	},
	Remove: func(s []int16, v int16) []int16 {
		s, _ = int16Remove(s, v)
		return s
	},
	Contains: func(s []int16, v int16) bool {
		return int16Contains(s, v)
	},
	Index: func(s []int16, v int16, last int) int {
		return int16Index(s, v, last)
	},
	MinMax: func(s []int16) (int16, int16) {
		return int16MinMax(s)
	},
	ContainsRange: func(s []int16, from, to int16) bool {
		return int16ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []int16) []int16 {
		return IntersectSortedInt16(x, y, out)
	},
	MatchEqual: func(s []int16, val int16, bits, mask *Bitset) *Bitset {
		return MatchInt16Equal(s, val, bits, mask)
	},
}
View Source 
var Int32 = struct {
	Sort          func([]int32) []int32
	Unique        func([]int32) []int32
	RemoveZeros   func([]int32) []int32
	AddUnique     func([]int32, int32) []int32
	Insert        func([]int32, int, ...int32) []int32
	Remove        func([]int32, int32) []int32
	Contains      func([]int32, int32) bool
	Index         func([]int32, int32, int) int
	MinMax        func([]int32) (int32, int32)
	ContainsRange func([]int32, int32, int32) bool
	Intersect     func([]int32, []int32, []int32) []int32
	MatchEqual    func([]int32, int32, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []int32) []int32 {
		return Int32Sorter(s).Sort()
	},
	Unique: func(s []int32) []int32 {
		return UniqueInt32Slice(s)
	},
	RemoveZeros: func(s []int32) []int32 {
		s, _ = int32RemoveZeros(s)
		return s
	},
	AddUnique: func(s []int32, v int32) []int32 {
		s, _ = int32AddUnique(s, v)
		return s
	},
	Insert: func(s []int32, k int, v ...int32) []int32 {
		return int32Insert(s, k, v...)
	},
	Remove: func(s []int32, v int32) []int32 {
		s, _ = int32Remove(s, v)
		return s
	},
	Contains: func(s []int32, v int32) bool {
		return int32Contains(s, v)
	},
	Index: func(s []int32, v int32, last int) int {
		return int32Index(s, v, last)
	},
	MinMax: func(s []int32) (int32, int32) {
		return int32MinMax(s)
	},
	ContainsRange: func(s []int32, from, to int32) bool {
		return int32ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []int32) []int32 {
		return IntersectSortedInt32(x, y, out)
	},
	MatchEqual: func(s []int32, val int32, bits, mask *Bitset) *Bitset {
		return MatchInt32Equal(s, val, bits, mask)
	},
}
View Source 
var Int64 = struct {
	Sort          func([]int64) []int64
	Unique        func([]int64) []int64
	RemoveZeros   func([]int64) []int64
	AddUnique     func([]int64, int64) []int64
	Insert        func([]int64, int, ...int64) []int64
	Remove        func([]int64, int64) []int64
	Contains      func([]int64, int64) bool
	Index         func([]int64, int64, int) int
	MinMax        func([]int64) (int64, int64)
	ContainsRange func([]int64, int64, int64) bool
	Intersect     func([]int64, []int64, []int64) []int64
	MatchEqual    func([]int64, int64, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []int64) []int64 {
		return Int64Sorter(s).Sort()
	},
	Unique: func(s []int64) []int64 {
		return UniqueInt64Slice(s)
	},
	RemoveZeros: func(s []int64) []int64 {
		s, _ = int64RemoveZeros(s)
		return s
	},
	AddUnique: func(s []int64, v int64) []int64 {
		s, _ = int64AddUnique(s, v)
		return s
	},
	Insert: func(s []int64, k int, v ...int64) []int64 {
		return int64Insert(s, k, v...)
	},
	Remove: func(s []int64, v int64) []int64 {
		s, _ = int64Remove(s, v)
		return s
	},
	Contains: func(s []int64, v int64) bool {
		return int64Contains(s, v)
	},
	Index: func(s []int64, v int64, last int) int {
		return int64Index(s, v, last)
	},
	MinMax: func(s []int64) (int64, int64) {
		return int64MinMax(s)
	},
	ContainsRange: func(s []int64, from, to int64) bool {
		return int64ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []int64) []int64 {
		return IntersectSortedInt64(x, y, out)
	},
	MatchEqual: func(s []int64, val int64, bits, mask *Bitset) *Bitset {
		return MatchInt64Equal(s, val, bits, mask)
	},
}
View Source 
var Int8 = struct {
	Sort          func([]int8) []int8
	Unique        func([]int8) []int8
	RemoveZeros   func([]int8) []int8
	AddUnique     func([]int8, int8) []int8
	Insert        func([]int8, int, ...int8) []int8
	Remove        func([]int8, int8) []int8
	Contains      func([]int8, int8) bool
	Index         func([]int8, int8, int) int
	MinMax        func([]int8) (int8, int8)
	ContainsRange func([]int8, int8, int8) bool
	Intersect     func([]int8, []int8, []int8) []int8
	MatchEqual    func([]int8, int8, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []int8) []int8 {
		return Int8Sorter(s).Sort()
	},
	Unique: func(s []int8) []int8 {
		return UniqueInt8Slice(s)
	},
	RemoveZeros: func(s []int8) []int8 {
		s, _ = int8RemoveZeros(s)
		return s
	},
	AddUnique: func(s []int8, v int8) []int8 {
		s, _ = int8AddUnique(s, v)
		return s
	},
	Insert: func(s []int8, k int, v ...int8) []int8 {
		return int8Insert(s, k, v...)
	},
	Remove: func(s []int8, v int8) []int8 {
		s, _ = int8Remove(s, v)
		return s
	},
	Contains: func(s []int8, v int8) bool {
		return int8Contains(s, v)
	},
	Index: func(s []int8, v int8, last int) int {
		return int8Index(s, v, last)
	},
	MinMax: func(s []int8) (int8, int8) {
		return int8MinMax(s)
	},
	ContainsRange: func(s []int8, from, to int8) bool {
		return int8ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []int8) []int8 {
		return IntersectSortedInt8(x, y, out)
	},
	MatchEqual: func(s []int8, val int8, bits, mask *Bitset) *Bitset {
		return MatchInt8Equal(s, val, bits, mask)
	},
}
View Source 
var Strings = struct {
	Sort          func([]string) []string
	Unique        func([]string) []string
	RemoveZeros   func([]string) []string
	AddUnique     func([]string, string) []string
	Insert        func([]string, int, ...string) []string
	Remove        func([]string, string) []string
	Contains      func([]string, string) bool
	Index         func([]string, string, int) int
	MinMax        func([]string) (string, string)
	ContainsRange func([]string, string, string) bool
	Intersect     func([]string, []string, []string) []string
	MatchEqual    func([]string, string, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []string) []string {
		return StringsSorter(s).Sort()
	},
	Unique: func(s []string) []string {
		return UniqueStringSlice(s)
	},
	RemoveZeros: func(s []string) []string {
		s, _ = stringRemoveZeros(s)
		return s
	},
	AddUnique: func(s []string, v string) []string {
		s, _ = stringAddUnique(s, v)
		return s
	},
	Insert: func(s []string, k int, v ...string) []string {
		return stringInsert(s, k, v...)
	},
	Remove: func(s []string, v string) []string {
		s, _ = stringRemove(s, v)
		return s
	},
	Contains: func(s []string, v string) bool {
		return stringContains(s, v)
	},
	Index: func(s []string, v string, last int) int {
		return stringIndex(s, v, last)
	},
	MinMax: func(s []string) (string, string) {
		return stringMinMax(s)
	},
	ContainsRange: func(s []string, from, to string) bool {
		return stringContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []string) []string {
		return IntersectSortedStrings(x, y, out)
	},
	MatchEqual: func(s []string, val string, bits, mask *Bitset) *Bitset {
		return MatchStringsEqual(s, val, bits, mask)
	},
}
View Source 
var Times = struct {
	Sort          func([]time.Time) []time.Time
	Unique        func([]time.Time) []time.Time
	RemoveZeros   func([]time.Time) []time.Time
	AddUnique     func([]time.Time, time.Time) []time.Time
	Remove        func([]time.Time, time.Time) []time.Time
	Contains      func([]time.Time, time.Time) bool
	Index         func([]time.Time, time.Time, int) int
	MinMax        func([]time.Time) (time.Time, time.Time)
	ContainsRange func([]time.Time, time.Time, time.Time) bool
	Intersect     func([]time.Time, []time.Time, []time.Time) []time.Time
	MatchEqual    func([]time.Time, time.Time, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []time.Time) []time.Time {
		return TimeSorter(s).Sort()
	},
	Unique: func(s []time.Time) []time.Time {
		return UniqueTimeSlice(s)
	},
	RemoveZeros: func(s []time.Time) []time.Time {
		s, _ = timeRemoveZeros(s)
		return s
	},
	AddUnique: func(s []time.Time, v time.Time) []time.Time {
		s, _ = timeAddUnique(s, v)
		return s
	},
	Remove: func(s []time.Time, v time.Time) []time.Time {
		s, _ = timeRemove(s, v)
		return s
	},
	Contains: func(s []time.Time, v time.Time) bool {
		return timeContains(s, v)
	},
	Index: func(s []time.Time, v time.Time, last int) int {
		return timeIndex(s, v, last)
	},
	MinMax: func(s []time.Time) (time.Time, time.Time) {
		return timeMinMax(s)
	},
	ContainsRange: func(s []time.Time, from, to time.Time) bool {
		return timeContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []time.Time) []time.Time {
		return IntersectSortedTime(x, y, out)
	},
	MatchEqual: func(s []time.Time, val time.Time, bits, mask *Bitset) *Bitset {
		return MatchTimeEqual(s, val, bits, mask)
	},
}
View Source 
var Uint16 = struct {
	Sort          func([]uint16) []uint16
	Unique        func([]uint16) []uint16
	RemoveZeros   func([]uint16) []uint16
	AddUnique     func([]uint16, uint16) []uint16
	Insert        func([]uint16, int, ...uint16) []uint16
	Remove        func([]uint16, uint16) []uint16
	Contains      func([]uint16, uint16) bool
	Index         func([]uint16, uint16, int) int
	MinMax        func([]uint16) (uint16, uint16)
	ContainsRange func([]uint16, uint16, uint16) bool
	Intersect     func([]uint16, []uint16, []uint16) []uint16
	MatchEqual    func([]uint16, uint16, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []uint16) []uint16 {
		return Uint16Sorter(s).Sort()
	},
	Unique: func(s []uint16) []uint16 {
		return UniqueUint16Slice(s)
	},
	RemoveZeros: func(s []uint16) []uint16 {
		s, _ = uint16RemoveZeros(s)
		return s
	},
	AddUnique: func(s []uint16, v uint16) []uint16 {
		s, _ = uint16AddUnique(s, v)
		return s
	},
	Insert: func(s []uint16, k int, v ...uint16) []uint16 {
		return uint16Insert(s, k, v...)
	},
	Remove: func(s []uint16, v uint16) []uint16 {
		s, _ = uint16Remove(s, v)
		return s
	},
	Contains: func(s []uint16, v uint16) bool {
		return uint16Contains(s, v)
	},
	Index: func(s []uint16, v uint16, last int) int {
		return uint16Index(s, v, last)
	},
	MinMax: func(s []uint16) (uint16, uint16) {
		return uint16MinMax(s)
	},
	ContainsRange: func(s []uint16, from, to uint16) bool {
		return uint16ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []uint16) []uint16 {
		return IntersectSortedUint16(x, y, out)
	},
	MatchEqual: func(s []uint16, val uint16, bits, mask *Bitset) *Bitset {
		return MatchUint16Equal(s, val, bits, mask)
	},
}
View Source 
var Uint32 = struct {
	Sort          func([]uint32) []uint32
	Unique        func([]uint32) []uint32
	RemoveZeros   func([]uint32) []uint32
	AddUnique     func([]uint32, uint32) []uint32
	Insert        func([]uint32, int, ...uint32) []uint32
	Remove        func([]uint32, uint32) []uint32
	Contains      func([]uint32, uint32) bool
	Index         func([]uint32, uint32, int) int
	MinMax        func([]uint32) (uint32, uint32)
	ContainsRange func([]uint32, uint32, uint32) bool
	Intersect     func([]uint32, []uint32, []uint32) []uint32
	MatchEqual    func([]uint32, uint32, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []uint32) []uint32 {
		return Uint32Sorter(s).Sort()
	},
	Unique: func(s []uint32) []uint32 {
		return UniqueUint32Slice(s)
	},
	RemoveZeros: func(s []uint32) []uint32 {
		s, _ = uint32RemoveZeros(s)
		return s
	},
	AddUnique: func(s []uint32, v uint32) []uint32 {
		s, _ = uint32AddUnique(s, v)
		return s
	},
	Insert: func(s []uint32, k int, v ...uint32) []uint32 {
		return uint32Insert(s, k, v...)
	},
	Remove: func(s []uint32, v uint32) []uint32 {
		s, _ = uint32Remove(s, v)
		return s
	},
	Contains: func(s []uint32, v uint32) bool {
		return uint32Contains(s, v)
	},
	Index: func(s []uint32, v uint32, last int) int {
		return uint32Index(s, v, last)
	},
	MinMax: func(s []uint32) (uint32, uint32) {
		return uint32MinMax(s)
	},
	ContainsRange: func(s []uint32, from, to uint32) bool {
		return uint32ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []uint32) []uint32 {
		return IntersectSortedUint32(x, y, out)
	},
	MatchEqual: func(s []uint32, val uint32, bits, mask *Bitset) *Bitset {
		return MatchUint32Equal(s, val, bits, mask)
	},
}
View Source 
var Uint64 = struct {
	Sort          func([]uint64) []uint64
	Unique        func([]uint64) []uint64
	RemoveZeros   func([]uint64) []uint64
	AddUnique     func([]uint64, uint64) []uint64
	Insert        func([]uint64, int, ...uint64) []uint64
	Remove        func([]uint64, uint64) []uint64
	Contains      func([]uint64, uint64) bool
	Index         func([]uint64, uint64, int) int
	MinMax        func([]uint64) (uint64, uint64)
	ContainsRange func([]uint64, uint64, uint64) bool
	Intersect     func([]uint64, []uint64, []uint64) []uint64
	MatchEqual    func([]uint64, uint64, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []uint64) []uint64 {
		return Uint64Sorter(s).Sort()
	},
	Unique: func(s []uint64) []uint64 {
		return UniqueUint64Slice(s)
	},
	RemoveZeros: func(s []uint64) []uint64 {
		s, _ = uint64RemoveZeros(s)
		return s
	},
	AddUnique: func(s []uint64, v uint64) []uint64 {
		s, _ = uint64AddUnique(s, v)
		return s
	},
	Insert: func(s []uint64, k int, v ...uint64) []uint64 {
		return uint64Insert(s, k, v...)
	},
	Remove: func(s []uint64, v uint64) []uint64 {
		s, _ = uint64Remove(s, v)
		return s
	},
	Contains: func(s []uint64, v uint64) bool {
		return uint64Contains(s, v)
	},
	Index: func(s []uint64, v uint64, last int) int {
		return uint64Index(s, v, last)
	},
	MinMax: func(s []uint64) (uint64, uint64) {
		return uint64MinMax(s)
	},
	ContainsRange: func(s []uint64, from, to uint64) bool {
		return uint64ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []uint64) []uint64 {
		if out == nil {
			out = make([]uint64, 0, max(len(x), len(y)))
		}
		return IntersectSortedUint64(x, y, out)
	},
	MatchEqual: func(s []uint64, val uint64, bits, mask *Bitset) *Bitset {
		return MatchUint64Equal(s, val, bits, mask)
	},
}
View Source 
var Uint8 = struct {
	Sort          func([]uint8) []uint8
	Unique        func([]uint8) []uint8
	RemoveZeros   func([]uint8) []uint8
	AddUnique     func([]uint8, uint8) []uint8
	Insert        func([]uint8, int, ...uint8) []uint8
	Remove        func([]uint8, uint8) []uint8
	Contains      func([]uint8, uint8) bool
	Index         func([]uint8, uint8, int) int
	MinMax        func([]uint8) (uint8, uint8)
	ContainsRange func([]uint8, uint8, uint8) bool
	Intersect     func([]uint8, []uint8, []uint8) []uint8
	MatchEqual    func([]uint8, uint8, *Bitset, *Bitset) *Bitset
}{
	Sort: func(s []uint8) []uint8 {
		return Uint8Sorter(s).Sort()
	},
	Unique: func(s []uint8) []uint8 {
		return UniqueUint8Slice(s)
	},
	RemoveZeros: func(s []uint8) []uint8 {
		s, _ = uint8RemoveZeros(s)
		return s
	},
	AddUnique: func(s []uint8, v uint8) []uint8 {
		s, _ = uint8AddUnique(s, v)
		return s
	},
	Insert: func(s []uint8, k int, v ...uint8) []uint8 {
		return uint8Insert(s, k, v...)
	},
	Remove: func(s []uint8, v uint8) []uint8 {
		s, _ = uint8Remove(s, v)
		return s
	},
	Contains: func(s []uint8, v uint8) bool {
		return uint8Contains(s, v)
	},
	Index: func(s []uint8, v uint8, last int) int {
		return uint8Index(s, v, last)
	},
	MinMax: func(s []uint8) (uint8, uint8) {
		return uint8MinMax(s)
	},
	ContainsRange: func(s []uint8, from, to uint8) bool {
		return uint8ContainsRange(s, from, to)
	},
	Intersect: func(x, y, out []uint8) []uint8 {
		return IntersectSortedUint8(x, y, out)
	},
	MatchEqual: func(s []uint8, val uint8, bits, mask *Bitset) *Bitset {
		return MatchUint8Equal(s, val, bits, mask)
	},
}

Functions

func Int128Compare 

func Int128Compare(a, b Int128) int

func Int256Compare 

func Int256Compare(a, b Int256) int

func IntersectSortedBytes 

func IntersectSortedBytes(x, y, out [][]byte) [][]byte

func IntersectSortedFloat32 

func IntersectSortedFloat32(x, y, out []float32) []float32

func IntersectSortedFloat64 

func IntersectSortedFloat64(x, y, out []float64) []float64

func IntersectSortedInt16 

func IntersectSortedInt16(x, y, out []int16) []int16

func IntersectSortedInt32 

func IntersectSortedInt32(x, y, out []int32) []int32

func IntersectSortedInt64 

func IntersectSortedInt64(x, y, out []int64) []int64

func IntersectSortedInt8 

func IntersectSortedInt8(x, y, out []int8) []int8

func IntersectSortedStrings 

func IntersectSortedStrings(x, y, out []string) []string

func IntersectSortedTime 

func IntersectSortedTime(x, y, out []time.Time) []time.Time

func IntersectSortedUint16 

func IntersectSortedUint16(x, y, out []uint16) []uint16

func IntersectSortedUint32 

func IntersectSortedUint32(x, y, out []uint32) []uint32

func IntersectSortedUint64 

func IntersectSortedUint64(x, y, out []uint64) []uint64

func IntersectSortedUint8 

func IntersectSortedUint8(x, y, out []uint8) []uint8

func TimeCompare 

func TimeCompare(a, b time.Time) int

func UniqueBytesSlice 

func UniqueBytesSlice(a [][]byte) [][]byte

func UniqueFloat32Slice 

func UniqueFloat32Slice(a []float32) []float32

func UniqueFloat64Slice 

func UniqueFloat64Slice(a []float64) []float64

func UniqueInt16Slice 

func UniqueInt16Slice(a []int16) []int16

func UniqueInt32Slice 

func UniqueInt32Slice(a []int32) []int32

func UniqueInt64Slice 

func UniqueInt64Slice(a []int64) []int64

func UniqueInt8Slice 

func UniqueInt8Slice(a []int8) []int8

func UniqueStringSlice 

func UniqueStringSlice(a []string) []string

func UniqueTimeSlice 

func UniqueTimeSlice(a []time.Time) []time.Time

func UniqueUint16Slice 

func UniqueUint16Slice(a []uint16) []uint16

func UniqueUint32Slice 

func UniqueUint32Slice(a []uint32) []uint32

func UniqueUint64Slice 

func UniqueUint64Slice(a []uint64) []uint64

func UniqueUint8Slice 

func UniqueUint8Slice(a []uint8) []uint8

Types

type Accuracy 

type Accuracy int8
const (
	Below Accuracy = -1
	Exact Accuracy = 0
	Above Accuracy = +1
)

func (Accuracy) String 

func (a Accuracy) String() string

type Bitset 

type Bitset struct {
	// contains filtered or unexported fields
}

func MatchBoolBetween 

func MatchBoolBetween(src []bool, a, b bool, bits, mask *Bitset) *Bitset

func MatchBoolEqual 

func MatchBoolEqual(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBoolGreaterThan 

func MatchBoolGreaterThan(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBoolGreaterThanEqual 

func MatchBoolGreaterThanEqual(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBoolLessThan 

func MatchBoolLessThan(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBoolLessThanEqual 

func MatchBoolLessThanEqual(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBoolNotEqual 

func MatchBoolNotEqual(src []bool, val bool, bits, mask *Bitset) *Bitset

func MatchBytesBetween 

func MatchBytesBetween(src [][]byte, a, b []byte, bits, mask *Bitset) *Bitset

func MatchBytesEqual 

func MatchBytesEqual(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchBytesGreaterThan 

func MatchBytesGreaterThan(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchBytesGreaterThanEqual 

func MatchBytesGreaterThanEqual(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchBytesLessThan 

func MatchBytesLessThan(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchBytesLessThanEqual 

func MatchBytesLessThanEqual(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchBytesNotEqual 

func MatchBytesNotEqual(src [][]byte, val []byte, bits, mask *Bitset) *Bitset

func MatchFloat32Between 

func MatchFloat32Between(src []float32, a, b float32, bits, mask *Bitset) *Bitset

func MatchFloat32Equal 

func MatchFloat32Equal(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat32GreaterThan 

func MatchFloat32GreaterThan(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat32GreaterThanEqual 

func MatchFloat32GreaterThanEqual(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat32LessThan 

func MatchFloat32LessThan(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat32LessThanEqual 

func MatchFloat32LessThanEqual(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat32NotEqual 

func MatchFloat32NotEqual(src []float32, val float32, bits, mask *Bitset) *Bitset

func MatchFloat64Between 

func MatchFloat64Between(src []float64, a, b float64, bits, mask *Bitset) *Bitset

func MatchFloat64Equal 

func MatchFloat64Equal(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchFloat64GreaterThan 

func MatchFloat64GreaterThan(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchFloat64GreaterThanEqual 

func MatchFloat64GreaterThanEqual(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchFloat64LessThan 

func MatchFloat64LessThan(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchFloat64LessThanEqual 

func MatchFloat64LessThanEqual(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchFloat64NotEqual 

func MatchFloat64NotEqual(src []float64, val float64, bits, mask *Bitset) *Bitset

func MatchInt128Between 

func MatchInt128Between(src Int128LLSlice, a, b Int128, bits, mask *Bitset) *Bitset

func MatchInt128Equal 

func MatchInt128Equal(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

Match helpers

func MatchInt128GreaterThan 

func MatchInt128GreaterThan(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

func MatchInt128GreaterThanEqual 

func MatchInt128GreaterThanEqual(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

func MatchInt128LessThan 

func MatchInt128LessThan(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

func MatchInt128LessThanEqual 

func MatchInt128LessThanEqual(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

func MatchInt128NotEqual 

func MatchInt128NotEqual(src Int128LLSlice, val Int128, bits, mask *Bitset) *Bitset

func MatchInt16Between 

func MatchInt16Between(src []int16, a, b int16, bits, mask *Bitset) *Bitset

func MatchInt16Equal 

func MatchInt16Equal(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt16GreaterThan 

func MatchInt16GreaterThan(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt16GreaterThanEqual 

func MatchInt16GreaterThanEqual(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt16LessThan 

func MatchInt16LessThan(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt16LessThanEqual 

func MatchInt16LessThanEqual(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt16NotEqual 

func MatchInt16NotEqual(src []int16, val int16, bits, mask *Bitset) *Bitset

func MatchInt256Between 

func MatchInt256Between(src Int256LLSlice, a, b Int256, bits, mask *Bitset) *Bitset

func MatchInt256Equal 

func MatchInt256Equal(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

Match helpers

func MatchInt256GreaterThan 

func MatchInt256GreaterThan(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

func MatchInt256GreaterThanEqual 

func MatchInt256GreaterThanEqual(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

func MatchInt256LessThan 

func MatchInt256LessThan(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

func MatchInt256LessThanEqual 

func MatchInt256LessThanEqual(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

func MatchInt256NotEqual 

func MatchInt256NotEqual(src Int256LLSlice, val Int256, bits, mask *Bitset) *Bitset

func MatchInt32Between 

func MatchInt32Between(src []int32, a, b int32, bits, mask *Bitset) *Bitset

func MatchInt32Equal 

func MatchInt32Equal(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt32GreaterThan 

func MatchInt32GreaterThan(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt32GreaterThanEqual 

func MatchInt32GreaterThanEqual(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt32LessThan 

func MatchInt32LessThan(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt32LessThanEqual 

func MatchInt32LessThanEqual(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt32NotEqual 

func MatchInt32NotEqual(src []int32, val int32, bits, mask *Bitset) *Bitset

func MatchInt64Between 

func MatchInt64Between(src []int64, a, b int64, bits, mask *Bitset) *Bitset

func MatchInt64Equal 

func MatchInt64Equal(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt64GreaterThan 

func MatchInt64GreaterThan(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt64GreaterThanEqual 

func MatchInt64GreaterThanEqual(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt64LessThan 

func MatchInt64LessThan(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt64LessThanEqual 

func MatchInt64LessThanEqual(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt64NotEqual 

func MatchInt64NotEqual(src []int64, val int64, bits, mask *Bitset) *Bitset

func MatchInt8Between 

func MatchInt8Between(src []int8, a, b int8, bits, mask *Bitset) *Bitset

func MatchInt8Equal 

func MatchInt8Equal(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchInt8GreaterThan 

func MatchInt8GreaterThan(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchInt8GreaterThanEqual 

func MatchInt8GreaterThanEqual(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchInt8LessThan 

func MatchInt8LessThan(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchInt8LessThanEqual 

func MatchInt8LessThanEqual(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchInt8NotEqual 

func MatchInt8NotEqual(src []int8, val int8, bits, mask *Bitset) *Bitset

func MatchStringsBetween 

func MatchStringsBetween(src []string, a, b string, bits, mask *Bitset) *Bitset

func MatchStringsEqual 

func MatchStringsEqual(src []string, val string, bits, mask *Bitset) *Bitset

func MatchStringsGreaterThan 

func MatchStringsGreaterThan(src []string, val string, bits, mask *Bitset) *Bitset

func MatchStringsGreaterThanEqual 

func MatchStringsGreaterThanEqual(src []string, val string, bits, mask *Bitset) *Bitset

func MatchStringsLessThan 

func MatchStringsLessThan(src []string, val string, bits, mask *Bitset) *Bitset

func MatchStringsLessThanEqual 

func MatchStringsLessThanEqual(src []string, val string, bits, mask *Bitset) *Bitset

func MatchStringsNotEqual 

func MatchStringsNotEqual(src []string, val string, bits, mask *Bitset) *Bitset

func MatchTimeBetween 

func MatchTimeBetween(src []time.Time, a, b time.Time, bits, mask *Bitset) *Bitset

func MatchTimeEqual 

func MatchTimeEqual(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchTimeGreaterThan 

func MatchTimeGreaterThan(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchTimeGreaterThanEqual 

func MatchTimeGreaterThanEqual(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchTimeLessThan 

func MatchTimeLessThan(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchTimeLessThanEqual 

func MatchTimeLessThanEqual(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchTimeNotEqual 

func MatchTimeNotEqual(src []time.Time, val time.Time, bits, mask *Bitset) *Bitset

func MatchUint16Between 

func MatchUint16Between(src []uint16, a, b uint16, bits, mask *Bitset) *Bitset

func MatchUint16Equal 

func MatchUint16Equal(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint16GreaterThan 

func MatchUint16GreaterThan(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint16GreaterThanEqual 

func MatchUint16GreaterThanEqual(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint16LessThan 

func MatchUint16LessThan(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint16LessThanEqual 

func MatchUint16LessThanEqual(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint16NotEqual 

func MatchUint16NotEqual(src []uint16, val uint16, bits, mask *Bitset) *Bitset

func MatchUint32Between 

func MatchUint32Between(src []uint32, a, b uint32, bits, mask *Bitset) *Bitset

func MatchUint32Equal 

func MatchUint32Equal(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint32GreaterThan 

func MatchUint32GreaterThan(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint32GreaterThanEqual 

func MatchUint32GreaterThanEqual(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint32LessThan 

func MatchUint32LessThan(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint32LessThanEqual 

func MatchUint32LessThanEqual(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint32NotEqual 

func MatchUint32NotEqual(src []uint32, val uint32, bits, mask *Bitset) *Bitset

func MatchUint64Between 

func MatchUint64Between(src []uint64, a, b uint64, bits, mask *Bitset) *Bitset

func MatchUint64Equal 

func MatchUint64Equal(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint64GreaterThan 

func MatchUint64GreaterThan(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint64GreaterThanEqual 

func MatchUint64GreaterThanEqual(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint64LessThan 

func MatchUint64LessThan(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint64LessThanEqual 

func MatchUint64LessThanEqual(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint64NotEqual 

func MatchUint64NotEqual(src []uint64, val uint64, bits, mask *Bitset) *Bitset

func MatchUint8Between 

func MatchUint8Between(src []uint8, a, b uint8, bits, mask *Bitset) *Bitset

func MatchUint8Equal 

func MatchUint8Equal(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func MatchUint8GreaterThan 

func MatchUint8GreaterThan(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func MatchUint8GreaterThanEqual 

func MatchUint8GreaterThanEqual(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func MatchUint8LessThan 

func MatchUint8LessThan(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func MatchUint8LessThanEqual 

func MatchUint8LessThanEqual(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func MatchUint8NotEqual 

func MatchUint8NotEqual(src []uint8, val uint8, bits, mask *Bitset) *Bitset

func NewBitset 

func NewBitset(size int) *Bitset

NewBitset allocates a new Bitset with a custom size and default capacity or 2<<16 bits (8kB). Call Close() to return the bitset after use. For efficiency an internal pool guarantees that bitsets of default capacity are reused. Changing the capacity with Grow() may make the Bitset uneligible for recycling.

func NewBitsetFromBytes 

func NewBitsetFromBytes(buf []byte, size int) *Bitset

NewBitsetFromBytes allocates a new bitset of size bits and copies the contents of `buf`. Buf may be nil and size must be >= zero.

func NewBitsetFromIndexes 

func NewBitsetFromIndexes(indexes []int, size int) *Bitset

NewBitsetFromIndexes allocates a new bitset and initializes it from integer positions representing one bits. If indeces is nil, the bitset is initially empty.

func NewBitsetFromSlice 

func NewBitsetFromSlice(bools []bool) *Bitset

NewBitsetFromSlice allocates a new bitset and initializes it from boolean values in bools. If bools is nil, the bitset is initially empty.

func NewBitsetFromString 

func NewBitsetFromString(s string, size int) *Bitset

NewBitsetFromSlice allocates a new bitset and initializes it from decoding a hex string. If s is empty or not a valid hex string, the bitset is initially empty.

func NewCustomBitset 

func NewCustomBitset(size int) *Bitset

NewCustomBitset allocates a new bitset of arbitrary small size and capacity without using a buffer pool. Use this function when your bitsets are always much smaller than the default capacity.

func (*Bitset) And 

func (s *Bitset) And(r *Bitset) *Bitset

func (*Bitset) AndFlag 

func (s *Bitset) AndFlag(r *Bitset) (*Bitset, bool, bool)

func (*Bitset) AndNot 

func (s *Bitset) AndNot(r *Bitset) *Bitset

func (*Bitset) Append 

func (s *Bitset) Append(src *Bitset, srcPos, srcLen int) *Bitset

Append grows the bitset by srcLen and appends srcLen values from src starting at position srcPos.

func (*Bitset) Bytes 

func (s *Bitset) Bytes() []byte

func (Bitset) Cap 

func (s Bitset) Cap() int

func (*Bitset) Clear 

func (s *Bitset) Clear(i int) *Bitset

func (*Bitset) Clone 

func (s *Bitset) Clone() *Bitset

func (*Bitset) Close 

func (s *Bitset) Close()

Close clears the bitset contents, sets its size to zero and returns it to the internal buffer pool. Using the bitset after calling Close is illegal.

func (*Bitset) Copy 

func (s *Bitset) Copy(b *Bitset) *Bitset

func (*Bitset) Count 

func (s *Bitset) Count() int

func (*Bitset) Delete 

func (s *Bitset) Delete(pos, n int) *Bitset

func (Bitset) EncodedSize 

func (s Bitset) EncodedSize() int

func (*Bitset) Fill 

func (s *Bitset) Fill(b byte) *Bitset

func (*Bitset) Grow 

func (s *Bitset) Grow(size int) *Bitset

Grow increases the bitset to a new size.

func (Bitset) HeapSize 

func (s Bitset) HeapSize() int

func (Bitset) Indexes 

func (s Bitset) Indexes(slice []int) []int

Indexes returns a slice of indexes for one bits in the bitset.

func (*Bitset) IndexesU32 

func (s *Bitset) IndexesU32(slice []uint32) []uint32

IndexesU32 returns a slice positions as uint32 for one bits in the bitset.

func (*Bitset) Insert 

func (s *Bitset) Insert(src *Bitset, srcPos, srcLen, dstPos int) *Bitset

Insert inserts srcLen values from position srcPos in bitset src into the bitset at position dstPos and moves all values following dstPos behind the newly inserted bits

func (*Bitset) IsSet 

func (s *Bitset) IsSet(i int) bool

func (Bitset) Len 

func (s Bitset) Len() int

func (Bitset) MarshalBinary 

func (s Bitset) MarshalBinary() ([]byte, error)

func (Bitset) MarshalText 

func (s Bitset) MarshalText() ([]byte, error)

func (*Bitset) Neg 

func (s *Bitset) Neg() *Bitset

func (*Bitset) One 

func (s *Bitset) One() *Bitset

func (*Bitset) Or 

func (s *Bitset) Or(r *Bitset) *Bitset

func (*Bitset) OrFlag 

func (s *Bitset) OrFlag(r *Bitset) (*Bitset, bool, bool)

func (*Bitset) Replace 

func (s *Bitset) Replace(src *Bitset, srcPos, srcLen, dstPos int) *Bitset

Replace replaces srcLen values at position dstPos with values from src bewteen position srcPos and srcPos + srcLen.

func (*Bitset) Reset 

func (s *Bitset) Reset() *Bitset

Reset clears the bitset contents and sets its size to zero.

func (*Bitset) ResetCount 

func (s *Bitset) ResetCount(n ...int)

func (*Bitset) Resize 

func (s *Bitset) Resize(size int) *Bitset

Resize resizes the bitset to a new size, either growing or shrinking it. Content remains unchanged on grow, when shrinking trailing bits are clipped.

func (*Bitset) Reverse 

func (s *Bitset) Reverse() *ReverseBitset

func (Bitset) Run 

func (b Bitset) Run(index int) (int, int)

Run returns the index and length of the next consecutive run of 1s in the bit vector starting at index. When no more 1s exist after index, -1 and a length of 0 is returned.

func (*Bitset) Set 

func (s *Bitset) Set(i int) *Bitset

func (*Bitset) SetFromBytes 

func (s *Bitset) SetFromBytes(buf []byte, size int) *Bitset

func (Bitset) Slice 

func (s Bitset) Slice() []bool

Slice returns a boolean slice containing all values

func (*Bitset) String 

func (s *Bitset) String() string

func (Bitset) SubSlice 

func (s Bitset) SubSlice(start, n int) []bool

func (*Bitset) Swap 

func (s *Bitset) Swap(i, j int)

func (*Bitset) UnmarshalBinary 

func (s *Bitset) UnmarshalBinary(data []byte) error

func (*Bitset) UnmarshalText 

func (s *Bitset) UnmarshalText(data []byte) error

func (*Bitset) Xor 

func (s *Bitset) Xor(r *Bitset) *Bitset

func (*Bitset) Zero 

func (s *Bitset) Zero() *Bitset

type BytesSorter 

type BytesSorter [][]byte

func (BytesSorter) Len 

func (s BytesSorter) Len() int

func (BytesSorter) Less 

func (s BytesSorter) Less(i, j int) bool

func (BytesSorter) Sort 

func (s BytesSorter) Sort() [][]byte

func (BytesSorter) Swap 

func (s BytesSorter) Swap(i, j int)

type Float32Sorter 

type Float32Sorter []float32

func (Float32Sorter) Len 

func (s Float32Sorter) Len() int

func (Float32Sorter) Less 

func (s Float32Sorter) Less(i, j int) bool

func (Float32Sorter) Sort 

func (s Float32Sorter) Sort() []float32

func (Float32Sorter) Swap 

func (s Float32Sorter) Swap(i, j int)

type Float64Reducer 

type Float64Reducer struct {
	// contains filtered or unexported fields
}

func (*Float64Reducer) Add 

func (b *Float64Reducer) Add(val float64)

func (*Float64Reducer) AddN 

func (b *Float64Reducer) AddN(val ...float64)

func (*Float64Reducer) AddSlice 

func (b *Float64Reducer) AddSlice(val []float64)

func (Float64Reducer) Len 

func (b Float64Reducer) Len() int

func (Float64Reducer) Max 

func (b Float64Reducer) Max() float64

func (Float64Reducer) Mean 

func (b Float64Reducer) Mean() float64

func (Float64Reducer) Min 

func (b Float64Reducer) Min() float64

func (Float64Reducer) Stddev 

func (b Float64Reducer) Stddev() float64

https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance

func (Float64Reducer) Sum 

func (b Float64Reducer) Sum() float64

func (Float64Reducer) Var 

func (b Float64Reducer) Var() float64

type Float64Sorter 

type Float64Sorter []float64

func (Float64Sorter) Len 

func (s Float64Sorter) Len() int

func (Float64Sorter) Less 

func (s Float64Sorter) Less(i, j int) bool

func (Float64Sorter) Sort 

func (s Float64Sorter) Sort() []float64

func (Float64Sorter) Swap 

func (s Float64Sorter) Swap(i, j int)

type Int128 

type Int128 [2]uint64

Big-Endian format [0] = Hi, [1] = Lo

func Int128From2Int64 

func Int128From2Int64(in0, in1 int64) Int128

func Int128FromBytes 

func Int128FromBytes(in []byte) Int128

func Int128FromInt64 

func Int128FromInt64(in int64) Int128

func IntersectSortedInt128 

func IntersectSortedInt128(x, y []Int128) []Int128

func Max128 

func Max128(x, y Int128) Int128

func Min128 

func Min128(x, y Int128) Int128

func MustParseInt128 

func MustParseInt128(s string) Int128

func NewInt128 

func NewInt128() Int128

func ParseInt128 

func ParseInt128(s string) (Int128, error)

func UniqueInt128Slice 

func UniqueInt128Slice(a []Int128) []Int128

func (Int128) Abs 

func (x Int128) Abs() Int128

Abs interprets x as a two's complement signed number, and returns its absolute value 

Abs(0)        = 0
Abs(1)        = 1
Abs(2**127)   = -2**127
Abs(2**128-1) = -1

func (Int128) Add 

func (x Int128) Add(y Int128) Int128

Add returns the sum x+y

func (Int128) Add64 

func (x Int128) Add64(y uint64) (z Int128)

func (Int128) Add64Overflow 

func (x Int128) Add64Overflow(y uint64) (Int128, bool)

func (Int128) AddOverflow 

func (x Int128) AddOverflow(y Int128) (Int128, bool)

AddOverflow returns the sum x+y, and returns whether overflow occurred

func (Int128) And 

func (x Int128) And(y Int128) Int128

func (Int128) BitLen 

func (x Int128) BitLen() int

BitLen returns the number of bits required to represent x

func (Int128) Bytes 

func (x Int128) Bytes() []byte

func (Int128) Bytes16 

func (x Int128) Bytes16() [16]byte

func (Int128) Cmp 

func (x Int128) Cmp(y Int128) int

func (Int128) Div 

func (n Int128) Div(d Int128) Int128

func (Int128) Div64 

func (n Int128) Div64(d int64) Int128

Div64 returns u/v.

func (Int128) Eq 

func (x Int128) Eq(y Int128) bool

func (Int128) Float64 

func (x Int128) Float64() float64

func (Int128) Gt 

func (x Int128) Gt(y Int128) bool

func (Int128) Gte 

func (x Int128) Gte(y Int128) bool

func (Int128) Int256 

func (x Int128) Int256() Int256

func (Int128) Int64 

func (x Int128) Int64() int64

func (Int128) IsInt64 

func (x Int128) IsInt64() bool

IsInt64 reports whether x can be represented as a int64.

func (Int128) IsZero 

func (x Int128) IsZero() bool

IsZero returns true if x == 0

func (Int128) Lsh 

func (x Int128) Lsh(n uint) Int128

Lsh returns u<<n.

func (Int128) Lt 

func (x Int128) Lt(y Int128) bool

func (Int128) Lte 

func (x Int128) Lte(y Int128) bool

func (Int128) MarshalText 

func (x Int128) MarshalText() ([]byte, error)

func (Int128) Mul 

func (x Int128) Mul(y Int128) (z Int128)

Mul returns x*y with wraparound semantics,

func (Int128) Mul64 

func (x Int128) Mul64(y int64) (z Int128)

Mul64 returns x*y.

func (Int128) Mul64Overflow 

func (x Int128) Mul64Overflow(y int64) (Int128, bool)

func (Int128) MulOverflow 

func (x Int128) MulOverflow(y Int128) (Int128, bool)

func (Int128) Neg 

func (x Int128) Neg() Int128

Neg returns -x mod 2**128.

func (Int128) Not 

func (x Int128) Not() Int128

Not sets z = ^x and returns z.

func (Int128) Or 

func (x Int128) Or(y Int128) Int128

func (Int128) Precision 

func (x Int128) Precision() int

func (Int128) QuoRem 

func (n Int128) QuoRem(d Int128) (Int128, Int128)

func (Int128) Rsh 

func (x Int128) Rsh(n uint) Int128

Rsh returns u>>n.

func (*Int128) SetFloat64 

func (x *Int128) SetFloat64(y float64) Accuracy

func (*Int128) SetInt64 

func (x *Int128) SetInt64(y int64)

func (Int128) Sign 

func (x Int128) Sign() int

Sign returns: 

-1 if x <  0
 0 if x == 0
+1 if x >  0

Where x is interpreted as a two's complement signed number

func (Int128) String 

func (x Int128) String() string

func (Int128) Sub 

func (x Int128) Sub(y Int128) Int128

Sub returns the difference x-y

func (Int128) Sub64 

func (x Int128) Sub64(y uint64) Int128

Sub64 returns the difference x - y, where y is a uint64

func (Int128) SubOverflow 

func (x Int128) SubOverflow(y Int128) (Int128, bool)

SubOverflow returns the difference x-y and returns true if the operation underflowed

func (*Int128) UnmarshalText 

func (x *Int128) UnmarshalText(buf []byte) error

func (Int128) Xor 

func (x Int128) Xor(y Int128) Int128

type Int128LLSlice 

type Int128LLSlice struct {
	X0 []int64
	X1 []uint64
}

represents a Int128 slice in two strides for higher and lower qword used for vector match algorithms

func MakeInt128LLSlice 

func MakeInt128LLSlice(sz int) Int128LLSlice

func (*Int128LLSlice) Append 

func (s *Int128LLSlice) Append(val Int128) Int128LLSlice

func (*Int128LLSlice) AppendFrom 

func (dst *Int128LLSlice) AppendFrom(src Int128LLSlice) Int128LLSlice

func (Int128LLSlice) Cap 

func (s Int128LLSlice) Cap() int

func (Int128LLSlice) Copy 

func (dst Int128LLSlice) Copy(src Int128LLSlice, dstPos, srcPos, n int)

func (*Int128LLSlice) Delete 

func (dst *Int128LLSlice) Delete(pos, n int) Int128LLSlice

func (Int128LLSlice) Elem 

func (s Int128LLSlice) Elem(i int) Int128

func (*Int128LLSlice) Insert 

func (s *Int128LLSlice) Insert(k int, vs Int128LLSlice)

func (Int128LLSlice) IsNil 

func (s Int128LLSlice) IsNil() bool

func (Int128LLSlice) Len 

func (s Int128LLSlice) Len() int

func (Int128LLSlice) Materialize 

func (s Int128LLSlice) Materialize() []Int128

func (Int128LLSlice) MinMax 

func (s Int128LLSlice) MinMax() (Int128, Int128)

func (Int128LLSlice) Set 

func (s Int128LLSlice) Set(i int, val Int128)

func (Int128LLSlice) Subslice 

func (s Int128LLSlice) Subslice(start, end int) Int128LLSlice

func (Int128LLSlice) Swap 

func (s Int128LLSlice) Swap(i, j int)

func (Int128LLSlice) Tail 

func (s Int128LLSlice) Tail(start int) Int128LLSlice

type Int128Slice 

type Int128Slice []Int128

func (*Int128Slice) AddUnique 

func (s *Int128Slice) AddUnique(val Int128) bool

func (Int128Slice) Contains 

func (s Int128Slice) Contains(val Int128) bool

func (Int128Slice) ContainsRange 

func (s Int128Slice) ContainsRange(from, to Int128) bool

ContainsRange returns true when slice s contains any values between from and to. Note that from/to do not necessarily have to be members themselves, but some intermediate values are. Slice s is expected to be sorted and from must be less than or equal to to.

func (Int128Slice) Index 

func (s Int128Slice) Index(val Int128, last int) int

func (*Int128Slice) Insert 

func (s *Int128Slice) Insert(k int, vs ...Int128)

func (Int128Slice) Intersect 

func (s Int128Slice) Intersect(x, out Int128Slice) Int128Slice

func (Int128Slice) Len 

func (s Int128Slice) Len() int

func (Int128Slice) Less 

func (s Int128Slice) Less(i, j int) bool

func (Int128Slice) MatchEqual 

func (s Int128Slice) MatchEqual(val Int128, bits, mask *Bitset) *Bitset

func (Int128Slice) MinMax 

func (s Int128Slice) MinMax() (Int128, Int128)

func (Int128Slice) Optimize 

func (s Int128Slice) Optimize() Int128LLSlice

func (*Int128Slice) Remove 

func (s *Int128Slice) Remove(val Int128) bool

func (*Int128Slice) RemoveZeros 

func (s *Int128Slice) RemoveZeros() int

func (Int128Slice) Sort 

func (s Int128Slice) Sort() Int128Slice

func (Int128Slice) Swap 

func (s Int128Slice) Swap(i, j int)

func (*Int128Slice) Unique 

func (s *Int128Slice) Unique()

type Int128Sorter 

type Int128Sorter []Int128

func (Int128Sorter) Len 

func (s Int128Sorter) Len() int

func (Int128Sorter) Less 

func (s Int128Sorter) Less(i, j int) bool

func (Int128Sorter) Sort 

func (s Int128Sorter) Sort()

func (Int128Sorter) Swap 

func (s Int128Sorter) Swap(i, j int)

type Int16Sorter 

type Int16Sorter []int16

func (Int16Sorter) Len 

func (s Int16Sorter) Len() int

func (Int16Sorter) Less 

func (s Int16Sorter) Less(i, j int) bool

func (Int16Sorter) Sort 

func (s Int16Sorter) Sort() []int16

func (Int16Sorter) Swap 

func (s Int16Sorter) Swap(i, j int)

type Int256 

type Int256 [4]uint64

Big-Endian format [0] = Hi .. [3] = Lo

func Int256From2Int64 

func Int256From2Int64(in0, in1 int64) Int256

func Int256FromBytes 

func Int256FromBytes(in []byte) Int256

func Int256FromInt128 

func Int256FromInt128(in Int128) Int256

func Int256FromInt64 

func Int256FromInt64(in int64) Int256

func IntersectSortedInt256 

func IntersectSortedInt256(x, y []Int256) []Int256

func Max256 

func Max256(x, y Int256) Int256

func Min256 

func Min256(x, y Int256) Int256

func MustParseInt256 

func MustParseInt256(s string) Int256

func NewInt256 

func NewInt256() Int256

func ParseInt256 

func ParseInt256(s string) (Int256, error)

func UniqueInt256Slice 

func UniqueInt256Slice(a []Int256) []Int256

func (Int256) Abs 

func (x Int256) Abs() Int256

Abs interprets x as a two's complement signed number, and returns its absolute value 

Abs(0)        = 0
Abs(1)        = 1
Abs(2**255)   = -2**255
Abs(2**256-1) = -1

func (Int256) Add 

func (x Int256) Add(y Int256) (z Int256)

Add returns the sum x+y

func (Int256) Add64 

func (x Int256) Add64(y uint64) (z Int256)

func (Int256) AddOverflow 

func (x Int256) AddOverflow(y Int256) (Int256, bool)

AddOverflow returns the sum x+y, and returns whether overflow occurred

func (Int256) And 

func (x Int256) And(y Int256) Int256

func (Int256) BitLen 

func (x Int256) BitLen() int

BitLen returns the number of bits required to represent z

func (Int256) Bytes 

func (x Int256) Bytes() []byte

func (Int256) Bytes32 

func (x Int256) Bytes32() [32]byte

func (Int256) Cmp 

func (x Int256) Cmp(y Int256) int

func (Int256) Div 

func (n Int256) Div(d Int256) Int256

FIXME: IEEE 754-2008 roundTiesToEven

Div interprets n and d as two's complement signed integers, does a signed division on the two operands. If d == 0, returns 0

func (Int256) Eq 

func (x Int256) Eq(y Int256) bool

func (Int256) Float64 

func (x Int256) Float64() float64

func (Int256) Gt 

func (x Int256) Gt(y Int256) bool

func (Int256) Gte 

func (x Int256) Gte(y Int256) bool

func (Int256) Int128 

func (x Int256) Int128() Int128

func (Int256) Int64 

func (x Int256) Int64() int64

func (Int256) IsInt64 

func (x Int256) IsInt64() bool

IsInt64 reports whether x can be represented as a int64.

func (Int256) IsZero 

func (x Int256) IsZero() bool

IsZero returns true if x == 0

func (Int256) Lsh 

func (x Int256) Lsh(n uint) Int256

Lsh returns x << n.

func (Int256) Lt 

func (x Int256) Lt(y Int256) bool

func (Int256) Lte 

func (x Int256) Lte(y Int256) bool

func (Int256) MarshalText 

func (x Int256) MarshalText() ([]byte, error)

func (Int256) Mod 

func (x Int256) Mod(y Int256) Int256

Mod returns the modulus x%y for y != 0. If y == 0, returns 0. OBS: differs from other math libraries

func (Int256) Mul 

func (x Int256) Mul(y Int256) Int256

Mul returns the product x*y

func (Int256) Neg 

func (x Int256) Neg() Int256

Neg returns -x mod 2**256.

func (Int256) Not 

func (x Int256) Not() Int256

Not returns ^x.

func (Int256) Or 

func (x Int256) Or(y Int256) Int256

func (Int256) Precision 

func (x Int256) Precision() int

func (Int256) QuoRem 

func (x Int256) QuoRem(y Int256) (Int256, Int256)

func (Int256) Rsh 

func (x Int256) Rsh(n uint) Int256

SRsh (Signed/Arithmetic right shift) considers z to be a signed integer, during right-shift and returns x >> n.

func (*Int256) SetFloat64 

func (x *Int256) SetFloat64(y float64) Accuracy

func (*Int256) SetInt128 

func (x *Int256) SetInt128(y Int128)

func (*Int256) SetInt64 

func (x *Int256) SetInt64(y int64)

func (Int256) Sign 

func (x Int256) Sign() int

Sign returns: 

-1 if x <  0
 0 if x == 0
+1 if x >  0

Where x is interpreted as a two's complement signed number

func (Int256) String 

func (x Int256) String() string

func (Int256) Sub 

func (x Int256) Sub(y Int256) Int256

Sub returns the difference x-y

func (Int256) Sub64 

func (x Int256) Sub64(y uint64) Int256

Sub64 returns the difference x - y, where y is a uint64

func (Int256) SubOverflow 

func (x Int256) SubOverflow(y Int256) (Int256, bool)

SubOverflow returns the difference x-y and returns true if the operation underflowed

func (Int256) Uint256 

func (x Int256) Uint256() Uint256

func (*Int256) UnmarshalText 

func (x *Int256) UnmarshalText(buf []byte) error

func (Int256) Xor 

func (x Int256) Xor(y Int256) Int256

type Int256LLSlice 

type Int256LLSlice struct {
	X0 []int64
	X1 []uint64
	X2 []uint64
	X3 []uint64
}

represents a Int256 slice in four strides fom highest to lowest qword used for vector match algorithms

func MakeInt256LLSlice 

func MakeInt256LLSlice(sz int) Int256LLSlice

func (*Int256LLSlice) Append 

func (s *Int256LLSlice) Append(val Int256) Int256LLSlice

func (*Int256LLSlice) AppendFrom 

func (dst *Int256LLSlice) AppendFrom(src Int256LLSlice) Int256LLSlice

func (Int256LLSlice) Cap 

func (s Int256LLSlice) Cap() int

func (Int256LLSlice) Copy 

func (dst Int256LLSlice) Copy(src Int256LLSlice, dstPos, srcPos, n int)

func (*Int256LLSlice) Delete 

func (dst *Int256LLSlice) Delete(pos, n int) Int256LLSlice

func (Int256LLSlice) Elem 

func (s Int256LLSlice) Elem(i int) Int256

func (*Int256LLSlice) Insert 

func (s *Int256LLSlice) Insert(k int, vs Int256LLSlice)

func (Int256LLSlice) IsNil 

func (s Int256LLSlice) IsNil() bool

func (Int256LLSlice) Len 

func (s Int256LLSlice) Len() int

func (Int256LLSlice) Materialize 

func (s Int256LLSlice) Materialize() []Int256

func (Int256LLSlice) MinMax 

func (s Int256LLSlice) MinMax() (Int256, Int256)

func (Int256LLSlice) Set 

func (s Int256LLSlice) Set(i int, val Int256)

func (Int256LLSlice) Subslice 

func (s Int256LLSlice) Subslice(start, end int) Int256LLSlice

func (Int256LLSlice) Swap 

func (s Int256LLSlice) Swap(i, j int)

func (Int256LLSlice) Tail 

func (s Int256LLSlice) Tail(start int) Int256LLSlice

type Int256Slice 

type Int256Slice []Int256

func (*Int256Slice) AddUnique 

func (s *Int256Slice) AddUnique(val Int256) bool

func (Int256Slice) Contains 

func (s Int256Slice) Contains(val Int256) bool

func (Int256Slice) ContainsRange 

func (s Int256Slice) ContainsRange(from, to Int256) bool

ContainsRange returns true when slice s contains any values between from and to. Note that from/to do not necessarily have to be members themselves, but some intermediate values are. Slice s is expected to be sorted and from must be less than or equal to to.

func (Int256Slice) Index 

func (s Int256Slice) Index(val Int256, last int) int

func (*Int256Slice) Insert 

func (s *Int256Slice) Insert(k int, vs ...Int256)

func (Int256Slice) Intersect 

func (s Int256Slice) Intersect(x, out Int256Slice) Int256Slice

func (Int256Slice) Len 

func (s Int256Slice) Len() int

func (Int256Slice) Less 

func (s Int256Slice) Less(i, j int) bool

func (Int256Slice) MatchEqual 

func (s Int256Slice) MatchEqual(val Int256, bits, mask *Bitset) *Bitset

func (Int256Slice) MinMax 

func (s Int256Slice) MinMax() (Int256, Int256)

func (Int256Slice) Optimize 

func (s Int256Slice) Optimize() Int256LLSlice

func (*Int256Slice) Remove 

func (s *Int256Slice) Remove(val Int256) bool

func (Int256Slice) Sort 

func (s Int256Slice) Sort() Int256Slice

func (Int256Slice) Swap 

func (s Int256Slice) Swap(i, j int)

func (*Int256Slice) Unique 

func (s *Int256Slice) Unique()

type Int256Sorter 

type Int256Sorter []Int256

func (Int256Sorter) Len 

func (s Int256Sorter) Len() int

func (Int256Sorter) Less 

func (s Int256Sorter) Less(i, j int) bool

func (Int256Sorter) Sort 

func (s Int256Sorter) Sort()

func (Int256Sorter) Swap 

func (s Int256Sorter) Swap(i, j int)

type Int32Sorter 

type Int32Sorter []int32

func (Int32Sorter) Len 

func (s Int32Sorter) Len() int

func (Int32Sorter) Less 

func (s Int32Sorter) Less(i, j int) bool

func (Int32Sorter) Sort 

func (s Int32Sorter) Sort() []int32

func (Int32Sorter) Swap 

func (s Int32Sorter) Swap(i, j int)

type Int64Reducer 

type Int64Reducer struct {
	// contains filtered or unexported fields
}

func (*Int64Reducer) Add 

func (b *Int64Reducer) Add(val int64)

func (*Int64Reducer) AddN 

func (b *Int64Reducer) AddN(val ...int64)

func (*Int64Reducer) AddSlice 

func (b *Int64Reducer) AddSlice(val []int64)

func (Int64Reducer) Len 

func (b Int64Reducer) Len() int

func (Int64Reducer) Max 

func (b Int64Reducer) Max() int64

func (Int64Reducer) Mean 

func (b Int64Reducer) Mean() float64

func (Int64Reducer) Min 

func (b Int64Reducer) Min() int64

func (Int64Reducer) Stddev 

func (b Int64Reducer) Stddev() float64

https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance

func (Int64Reducer) Sum 

func (b Int64Reducer) Sum() int64

func (Int64Reducer) Var 

func (b Int64Reducer) Var() float64

type Int64Sorter 

type Int64Sorter []int64

func (Int64Sorter) Len 

func (s Int64Sorter) Len() int

func (Int64Sorter) Less 

func (s Int64Sorter) Less(i, j int) bool

func (Int64Sorter) Sort 

func (s Int64Sorter) Sort() []int64

func (Int64Sorter) Swap 

func (s Int64Sorter) Swap(i, j int)

type Int8Sorter 

type Int8Sorter []int8

func (Int8Sorter) Len 

func (s Int8Sorter) Len() int

func (Int8Sorter) Less 

func (s Int8Sorter) Less(i, j int) bool

func (Int8Sorter) Sort 

func (s Int8Sorter) Sort() []int8

func (Int8Sorter) Swap 

func (s Int8Sorter) Swap(i, j int)

type ReverseBitset 

type ReverseBitset struct {
	// contains filtered or unexported fields
}

func (*ReverseBitset) Bytes 

func (r *ReverseBitset) Bytes() []byte

func (ReverseBitset) Cap 

func (r ReverseBitset) Cap() int

func (*ReverseBitset) Close 

func (r *ReverseBitset) Close()

func (*ReverseBitset) Count 

func (r *ReverseBitset) Count() int

func (ReverseBitset) Len 

func (r ReverseBitset) Len() int

func (ReverseBitset) Run 

func (b ReverseBitset) Run(index int) (int, int)

Runs through an reversed bitset. You have to reverse it yourself with Reverse function. returns the index and length of the next consecutive run of 1s in the bit vector starting at index. When no more 1s exist after index, -1 and a length of 0 is returned.

type StringsSorter 

type StringsSorter []string

func (StringsSorter) Len 

func (s StringsSorter) Len() int

func (StringsSorter) Less 

func (s StringsSorter) Less(i, j int) bool

func (StringsSorter) Sort 

func (s StringsSorter) Sort() []string

func (StringsSorter) Swap 

func (s StringsSorter) Swap(i, j int)

type TimeSorter 

type TimeSorter []time.Time

func (TimeSorter) Len 

func (s TimeSorter) Len() int

func (TimeSorter) Less 

func (s TimeSorter) Less(i, j int) bool

func (TimeSorter) Sort 

func (s TimeSorter) Sort() []time.Time

func (TimeSorter) Swap 

func (s TimeSorter) Swap(i, j int)

type TopFloat64Heap 

type TopFloat64Heap struct {
	// contains filtered or unexported fields
}

func NewTopFloat64Heap 

func NewTopFloat64Heap(size int) *TopFloat64Heap

func (*TopFloat64Heap) Add 

func (h *TopFloat64Heap) Add(val float64)

func (*TopFloat64Heap) Calls 

func (h *TopFloat64Heap) Calls() uint64

func (*TopFloat64Heap) Gini 

func (h *TopFloat64Heap) Gini() float64

based on https://en.wikipedia.org/wiki/Gini_coefficient (alternate expressions, 2nd formula)

func (*TopFloat64Heap) GiniCapped 

func (h *TopFloat64Heap) GiniCapped(cutoff float64) float64

func (TopFloat64Heap) Len 

func (h TopFloat64Heap) Len() int

func (TopFloat64Heap) Less 

func (h TopFloat64Heap) Less(i, j int) bool

func (*TopFloat64Heap) Pop 

func (h *TopFloat64Heap) Pop() interface{}

func (*TopFloat64Heap) Push 

func (h *TopFloat64Heap) Push(x interface{})

func (*TopFloat64Heap) Sum 

func (h *TopFloat64Heap) Sum() float64

func (*TopFloat64Heap) SumN 

func (h *TopFloat64Heap) SumN(n int) float64

func (TopFloat64Heap) Swap 

func (h TopFloat64Heap) Swap(i, j int)

func (*TopFloat64Heap) TopN 

func (h *TopFloat64Heap) TopN(n int) []float64

func (*TopFloat64Heap) Total 

func (h *TopFloat64Heap) Total() float64

type TopHeap 

type TopHeap struct {
	// contains filtered or unexported fields
}

func NewTopHeap 

func NewTopHeap(size int) *TopHeap

func (*TopHeap) Add 

func (h *TopHeap) Add(x Topable)

func (*TopHeap) AddMap 

func (h *TopHeap) AddMap(m map[string]int)

func (*TopHeap) Calls 

func (h *TopHeap) Calls() int

func (*TopHeap) Gini 

func (h *TopHeap) Gini() float64

based on https://en.wikipedia.org/wiki/Gini_coefficient (alternate expressions, 2nd formula)

func (*TopHeap) GiniCapped 

func (h *TopHeap) GiniCapped(cutoff int) float64

func (TopHeap) Len 

func (h TopHeap) Len() int

func (TopHeap) Less 

func (h TopHeap) Less(i, j int) bool

func (*TopHeap) Pop 

func (h *TopHeap) Pop() interface{}

func (*TopHeap) Push 

func (h *TopHeap) Push(x interface{})

func (*TopHeap) Sum 

func (h *TopHeap) Sum() int

func (*TopHeap) SumN 

func (h *TopHeap) SumN(n int) int

func (TopHeap) Swap 

func (h TopHeap) Swap(i, j int)

func (*TopHeap) TopN 

func (h *TopHeap) TopN(n int) []Topable

func (*TopHeap) Total 

func (h *TopHeap) Total() int

type TopItem 

type TopItem struct {
	// contains filtered or unexported fields
}

func (TopItem) Label 

func (t TopItem) Label() string

func (TopItem) Value 

func (t TopItem) Value() int

type TopUint64Heap 

type TopUint64Heap struct {
	// contains filtered or unexported fields
}

func NewTopUint64Heap 

func NewTopUint64Heap(size int) *TopUint64Heap

func (*TopUint64Heap) Add 

func (h *TopUint64Heap) Add(val uint64)

func (*TopUint64Heap) Calls 

func (h *TopUint64Heap) Calls() uint64

func (*TopUint64Heap) Gini 

func (h *TopUint64Heap) Gini() float64

based on https://en.wikipedia.org/wiki/Gini_coefficient (alternate expressions, 2nd formula)

func (*TopUint64Heap) GiniCapped 

func (h *TopUint64Heap) GiniCapped(cutoff uint64) float64

func (TopUint64Heap) Len 

func (h TopUint64Heap) Len() int

func (TopUint64Heap) Less 

func (h TopUint64Heap) Less(i, j int) bool

func (*TopUint64Heap) Pop 

func (h *TopUint64Heap) Pop() interface{}

func (*TopUint64Heap) Push 

func (h *TopUint64Heap) Push(x interface{})

func (*TopUint64Heap) Sum 

func (h *TopUint64Heap) Sum() uint64

func (*TopUint64Heap) SumN 

func (h *TopUint64Heap) SumN(n int) uint64

func (TopUint64Heap) Swap 

func (h TopUint64Heap) Swap(i, j int)

func (*TopUint64Heap) TopN 

func (h *TopUint64Heap) TopN(n int) []uint64

func (*TopUint64Heap) Total 

func (h *TopUint64Heap) Total() uint64

type Topable 

type Topable interface {
	Value() int
	Label() string
}

type Uint16Sorter 

type Uint16Sorter []uint16

func (Uint16Sorter) Len 

func (s Uint16Sorter) Len() int

func (Uint16Sorter) Less 

func (s Uint16Sorter) Less(i, j int) bool

func (Uint16Sorter) Sort 

func (s Uint16Sorter) Sort() []uint16

func (Uint16Sorter) Swap 

func (s Uint16Sorter) Swap(i, j int)

type Uint256 

type Uint256 [4]uint64

func (Uint256) Gte 

func (x Uint256) Gte(y Uint256) bool

func (Uint256) Int256 

func (x Uint256) Int256() Int256

type Uint32Sorter 

type Uint32Sorter []uint32

func (Uint32Sorter) Len 

func (s Uint32Sorter) Len() int

func (Uint32Sorter) Less 

func (s Uint32Sorter) Less(i, j int) bool

func (Uint32Sorter) Sort 

func (s Uint32Sorter) Sort() []uint32

func (Uint32Sorter) Swap 

func (s Uint32Sorter) Swap(i, j int)

type Uint64Reducer 

type Uint64Reducer struct {
	// contains filtered or unexported fields
}

func (*Uint64Reducer) Add 

func (b *Uint64Reducer) Add(val uint64)

func (*Uint64Reducer) AddN 

func (b *Uint64Reducer) AddN(val ...uint64)

func (*Uint64Reducer) AddSlice 

func (b *Uint64Reducer) AddSlice(val []uint64)

func (Uint64Reducer) Len 

func (b Uint64Reducer) Len() int

func (Uint64Reducer) Max 

func (b Uint64Reducer) Max() uint64

func (Uint64Reducer) Mean 

func (b Uint64Reducer) Mean() float64

func (Uint64Reducer) Min 

func (b Uint64Reducer) Min() uint64

func (Uint64Reducer) Stddev 

func (b Uint64Reducer) Stddev() float64

https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance

func (Uint64Reducer) Sum 

func (b Uint64Reducer) Sum() uint64

func (Uint64Reducer) Var 

func (b Uint64Reducer) Var() float64

type Uint64Sorter 

type Uint64Sorter []uint64

func (Uint64Sorter) Len 

func (s Uint64Sorter) Len() int

func (Uint64Sorter) Less 

func (s Uint64Sorter) Less(i, j int) bool

func (Uint64Sorter) Sort 

func (s Uint64Sorter) Sort() []uint64

func (Uint64Sorter) Swap 

func (s Uint64Sorter) Swap(i, j int)

type Uint8Sorter 

type Uint8Sorter []uint8

func (Uint8Sorter) Len 

func (s Uint8Sorter) Len() int

func (Uint8Sorter) Less 

func (s Uint8Sorter) Less(i, j int) bool

func (Uint8Sorter) Sort 

func (s Uint8Sorter) Sort() []uint8

func (Uint8Sorter) Swap 

func (s Uint8Sorter) Swap(i, j int)

type WindowFloat64Reducer 

type WindowFloat64Reducer struct {
	Float64Reducer
	// contains filtered or unexported fields
}

func NewWindowFloat64Reducer 

func NewWindowFloat64Reducer(size int) *WindowFloat64Reducer

func (*WindowFloat64Reducer) Add 

func (b *WindowFloat64Reducer) Add(val float64)

func (*WindowFloat64Reducer) AddN 

func (b *WindowFloat64Reducer) AddN(val ...float64)

func (*WindowFloat64Reducer) AddSorted 

func (b *WindowFloat64Reducer) AddSorted(val float64)

func (*WindowFloat64Reducer) AddSortedN 

func (b *WindowFloat64Reducer) AddSortedN(val ...float64)

func (*WindowFloat64Reducer) AddSortedSlice 

func (b *WindowFloat64Reducer) AddSortedSlice(val []float64)

func (*WindowFloat64Reducer) Median 

func (b *WindowFloat64Reducer) Median() float64

func (*WindowFloat64Reducer) UseSlice 

func (b *WindowFloat64Reducer) UseSlice(val []float64)

type WindowInt64Reducer 

type WindowInt64Reducer struct {
	Int64Reducer
	// contains filtered or unexported fields
}

func NewWindowInt64Reducer 

func NewWindowInt64Reducer(size int) *WindowInt64Reducer

func (*WindowInt64Reducer) Add 

func (b *WindowInt64Reducer) Add(val int64)

func (*WindowInt64Reducer) AddN 

func (b *WindowInt64Reducer) AddN(val ...int64)

func (*WindowInt64Reducer) AddSorted 

func (b *WindowInt64Reducer) AddSorted(val int64)

func (*WindowInt64Reducer) AddSortedN 

func (b *WindowInt64Reducer) AddSortedN(val ...int64)

func (*WindowInt64Reducer) AddSortedSlice 

func (b *WindowInt64Reducer) AddSortedSlice(val []int64)

func (*WindowInt64Reducer) Median 

func (b *WindowInt64Reducer) Median() float64

func (*WindowInt64Reducer) UseSlice 

func (b *WindowInt64Reducer) UseSlice(val []int64)

type WindowUint64Reducer 

type WindowUint64Reducer struct {
	Uint64Reducer
	// contains filtered or unexported fields
}

func NewWindowUint64Reducer 

func NewWindowUint64Reducer(size int) *WindowUint64Reducer

func (*WindowUint64Reducer) Add 

func (b *WindowUint64Reducer) Add(val uint64)

func (*WindowUint64Reducer) AddN 

func (b *WindowUint64Reducer) AddN(val ...uint64)

func (*WindowUint64Reducer) AddSorted 

func (b *WindowUint64Reducer) AddSorted(val uint64)

func (*WindowUint64Reducer) AddSortedN 

func (b *WindowUint64Reducer) AddSortedN(val ...uint64)

func (*WindowUint64Reducer) AddSortedSlice 

func (b *WindowUint64Reducer) AddSortedSlice(val []uint64)

func (*WindowUint64Reducer) Median 

func (b *WindowUint64Reducer) Median() float64

func (*WindowUint64Reducer) UseSlice 

func (b *WindowUint64Reducer) UseSlice(val []uint64)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.