replace parser with actions/workflow-parser
Этот коммит содержится в:
Casey Lee
9
vendor/github.com/soniakeys/bits/.travis.yml
сгенерированный
поставляемый
Обычный файл
9
vendor/github.com/soniakeys/bits/.travis.yml
сгенерированный
поставляемый
Обычный файл
@@ -0,0 +1,9 @@
|
||||
sudo: false
|
||||
language: go
|
||||
go: master
|
||||
before_script:
|
||||
- go vet
|
||||
- go get github.com/client9/misspell/cmd/misspell
|
||||
- misspell -error *
|
||||
- go get github.com/soniakeys/vetc
|
||||
- vetc
|
||||
463
vendor/github.com/soniakeys/bits/bits.go
сгенерированный
поставляемый
Обычный файл
463
vendor/github.com/soniakeys/bits/bits.go
сгенерированный
поставляемый
Обычный файл
@@ -0,0 +1,463 @@
|
||||
// Copyright 2017 Sonia Keys
|
||||
// License MIT: http://opensource.org/licenses/MIT
|
||||
|
||||
// Bits implements methods on a bit array type.
|
||||
//
|
||||
// The Bits type holds a fixed size array of bits, numbered consecutively
|
||||
// from zero. Some set-like operations are possible, but the API is more
|
||||
// array-like or register-like.
|
||||
package bits
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
mb "math/bits"
|
||||
)
|
||||
|
||||
// Bits holds a fixed number of bits.
|
||||
//
|
||||
// Bit number 0 is stored in the LSB, or bit 0, of the word indexed at 0.
|
||||
//
|
||||
// When Num is not a multiple of 64, the last element of Bits will hold some
|
||||
// bits beyond Num. These bits are undefined. They are not required to be
|
||||
// zero but do not have any meaning. Bits methods are not required to leave
|
||||
// them undisturbed.
|
||||
type Bits struct {
|
||||
Num int // number of bits
|
||||
Bits []uint64
|
||||
}
|
||||
|
||||
// New constructs a Bits value with the given number of bits.
|
||||
//
|
||||
// It panics if num is negative.
|
||||
func New(num int) Bits {
|
||||
if num < 0 {
|
||||
panic("negative number of bits")
|
||||
}
|
||||
return Bits{num, make([]uint64, (num+63)>>6)}
|
||||
}
|
||||
|
||||
// NewGivens constructs a Bits value with the given bits nums set to 1.
|
||||
//
|
||||
// The number of bits will be just enough to hold the largest bit value
|
||||
// listed. That is, the number of bits will be the max bit number plus one.
|
||||
//
|
||||
// It panics if any bit number is negative.
|
||||
func NewGivens(nums ...int) Bits {
|
||||
max := -1
|
||||
for _, p := range nums {
|
||||
if p > max {
|
||||
max = p
|
||||
}
|
||||
}
|
||||
b := New(max + 1)
|
||||
for _, p := range nums {
|
||||
b.SetBit(p, 1)
|
||||
}
|
||||
return b
|
||||
}
|
||||
|
||||
// AllOnes returns true if all Num bits are 1.
|
||||
func (b Bits) AllOnes() bool {
|
||||
last := len(b.Bits) - 1
|
||||
for _, w := range b.Bits[:last] {
|
||||
if w != ^uint64(0) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return ^b.Bits[last]<<uint(64*len(b.Bits)-b.Num) == 0
|
||||
}
|
||||
|
||||
// AllZeros returns true if all Num bits are 0.
|
||||
func (b Bits) AllZeros() bool {
|
||||
last := len(b.Bits) - 1
|
||||
for _, w := range b.Bits[:last] {
|
||||
if w != 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return b.Bits[last]<<uint(64*len(b.Bits)-b.Num) == 0
|
||||
}
|
||||
|
||||
// And sets z = x & y.
|
||||
//
|
||||
// It panics if x and y do not have the same Num.
|
||||
func (z *Bits) And(x, y Bits) {
|
||||
if x.Num != y.Num {
|
||||
panic("arguments have different number of bits")
|
||||
}
|
||||
if z.Num != x.Num {
|
||||
*z = New(x.Num)
|
||||
}
|
||||
for i, w := range y.Bits {
|
||||
z.Bits[i] = x.Bits[i] & w
|
||||
}
|
||||
}
|
||||
|
||||
// AndNot sets z = x &^ y.
|
||||
//
|
||||
// It panics if x and y do not have the same Num.
|
||||
func (z *Bits) AndNot(x, y Bits) {
|
||||
if x.Num != y.Num {
|
||||
panic("arguments have different number of bits")
|
||||
}
|
||||
if z.Num != x.Num {
|
||||
*z = New(x.Num)
|
||||
}
|
||||
for i, w := range y.Bits {
|
||||
z.Bits[i] = x.Bits[i] &^ w
|
||||
}
|
||||
}
|
||||
|
||||
// Bit returns the value of the n'th bit of receiver b.
|
||||
func (b Bits) Bit(n int) int {
|
||||
if n < 0 || n >= b.Num {
|
||||
panic("bit number out of range")
|
||||
}
|
||||
return int(b.Bits[n>>6] >> uint(n&63) & 1)
|
||||
}
|
||||
|
||||
// ClearAll sets all bits to 0.
|
||||
func (b Bits) ClearAll() {
|
||||
for i := range b.Bits {
|
||||
b.Bits[i] = 0
|
||||
}
|
||||
}
|
||||
|
||||
// ClearBits sets the given bits to 0 in receiver b.
|
||||
//
|
||||
// Other bits of b are left unchanged.
|
||||
//
|
||||
// It panics if any bit number is out of range.
|
||||
// That is, negative or >= the number of bits.
|
||||
func (b Bits) ClearBits(nums ...int) {
|
||||
for _, p := range nums {
|
||||
b.SetBit(p, 0)
|
||||
}
|
||||
}
|
||||
|
||||
// Equal returns true if all Num bits of a and b are equal.
|
||||
//
|
||||
// It panics if a and b have different Num.
|
||||
func (a Bits) Equal(b Bits) bool {
|
||||
if a.Num != b.Num {
|
||||
panic("receiver and argument have different number of bits")
|
||||
}
|
||||
if a.Num == 0 {
|
||||
return true
|
||||
}
|
||||
last := len(a.Bits) - 1
|
||||
for i, w := range a.Bits[:last] {
|
||||
if w != b.Bits[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return (a.Bits[last]^b.Bits[last])<<uint(len(a.Bits)*64-a.Num) == 0
|
||||
}
|
||||
|
||||
// IterateOnes calls visitor function v for each bit with a value of 1, in order
|
||||
// from lowest bit to highest bit.
|
||||
//
|
||||
// Iteration continues to the highest bit as long as v returns true.
|
||||
// It stops if v returns false.
|
||||
//
|
||||
// IterateOnes returns true normally. It returns false if v returns false.
|
||||
//
|
||||
// IterateOnes may not be sensitive to changes if bits are changed during
|
||||
// iteration, by the vistor function for example.
|
||||
// See OneFrom for an iteration method sensitive to changes during iteration.
|
||||
func (b Bits) IterateOnes(v func(int) bool) bool {
|
||||
for x, w := range b.Bits {
|
||||
if w != 0 {
|
||||
t := mb.TrailingZeros64(w)
|
||||
i := t // index in w of next 1 bit
|
||||
for {
|
||||
n := x<<6 | i
|
||||
if n >= b.Num {
|
||||
return true
|
||||
}
|
||||
if !v(x<<6 | i) {
|
||||
return false
|
||||
}
|
||||
w >>= uint(t + 1)
|
||||
if w == 0 {
|
||||
break
|
||||
}
|
||||
t = mb.TrailingZeros64(w)
|
||||
i += 1 + t
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// IterateZeros calls visitor function v for each bit with a value of 0,
|
||||
// in order from lowest bit to highest bit.
|
||||
//
|
||||
// Iteration continues to the highest bit as long as v returns true.
|
||||
// It stops if v returns false.
|
||||
//
|
||||
// IterateZeros returns true normally. It returns false if v returns false.
|
||||
//
|
||||
// IterateZeros may not be sensitive to changes if bits are changed during
|
||||
// iteration, by the vistor function for example.
|
||||
// See ZeroFrom for an iteration method sensitive to changes during iteration.
|
||||
func (b Bits) IterateZeros(v func(int) bool) bool {
|
||||
for x, w := range b.Bits {
|
||||
w = ^w
|
||||
if w != 0 {
|
||||
t := mb.TrailingZeros64(w)
|
||||
i := t // index in w of next 1 bit
|
||||
for {
|
||||
n := x<<6 | i
|
||||
if n >= b.Num {
|
||||
return true
|
||||
}
|
||||
if !v(x<<6 | i) {
|
||||
return false
|
||||
}
|
||||
w >>= uint(t + 1)
|
||||
if w == 0 {
|
||||
break
|
||||
}
|
||||
t = mb.TrailingZeros64(w)
|
||||
i += 1 + t
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Not sets receiver z to the complement of b.
|
||||
func (z *Bits) Not(b Bits) {
|
||||
if z.Num != b.Num {
|
||||
*z = New(b.Num)
|
||||
}
|
||||
for i, w := range b.Bits {
|
||||
z.Bits[i] = ^w
|
||||
}
|
||||
}
|
||||
|
||||
// OneFrom returns the number of the first 1 bit at or after (from) bit num.
|
||||
//
|
||||
// It returns -1 if there is no one bit at or after num.
|
||||
//
|
||||
// This provides one way to iterate over one bits.
|
||||
// To iterate over the one bits, call OneFrom with n = 0 to get the the first
|
||||
// one bit, then call with the result + 1 to get successive one bits.
|
||||
// Unlike the Iterate method, this technique is stateless and so allows
|
||||
// bits to be changed between successive calls.
|
||||
//
|
||||
// There is no panic for calling OneFrom with an argument >= b.Num.
|
||||
// In this case OneFrom simply returns -1.
|
||||
//
|
||||
// See also Iterate.
|
||||
func (b Bits) OneFrom(num int) int {
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
x := num >> 6
|
||||
// test for 1 in this word at or after n
|
||||
if wx := b.Bits[x] >> uint(num&63); wx != 0 {
|
||||
num += mb.TrailingZeros64(wx)
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
return num
|
||||
}
|
||||
x++
|
||||
for y, wy := range b.Bits[x:] {
|
||||
if wy != 0 {
|
||||
num = (x+y)<<6 | mb.TrailingZeros64(wy)
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
return num
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
// Or sets z = x | y.
|
||||
//
|
||||
// It panics if x and y do not have the same Num.
|
||||
func (z *Bits) Or(x, y Bits) {
|
||||
if x.Num != y.Num {
|
||||
panic("arguments have different number of bits")
|
||||
}
|
||||
if z.Num != x.Num {
|
||||
*z = New(x.Num)
|
||||
}
|
||||
for i, w := range y.Bits {
|
||||
z.Bits[i] = x.Bits[i] | w
|
||||
}
|
||||
}
|
||||
|
||||
// OnesCount returns the number of 1 bits.
|
||||
func (b Bits) OnesCount() (c int) {
|
||||
if b.Num == 0 {
|
||||
return 0
|
||||
}
|
||||
last := len(b.Bits) - 1
|
||||
for _, w := range b.Bits[:last] {
|
||||
c += mb.OnesCount64(w)
|
||||
}
|
||||
c += mb.OnesCount64(b.Bits[last] << uint(len(b.Bits)*64-b.Num))
|
||||
return
|
||||
}
|
||||
|
||||
// Set sets the bits of z to the bits of x.
|
||||
func (z *Bits) Set(b Bits) {
|
||||
if z.Num != b.Num {
|
||||
*z = New(b.Num)
|
||||
}
|
||||
copy(z.Bits, b.Bits)
|
||||
}
|
||||
|
||||
// SetAll sets z to have all 1 bits.
|
||||
func (b Bits) SetAll() {
|
||||
for i := range b.Bits {
|
||||
b.Bits[i] = ^uint64(0)
|
||||
}
|
||||
}
|
||||
|
||||
// SetBit sets the n'th bit to x, where x is a 0 or 1.
|
||||
//
|
||||
// It panics if n is out of range
|
||||
func (b Bits) SetBit(n, x int) {
|
||||
if n < 0 || n >= b.Num {
|
||||
panic("bit number out of range")
|
||||
}
|
||||
if x == 0 {
|
||||
b.Bits[n>>6] &^= 1 << uint(n&63)
|
||||
} else {
|
||||
b.Bits[n>>6] |= 1 << uint(n&63)
|
||||
}
|
||||
}
|
||||
|
||||
// SetBits sets the given bits to 1 in receiver b.
|
||||
//
|
||||
// Other bits of b are left unchanged.
|
||||
//
|
||||
// It panics if any bit number is out of range, negative or >= the number
|
||||
// of bits.
|
||||
func (b Bits) SetBits(nums ...int) {
|
||||
for _, p := range nums {
|
||||
b.SetBit(p, 1)
|
||||
}
|
||||
}
|
||||
|
||||
// Single returns true if b has exactly one 1 bit.
|
||||
func (b Bits) Single() bool {
|
||||
// like OnesCount, but stop as soon as two are found
|
||||
if b.Num == 0 {
|
||||
return false
|
||||
}
|
||||
c := 0
|
||||
last := len(b.Bits) - 1
|
||||
for _, w := range b.Bits[:last] {
|
||||
c += mb.OnesCount64(w)
|
||||
if c > 1 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
c += mb.OnesCount64(b.Bits[last] << uint(len(b.Bits)*64-b.Num))
|
||||
return c == 1
|
||||
}
|
||||
|
||||
// Slice returns a slice with the bit numbers of each 1 bit.
|
||||
func (b Bits) Slice() (s []int) {
|
||||
for x, w := range b.Bits {
|
||||
if w == 0 {
|
||||
continue
|
||||
}
|
||||
t := mb.TrailingZeros64(w)
|
||||
i := t // index in w of next 1 bit
|
||||
for {
|
||||
n := x<<6 | i
|
||||
if n >= b.Num {
|
||||
break
|
||||
}
|
||||
s = append(s, n)
|
||||
w >>= uint(t + 1)
|
||||
if w == 0 {
|
||||
break
|
||||
}
|
||||
t = mb.TrailingZeros64(w)
|
||||
i += 1 + t
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// String returns a readable representation.
|
||||
//
|
||||
// The returned string is big-endian, with the highest number bit first.
|
||||
//
|
||||
// If Num is 0, an empty string is returned.
|
||||
func (b Bits) String() (s string) {
|
||||
if b.Num == 0 {
|
||||
return ""
|
||||
}
|
||||
last := len(b.Bits) - 1
|
||||
for _, w := range b.Bits[:last] {
|
||||
s = fmt.Sprintf("%064b", w) + s
|
||||
}
|
||||
lb := b.Num - 64*last
|
||||
return fmt.Sprintf("%0*b", lb,
|
||||
b.Bits[last]&(^uint64(0)>>uint(64-lb))) + s
|
||||
}
|
||||
|
||||
// Xor sets z = x ^ y.
|
||||
func (z *Bits) Xor(x, y Bits) {
|
||||
if x.Num != y.Num {
|
||||
panic("arguments have different number of bits")
|
||||
}
|
||||
if z.Num != x.Num {
|
||||
*z = New(x.Num)
|
||||
}
|
||||
for i, w := range y.Bits {
|
||||
z.Bits[i] = x.Bits[i] ^ w
|
||||
}
|
||||
}
|
||||
|
||||
// ZeroFrom returns the number of the first 0 bit at or after (from) bit num.
|
||||
//
|
||||
// It returns -1 if there is no zero bit at or after num.
|
||||
//
|
||||
// This provides one way to iterate over zero bits.
|
||||
// To iterate over the zero bits, call ZeroFrom with n = 0 to get the the first
|
||||
// zero bit, then call with the result + 1 to get successive zero bits.
|
||||
// Unlike the IterateZeros method, this technique is stateless and so allows
|
||||
// bits to be changed between successive calls.
|
||||
//
|
||||
// There is no panic for calling ZeroFrom with an argument >= b.Num.
|
||||
// In this case ZeroFrom simply returns -1.
|
||||
//
|
||||
// See also IterateZeros.
|
||||
func (b Bits) ZeroFrom(num int) int {
|
||||
// code much like OneFrom except words are negated before testing
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
x := num >> 6
|
||||
// negate word to test for 0 at or after n
|
||||
if wx := ^b.Bits[x] >> uint(num&63); wx != 0 {
|
||||
num += mb.TrailingZeros64(wx)
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
return num
|
||||
}
|
||||
x++
|
||||
for y, wy := range b.Bits[x:] {
|
||||
wy = ^wy
|
||||
if wy != 0 {
|
||||
num = (x+y)<<6 | mb.TrailingZeros64(wy)
|
||||
if num >= b.Num {
|
||||
return -1
|
||||
}
|
||||
return num
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
1
vendor/github.com/soniakeys/bits/go.mod
сгенерированный
поставляемый
Обычный файл
1
vendor/github.com/soniakeys/bits/go.mod
сгенерированный
поставляемый
Обычный файл
@@ -0,0 +1 @@
|
||||
module "github.com/soniakeys/bits"
|
||||
38
vendor/github.com/soniakeys/bits/readme.adoc
сгенерированный
поставляемый
Обычный файл
38
vendor/github.com/soniakeys/bits/readme.adoc
сгенерированный
поставляемый
Обычный файл
@@ -0,0 +1,38 @@
|
||||
= Bits
|
||||
|
||||
Bits provides methods on a bit array type.
|
||||
|
||||
The Bits type holds a fixed size array of bits, numbered consecutively
|
||||
from zero. Some set-like operations are possible, but the API is more
|
||||
array-like or register-like.
|
||||
|
||||
image:https://godoc.org/github.com/soniakeys/bits?status.svg[link=https://godoc.org/github.com/soniakeys/bits] image:https://travis-ci.org/soniakeys/bits.svg[link=https://travis-ci.org/soniakeys/bits]
|
||||
|
||||
== Motivation and history
|
||||
|
||||
This package evolved from needs of my library of
|
||||
https://github.com/soniakeys/graph[graph algorithms]. For graph algorithms
|
||||
a common need is to store a single bit of information per node in a way that
|
||||
is both fast and memory efficient. I began by using `big.Int` from the standard
|
||||
library, then wrapped big.Int in a type. From time to time I considered
|
||||
other publicly available bit array or bit set packages, such as Will
|
||||
Fitzgerald's popular https://github.com/willf/bitset[bitset], but there were
|
||||
always little reasons I preferred my own type and methods. My type that
|
||||
wrapped `big.Int` met my needs until some simple benchmarks indicated it
|
||||
might be causing performance problems. Some further experiments supported
|
||||
this hypothesis so I ran further tests with a prototype bit array written
|
||||
from scratch. Then satisfied that my custom bit array was solving the graph
|
||||
performance problems, I decided to move it to a separate package with the
|
||||
idea it might have more general utility. For the initial version of this
|
||||
package I did the following:
|
||||
|
||||
- implemented a few tests to demonstrate fundamental correctness
|
||||
- brought over most methods of my type that wrapped big.Int
|
||||
- changed the index type from the graph-specific node index to a general `int`
|
||||
- replaced some custom bit-twiddling with use of the new `math/bits` package
|
||||
in the standard library
|
||||
- renamed a few methods for clarity
|
||||
- added a few methods for symmetry
|
||||
- added a few new methods I had seen a need for in my graph library
|
||||
- added doc, examples, tests, and more tests for 100% coverage
|
||||
- added this readme
|
||||
Ссылка в новой задаче
Block a user