mirror of
https://github.com/go-gitea/gitea
synced 2024-12-21 04:24:06 +01:00
30ce3731a1
* denisenkom/go-mssqldb untagged -> v0.9.0 * github.com/editorconfig/editorconfig-core-go v2.3.7 -> v2.3.8 * github.com/go-testfixtures/testfixtures v3.4.0 -> v3.4.1 * github.com/mholt/archiver v3.3.2 -> v3.5.0 * github.com/olivere/elastic v7.0.20 -> v7.0.21 * github.com/urfave/cli v1.22.4 -> v1.22.5 * github.com/xanzy/go-gitlab v0.38.1 -> v0.39.0 * github.com/yuin/goldmark-meta untagged -> v1.0.0 * github.com/ethantkoenig/rupture 0a76f03a811a -> c3b3b810dc77 * github.com/jaytaylor/html2text 8fb95d837f7d -> 3577fbdbcff7 * github.com/kballard/go-shellquote cd60e84ee657 -> 95032a82bc51 * github.com/msteinert/pam 02ccfbfaf0cc -> 913b8f8cdf8b * github.com/unknwon/paginater 7748a72e0141 -> 042474bd0eae * CI.restart() Co-authored-by: techknowlogick <techknowlogick@gitea.io>
550 lines
8.2 KiB
Go
Vendored
550 lines
8.2 KiB
Go
Vendored
package roaring
|
|
|
|
func equal(a, b []uint16) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func difference(set1 []uint16, set2 []uint16, buffer []uint16) int {
|
|
if 0 == len(set2) {
|
|
buffer = buffer[:len(set1)]
|
|
for k := 0; k < len(set1); k++ {
|
|
buffer[k] = set1[k]
|
|
}
|
|
return len(set1)
|
|
}
|
|
if 0 == len(set1) {
|
|
return 0
|
|
}
|
|
pos := 0
|
|
k1 := 0
|
|
k2 := 0
|
|
buffer = buffer[:cap(buffer)]
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
for {
|
|
if s1 < s2 {
|
|
buffer[pos] = s1
|
|
pos++
|
|
k1++
|
|
if k1 >= len(set1) {
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
} else if s1 == s2 {
|
|
k1++
|
|
k2++
|
|
if k1 >= len(set1) {
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
if k2 >= len(set2) {
|
|
for ; k1 < len(set1); k1++ {
|
|
buffer[pos] = set1[k1]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
} else { // if (val1>val2)
|
|
k2++
|
|
if k2 >= len(set2) {
|
|
for ; k1 < len(set1); k1++ {
|
|
buffer[pos] = set1[k1]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
}
|
|
}
|
|
return pos
|
|
|
|
}
|
|
|
|
func exclusiveUnion2by2(set1 []uint16, set2 []uint16, buffer []uint16) int {
|
|
if 0 == len(set2) {
|
|
buffer = buffer[:len(set1)]
|
|
copy(buffer, set1[:])
|
|
return len(set1)
|
|
}
|
|
if 0 == len(set1) {
|
|
buffer = buffer[:len(set2)]
|
|
copy(buffer, set2[:])
|
|
return len(set2)
|
|
}
|
|
pos := 0
|
|
k1 := 0
|
|
k2 := 0
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
buffer = buffer[:cap(buffer)]
|
|
for {
|
|
if s1 < s2 {
|
|
buffer[pos] = s1
|
|
pos++
|
|
k1++
|
|
if k1 >= len(set1) {
|
|
for ; k2 < len(set2); k2++ {
|
|
buffer[pos] = set2[k2]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
} else if s1 == s2 {
|
|
k1++
|
|
k2++
|
|
if k1 >= len(set1) {
|
|
for ; k2 < len(set2); k2++ {
|
|
buffer[pos] = set2[k2]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
if k2 >= len(set2) {
|
|
for ; k1 < len(set1); k1++ {
|
|
buffer[pos] = set1[k1]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
s2 = set2[k2]
|
|
} else { // if (val1>val2)
|
|
buffer[pos] = s2
|
|
pos++
|
|
k2++
|
|
if k2 >= len(set2) {
|
|
for ; k1 < len(set1); k1++ {
|
|
buffer[pos] = set1[k1]
|
|
pos++
|
|
}
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
}
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func union2by2Cardinality(set1 []uint16, set2 []uint16) int {
|
|
pos := 0
|
|
k1 := 0
|
|
k2 := 0
|
|
if 0 == len(set2) {
|
|
return len(set1)
|
|
}
|
|
if 0 == len(set1) {
|
|
return len(set2)
|
|
}
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
for {
|
|
if s1 < s2 {
|
|
pos++
|
|
k1++
|
|
if k1 >= len(set1) {
|
|
pos += len(set2) - k2
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
} else if s1 == s2 {
|
|
pos++
|
|
k1++
|
|
k2++
|
|
if k1 >= len(set1) {
|
|
pos += len(set2) - k2
|
|
break
|
|
}
|
|
if k2 >= len(set2) {
|
|
pos += len(set1) - k1
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
s2 = set2[k2]
|
|
} else { // if (set1[k1]>set2[k2])
|
|
pos++
|
|
k2++
|
|
if k2 >= len(set2) {
|
|
pos += len(set1) - k1
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
}
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func intersection2by2(
|
|
set1 []uint16,
|
|
set2 []uint16,
|
|
buffer []uint16) int {
|
|
|
|
if len(set1)*64 < len(set2) {
|
|
return onesidedgallopingintersect2by2(set1, set2, buffer)
|
|
} else if len(set2)*64 < len(set1) {
|
|
return onesidedgallopingintersect2by2(set2, set1, buffer)
|
|
} else {
|
|
return localintersect2by2(set1, set2, buffer)
|
|
}
|
|
}
|
|
|
|
func intersection2by2Cardinality(
|
|
set1 []uint16,
|
|
set2 []uint16) int {
|
|
|
|
if len(set1)*64 < len(set2) {
|
|
return onesidedgallopingintersect2by2Cardinality(set1, set2)
|
|
} else if len(set2)*64 < len(set1) {
|
|
return onesidedgallopingintersect2by2Cardinality(set2, set1)
|
|
} else {
|
|
return localintersect2by2Cardinality(set1, set2)
|
|
}
|
|
}
|
|
|
|
func intersects2by2(
|
|
set1 []uint16,
|
|
set2 []uint16) bool {
|
|
// could be optimized if one set is much larger than the other one
|
|
if (0 == len(set1)) || (0 == len(set2)) {
|
|
return false
|
|
}
|
|
k1 := 0
|
|
k2 := 0
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
mainwhile:
|
|
for {
|
|
|
|
if s2 < s1 {
|
|
for {
|
|
k2++
|
|
if k2 == len(set2) {
|
|
break mainwhile
|
|
}
|
|
s2 = set2[k2]
|
|
if s2 >= s1 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if s1 < s2 {
|
|
for {
|
|
k1++
|
|
if k1 == len(set1) {
|
|
break mainwhile
|
|
}
|
|
s1 = set1[k1]
|
|
if s1 >= s2 {
|
|
break
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// (set2[k2] == set1[k1])
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func localintersect2by2(
|
|
set1 []uint16,
|
|
set2 []uint16,
|
|
buffer []uint16) int {
|
|
|
|
if (0 == len(set1)) || (0 == len(set2)) {
|
|
return 0
|
|
}
|
|
k1 := 0
|
|
k2 := 0
|
|
pos := 0
|
|
buffer = buffer[:cap(buffer)]
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
mainwhile:
|
|
for {
|
|
if s2 < s1 {
|
|
for {
|
|
k2++
|
|
if k2 == len(set2) {
|
|
break mainwhile
|
|
}
|
|
s2 = set2[k2]
|
|
if s2 >= s1 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if s1 < s2 {
|
|
for {
|
|
k1++
|
|
if k1 == len(set1) {
|
|
break mainwhile
|
|
}
|
|
s1 = set1[k1]
|
|
if s1 >= s2 {
|
|
break
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// (set2[k2] == set1[k1])
|
|
buffer[pos] = s1
|
|
pos++
|
|
k1++
|
|
if k1 == len(set1) {
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
k2++
|
|
if k2 == len(set2) {
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
}
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func localintersect2by2Cardinality(
|
|
set1 []uint16,
|
|
set2 []uint16) int {
|
|
|
|
if (0 == len(set1)) || (0 == len(set2)) {
|
|
return 0
|
|
}
|
|
k1 := 0
|
|
k2 := 0
|
|
pos := 0
|
|
s1 := set1[k1]
|
|
s2 := set2[k2]
|
|
mainwhile:
|
|
for {
|
|
if s2 < s1 {
|
|
for {
|
|
k2++
|
|
if k2 == len(set2) {
|
|
break mainwhile
|
|
}
|
|
s2 = set2[k2]
|
|
if s2 >= s1 {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
if s1 < s2 {
|
|
for {
|
|
k1++
|
|
if k1 == len(set1) {
|
|
break mainwhile
|
|
}
|
|
s1 = set1[k1]
|
|
if s1 >= s2 {
|
|
break
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// (set2[k2] == set1[k1])
|
|
pos++
|
|
k1++
|
|
if k1 == len(set1) {
|
|
break
|
|
}
|
|
s1 = set1[k1]
|
|
k2++
|
|
if k2 == len(set2) {
|
|
break
|
|
}
|
|
s2 = set2[k2]
|
|
}
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func advanceUntil(
|
|
array []uint16,
|
|
pos int,
|
|
length int,
|
|
min uint16) int {
|
|
lower := pos + 1
|
|
|
|
if lower >= length || array[lower] >= min {
|
|
return lower
|
|
}
|
|
|
|
spansize := 1
|
|
|
|
for lower+spansize < length && array[lower+spansize] < min {
|
|
spansize *= 2
|
|
}
|
|
var upper int
|
|
if lower+spansize < length {
|
|
upper = lower + spansize
|
|
} else {
|
|
upper = length - 1
|
|
}
|
|
|
|
if array[upper] == min {
|
|
return upper
|
|
}
|
|
|
|
if array[upper] < min {
|
|
// means
|
|
// array
|
|
// has no
|
|
// item
|
|
// >= min
|
|
// pos = array.length;
|
|
return length
|
|
}
|
|
|
|
// we know that the next-smallest span was too small
|
|
lower += (spansize >> 1)
|
|
|
|
mid := 0
|
|
for lower+1 != upper {
|
|
mid = (lower + upper) >> 1
|
|
if array[mid] == min {
|
|
return mid
|
|
} else if array[mid] < min {
|
|
lower = mid
|
|
} else {
|
|
upper = mid
|
|
}
|
|
}
|
|
return upper
|
|
|
|
}
|
|
|
|
func onesidedgallopingintersect2by2(
|
|
smallset []uint16,
|
|
largeset []uint16,
|
|
buffer []uint16) int {
|
|
|
|
if 0 == len(smallset) {
|
|
return 0
|
|
}
|
|
buffer = buffer[:cap(buffer)]
|
|
k1 := 0
|
|
k2 := 0
|
|
pos := 0
|
|
s1 := largeset[k1]
|
|
s2 := smallset[k2]
|
|
mainwhile:
|
|
|
|
for {
|
|
if s1 < s2 {
|
|
k1 = advanceUntil(largeset, k1, len(largeset), s2)
|
|
if k1 == len(largeset) {
|
|
break mainwhile
|
|
}
|
|
s1 = largeset[k1]
|
|
}
|
|
if s2 < s1 {
|
|
k2++
|
|
if k2 == len(smallset) {
|
|
break mainwhile
|
|
}
|
|
s2 = smallset[k2]
|
|
} else {
|
|
|
|
buffer[pos] = s2
|
|
pos++
|
|
k2++
|
|
if k2 == len(smallset) {
|
|
break
|
|
}
|
|
s2 = smallset[k2]
|
|
k1 = advanceUntil(largeset, k1, len(largeset), s2)
|
|
if k1 == len(largeset) {
|
|
break mainwhile
|
|
}
|
|
s1 = largeset[k1]
|
|
}
|
|
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func onesidedgallopingintersect2by2Cardinality(
|
|
smallset []uint16,
|
|
largeset []uint16) int {
|
|
|
|
if 0 == len(smallset) {
|
|
return 0
|
|
}
|
|
k1 := 0
|
|
k2 := 0
|
|
pos := 0
|
|
s1 := largeset[k1]
|
|
s2 := smallset[k2]
|
|
mainwhile:
|
|
|
|
for {
|
|
if s1 < s2 {
|
|
k1 = advanceUntil(largeset, k1, len(largeset), s2)
|
|
if k1 == len(largeset) {
|
|
break mainwhile
|
|
}
|
|
s1 = largeset[k1]
|
|
}
|
|
if s2 < s1 {
|
|
k2++
|
|
if k2 == len(smallset) {
|
|
break mainwhile
|
|
}
|
|
s2 = smallset[k2]
|
|
} else {
|
|
|
|
pos++
|
|
k2++
|
|
if k2 == len(smallset) {
|
|
break
|
|
}
|
|
s2 = smallset[k2]
|
|
k1 = advanceUntil(largeset, k1, len(largeset), s2)
|
|
if k1 == len(largeset) {
|
|
break mainwhile
|
|
}
|
|
s1 = largeset[k1]
|
|
}
|
|
|
|
}
|
|
return pos
|
|
}
|
|
|
|
func binarySearch(array []uint16, ikey uint16) int {
|
|
low := 0
|
|
high := len(array) - 1
|
|
for low+16 <= high {
|
|
middleIndex := int(uint32(low+high) >> 1)
|
|
middleValue := array[middleIndex]
|
|
if middleValue < ikey {
|
|
low = middleIndex + 1
|
|
} else if middleValue > ikey {
|
|
high = middleIndex - 1
|
|
} else {
|
|
return middleIndex
|
|
}
|
|
}
|
|
for ; low <= high; low++ {
|
|
val := array[low]
|
|
if val >= ikey {
|
|
if val == ikey {
|
|
return low
|
|
}
|
|
break
|
|
}
|
|
}
|
|
return -(low + 1)
|
|
}
|