_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36000 | Delete | train | func (fi *FastIntegerHashMap) Delete(key uint64) {
if fi.packets.delete(key) {
fi.count--
}
} | go | {
"resource": ""
} |
q36001 | New | train | func New(hint uint64) *FastIntegerHashMap {
if hint == 0 {
hint = 16
}
hint = roundUp(hint)
return &FastIntegerHashMap{
count: 0,
packets: make(packets, hint),
}
} | go | {
"resource": ""
} |
q36002 | Compare | train | func (se skipEntry) Compare(other common.Comparator) int {
otherSe := other.(skipEntry)
if se == otherSe {
return 0
}
if se > otherSe {
return 1
}
return -1
} | go | {
"resource": ""
} |
q36003 | isLastDimension | train | func isLastDimension(dimension, lastDimension uint64) bool {
if dimension >= lastDimension { // useful in testing and denotes a serious problem
panic(`Dimension is greater than possible dimensions.`)
}
return dimension == lastDimension-1
} | go | {
"resource": ""
} |
q36004 | needsDeletion | train | func needsDeletion(value, index, number int64) bool {
if number > 0 {
return false
}
number = -number // get the magnitude
offset := value - index
return offset >= 0 && offset < number
} | go | {
"resource": ""
} |
q36005 | Get | train | func (rt *skipListRT) Get(entries ...rangetree.Entry) rangetree.Entries {
results := make(rangetree.Entries, 0, len(entries))
for _, e := range entries {
results = append(results, rt.get(e))
}
return results
} | go | {
"resource": ""
} |
q36006 | deleteRecursive | train | func (rt *skipListRT) deleteRecursive(sl *skip.SkipList, dimension uint64,
entry rangetree.Entry) rangetree.Entry {
value := entry.ValueAtDimension(dimension)
if isLastDimension(dimension, rt.dimensions) {
entries := sl.Delete(skipEntry(value))
if entries[0] == nil {
return nil
}
rt.number--
return en... | go | {
"resource": ""
} |
q36007 | Apply | train | func (rt *skipListRT) Apply(interval rangetree.Interval, fn func(rangetree.Entry) bool) {
rt.apply(rt.top, 0, interval, fn)
} | go | {
"resource": ""
} |
q36008 | Query | train | func (rt *skipListRT) Query(interval rangetree.Interval) rangetree.Entries {
entries := make(rangetree.Entries, 0, 100)
rt.apply(rt.top, 0, interval, func(e rangetree.Entry) bool {
entries = append(entries, e)
return true
})
return entries
} | go | {
"resource": ""
} |
q36009 | Swap | train | func (u uintSlice) Swap(i, j int64) {
u[i], u[j] = u[j], u[i]
} | go | {
"resource": ""
} |
q36010 | Less | train | func (u uintSlice) Less(i, j int64) bool {
return u[i] < u[j]
} | go | {
"resource": ""
} |
q36011 | SetBit | train | func (sba *sparseBitArray) SetBit(k uint64) error {
index, position := getIndexAndRemainder(k)
i, inserted := sba.indices.insert(index)
if inserted {
sba.blocks.insert(i)
}
sba.blocks[i] = sba.blocks[i].insert(position)
return nil
} | go | {
"resource": ""
} |
q36012 | GetBit | train | func (sba *sparseBitArray) GetBit(k uint64) (bool, error) {
index, position := getIndexAndRemainder(k)
i := sba.indices.get(index)
if i == -1 {
return false, nil
}
return sba.blocks[i].get(position), nil
} | go | {
"resource": ""
} |
q36013 | ToNums | train | func (sba *sparseBitArray) ToNums() []uint64 {
if len(sba.indices) == 0 {
return nil
}
diff := uint64(len(sba.indices)) * s
nums := make([]uint64, 0, diff/4)
for i, offset := range sba.indices {
sba.blocks[i].toNums(offset*s, &nums)
}
return nums
} | go | {
"resource": ""
} |
q36014 | ClearBit | train | func (sba *sparseBitArray) ClearBit(k uint64) error {
index, position := getIndexAndRemainder(k)
i := sba.indices.get(index)
if i == -1 {
return nil
}
sba.blocks[i] = sba.blocks[i].remove(position)
if sba.blocks[i] == 0 {
sba.blocks.deleteAtIndex(i)
sba.indices.deleteAtIndex(i)
}
return nil
} | go | {
"resource": ""
} |
q36015 | Reset | train | func (sba *sparseBitArray) Reset() {
sba.blocks = sba.blocks[:0]
sba.indices = sba.indices[:0]
} | go | {
"resource": ""
} |
q36016 | Equals | train | func (sba *sparseBitArray) Equals(other BitArray) bool {
if other.Capacity() == 0 && sba.Capacity() > 0 {
return false
}
var selfIndex uint64
for iter := other.Blocks(); iter.Next(); {
otherIndex, otherBlock := iter.Value()
if len(sba.indices) == 0 {
if otherBlock > 0 {
return false
}
continue
... | go | {
"resource": ""
} |
q36017 | Or | train | func (sba *sparseBitArray) Or(other BitArray) BitArray {
if ba, ok := other.(*sparseBitArray); ok {
return orSparseWithSparseBitArray(sba, ba)
}
return orSparseWithDenseBitArray(sba, other.(*bitArray))
} | go | {
"resource": ""
} |
q36018 | And | train | func (sba *sparseBitArray) And(other BitArray) BitArray {
if ba, ok := other.(*sparseBitArray); ok {
return andSparseWithSparseBitArray(sba, ba)
}
return andSparseWithDenseBitArray(sba, other.(*bitArray))
} | go | {
"resource": ""
} |
q36019 | Intersects | train | func (sba *sparseBitArray) Intersects(other BitArray) bool {
if other.Capacity() == 0 {
return true
}
var selfIndex int64
for iter := other.Blocks(); iter.Next(); {
otherI, otherBlock := iter.Value()
if len(sba.indices) == 0 {
if otherBlock > 0 {
return false
}
continue
}
// here we grab whe... | go | {
"resource": ""
} |
q36020 | compare | train | func compare(nodeLow, ivLow int64, nodeID, ivID uint64) int {
if ivLow > nodeLow {
return 1
}
if ivLow < nodeLow {
return 0
}
return intFromBool(ivID > nodeID)
} | go | {
"resource": ""
} |
q36021 | add | train | func (tree *tree) add(iv Interval) {
if tree.root == nil {
tree.root = newNode(
iv, iv.LowAtDimension(1),
iv.HighAtDimension(1),
1,
)
tree.root.red = false
tree.number++
return
}
tree.resetDummy()
var (
dummy = tree.dummy
parent, grandParent *node
node = tree.r... | go | {
"resource": ""
} |
q36022 | Add | train | func (tree *tree) Add(intervals ...Interval) {
for _, iv := range intervals {
tree.add(iv)
}
} | go | {
"resource": ""
} |
q36023 | Delete | train | func (tree *tree) Delete(intervals ...Interval) {
for _, iv := range intervals {
tree.delete(iv)
}
if tree.root != nil {
tree.root.adjustRanges()
}
} | go | {
"resource": ""
} |
q36024 | Query | train | func (tree *tree) Query(interval Interval) Intervals {
if tree.root == nil {
return nil
}
var (
Intervals = intervalsPool.Get().(Intervals)
ivLow = interval.LowAtDimension(1)
ivHigh = interval.HighAtDimension(1)
)
tree.root.query(ivLow, ivHigh, interval, tree.maxDimension, func(node *node) {
Int... | go | {
"resource": ""
} |
q36025 | Enqueue | train | func (heap *FloatingFibonacciHeap) Enqueue(priority float64) *Entry {
singleton := newEntry(priority)
// Merge singleton list with heap
heap.min = mergeLists(heap.min, singleton)
heap.size++
return singleton
} | go | {
"resource": ""
} |
q36026 | Min | train | func (heap *FloatingFibonacciHeap) Min() (*Entry, error) {
if heap.IsEmpty() {
return nil, EmptyHeapError("Trying to get minimum element of empty heap")
}
return heap.min, nil
} | go | {
"resource": ""
} |
q36027 | DequeueMin | train | func (heap *FloatingFibonacciHeap) DequeueMin() (*Entry, error) {
if heap.IsEmpty() {
return nil, EmptyHeapError("Cannot dequeue minimum of empty heap")
}
heap.size--
// Copy pointer. Will need it later.
min := heap.min
if min.next == min { // This is the only root node
heap.min = nil
} else { // There ar... | go | {
"resource": ""
} |
q36028 | DecreaseKey | train | func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriority float64) (*Entry, error) {
if heap.IsEmpty() {
return nil, EmptyHeapError("Cannot decrease key in an empty heap")
}
if node == nil {
return nil, NilError("Cannot decrease key: given node is nil")
}
if newPriority >= node.Priority {
re... | go | {
"resource": ""
} |
q36029 | Delete | train | func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
if heap.IsEmpty() {
return EmptyHeapError("Cannot delete element from an empty heap")
}
if node == nil {
return NilError("Cannot delete node: given node is nil")
}
decreaseKeyUnchecked(heap, node, -math.MaxFloat64)
heap.DequeueMin()
return nil... | go | {
"resource": ""
} |
q36030 | Merge | train | func (heap *FloatingFibonacciHeap) Merge(other *FloatingFibonacciHeap) (FloatingFibonacciHeap, error) {
if heap == nil || other == nil {
return FloatingFibonacciHeap{}, NilError("One of the heaps to merge is nil. Cannot merge")
}
resultSize := heap.size + other.size
resultMin := mergeLists(heap.min, other.min)... | go | {
"resource": ""
} |
q36031 | Put | train | func (b *basicBatcher) Put(item interface{}) error {
b.lock.Lock()
if b.disposed {
b.lock.Unlock()
return ErrDisposed
}
b.items = append(b.items, item)
if b.calculateBytes != nil {
b.availableBytes += b.calculateBytes(item)
}
if b.ready() {
// To guarantee ordering this MUST be in the lock, otherwise mu... | go | {
"resource": ""
} |
q36032 | Get | train | func (b *basicBatcher) Get() ([]interface{}, error) {
// Don't check disposed yet so any items remaining in the queue
// will be returned properly.
var timeout <-chan time.Time
if b.maxTime > 0 {
timeout = time.After(b.maxTime)
}
select {
case items, ok := <-b.batchChan:
// If there's something on the batc... | go | {
"resource": ""
} |
q36033 | Flush | train | func (b *basicBatcher) Flush() error {
// This is the same pattern as a Put
b.lock.Lock()
if b.disposed {
b.lock.Unlock()
return ErrDisposed
}
b.flush()
b.lock.Unlock()
return nil
} | go | {
"resource": ""
} |
q36034 | Dispose | train | func (b *basicBatcher) Dispose() {
for {
if b.lock.TryLock() {
// We've got a lock
if b.disposed {
b.lock.Unlock()
return
}
b.disposed = true
b.items = nil
b.drainBatchChan()
close(b.batchChan)
b.lock.Unlock()
} else {
// Two cases here:
// 1) Something is blocked and holding... | go | {
"resource": ""
} |
q36035 | IsDisposed | train | func (b *basicBatcher) IsDisposed() bool {
b.lock.Lock()
disposed := b.disposed
b.lock.Unlock()
return disposed
} | go | {
"resource": ""
} |
q36036 | flush | train | func (b *basicBatcher) flush() {
b.batchChan <- b.items
b.items = make([]interface{}, 0, b.maxItems)
b.availableBytes = 0
} | go | {
"resource": ""
} |
q36037 | Value | train | func (iter *sparseBitArrayIterator) Value() (uint64, block) {
return iter.sba.indices[iter.index], iter.sba.blocks[iter.index]
} | go | {
"resource": ""
} |
q36038 | Value | train | func (iter *bitArrayIterator) Value() (uint64, block) {
return uint64(iter.index), iter.ba.blocks[iter.index]
} | go | {
"resource": ""
} |
q36039 | Dispose | train | func (entries *Entries) Dispose() {
for i := 0; i < len(*entries); i++ {
(*entries)[i] = nil
}
*entries = (*entries)[:0]
entriesPool.Put(*entries)
} | go | {
"resource": ""
} |
q36040 | copy | train | func (n *node) copy() *node {
return &node{
balance: n.balance,
children: [2]*node{n.children[0], n.children[1]},
entry: n.entry,
}
} | go | {
"resource": ""
} |
q36041 | copy | train | func (immutable *Immutable) copy() *Immutable {
var root *node
if immutable.root != nil {
root = immutable.root.copy()
}
cp := &Immutable{
root: root,
number: immutable.number,
dummy: *newNode(nil),
}
return cp
} | go | {
"resource": ""
} |
q36042 | Get | train | func (immutable *Immutable) Get(entries ...Entry) Entries {
result := make(Entries, 0, len(entries))
for _, e := range entries {
result = append(result, immutable.get(e))
}
return result
} | go | {
"resource": ""
} |
q36043 | Insert | train | func (immutable *Immutable) Insert(entries ...Entry) (*Immutable, Entries) {
if len(entries) == 0 {
return immutable, Entries{}
}
overwritten := make(Entries, 0, len(entries))
cp := immutable.copy()
for _, e := range entries {
overwritten = append(overwritten, cp.insert(e))
}
return cp, overwritten
} | go | {
"resource": ""
} |
q36044 | Delete | train | func (immutable *Immutable) Delete(entries ...Entry) (*Immutable, Entries) {
if len(entries) == 0 {
return immutable, Entries{}
}
deleted := make(Entries, 0, len(entries))
cp := immutable.copy()
for _, e := range entries {
deleted = append(deleted, cp.delete(e))
}
return cp, deleted
} | go | {
"resource": ""
} |
q36045 | Put | train | func (rb *RingBuffer) Put(item interface{}) error {
_, err := rb.put(item, false)
return err
} | go | {
"resource": ""
} |
q36046 | Offer | train | func (rb *RingBuffer) Offer(item interface{}) (bool, error) {
return rb.put(item, true)
} | go | {
"resource": ""
} |
q36047 | Poll | train | func (rb *RingBuffer) Poll(timeout time.Duration) (interface{}, error) {
var (
n *node
pos = atomic.LoadUint64(&rb.dequeue)
start time.Time
)
if timeout > 0 {
start = time.Now()
}
L:
for {
if atomic.LoadUint64(&rb.disposed) == 1 {
return nil, ErrDisposed
}
n = rb.nodes[pos&rb.mask]
seq :=... | go | {
"resource": ""
} |
q36048 | Len | train | func (rb *RingBuffer) Len() uint64 {
return atomic.LoadUint64(&rb.queue) - atomic.LoadUint64(&rb.dequeue)
} | go | {
"resource": ""
} |
q36049 | NewRingBuffer | train | func NewRingBuffer(size uint64) *RingBuffer {
rb := &RingBuffer{}
rb.init(size)
return rb
} | go | {
"resource": ""
} |
q36050 | generateRandomVerticesFromGuess | train | func generateRandomVerticesFromGuess(guess *nmVertex, num int) vertices {
// summed allows us to prevent duplicate guesses, checking
// all previous guesses for every guess created would be too
// time consuming so we take an indexed shortcut here. summed
// is a map of a sum of the vars to the vertices that have ... | go | {
"resource": ""
} |
q36051 | findMidpoint | train | func findMidpoint(vertices ...*nmVertex) *nmVertex {
num := len(vertices) // this is what we divide by
vars := make([]float64, 0, num)
for i := 0; i < num; i++ {
sum := float64(0)
for _, v := range vertices {
sum += v.vars[i]
}
vars = append(vars, sum/float64(num))
}
return &nmVertex{
vars: vars,
}... | go | {
"resource": ""
} |
q36052 | evaluate | train | func (vertices vertices) evaluate(config NelderMeadConfiguration) {
for _, v := range vertices {
v.evaluate(config)
}
vertices.sort(config)
} | go | {
"resource": ""
} |
q36053 | Less | train | func (sorter sorter) Less(i, j int) bool {
return sorter.vertices[i].less(sorter.config, sorter.vertices[j])
} | go | {
"resource": ""
} |
q36054 | euclideanDistance | train | func (nm *nmVertex) euclideanDistance(other *nmVertex) float64 {
sum := float64(0)
// first we want to sum all the distances between the points
for i, otherPoint := range other.vars {
// distance between points is defined by (qi-ri)^2
sum += math.Pow(otherPoint-nm.vars[i], 2)
}
return math.Sqrt(sum)
} | go | {
"resource": ""
} |
q36055 | reflect | train | func (nm *nelderMead) reflect(vertices vertices, midpoint *nmVertex) *nmVertex {
toScalar := midpoint.subtract(nm.lastVertex(vertices))
toScalar = toScalar.multiply(alpha)
toScalar = midpoint.add(toScalar)
return nm.evaluateWithConstraints(vertices, toScalar)
} | go | {
"resource": ""
} |
q36056 | checkIteration | train | func (nm *nelderMead) checkIteration(vertices vertices) bool {
// this will never be true for += inf
if math.Abs(vertices[0].result-nm.config.Target) < delta {
return false
}
best := vertices[0]
// here we are checking distance convergence. If all vertices
// are near convergence, that is they are all within ... | go | {
"resource": ""
} |
q36057 | NelderMead | train | func NelderMead(config NelderMeadConfiguration) []float64 {
nm := newNelderMead(config)
nm.evaluate()
return nm.results.vertices[0].vars
} | go | {
"resource": ""
} |
q36058 | symSearch | train | func symSearch(u, w Comparators) int {
start, stop, p := 0, len(u), len(w)-1
for start < stop {
mid := (start + stop) / 2
if u[mid].Compare(w[p-mid]) <= 0 {
start = mid + 1
} else {
stop = mid
}
}
return start
} | go | {
"resource": ""
} |
q36059 | swap | train | func swap(u, w Comparators, index int) {
for i := index; i < len(u); i++ {
u[i], w[i-index] = w[i-index], u[i]
}
} | go | {
"resource": ""
} |
q36060 | decomposeForSymMerge | train | func decomposeForSymMerge(length int,
comparators Comparators) (v1 Comparators,
w Comparators, v2 Comparators) {
if length >= len(comparators) {
panic(`INCORRECT PARAMS FOR SYM MERGE.`)
}
overhang := (len(comparators) - length) / 2
v1 = comparators[:overhang]
w = comparators[overhang : overhang+length]
v2 =... | go | {
"resource": ""
} |
q36061 | symBinarySearch | train | func symBinarySearch(u Comparators, start, stop, total int) int {
for start < stop {
mid := (start + stop) / 2
if u[mid].Compare(u[total-mid]) <= 0 {
start = mid + 1
} else {
stop = mid
}
}
return start
} | go | {
"resource": ""
} |
q36062 | symSwap | train | func symSwap(u Comparators, start1, start2, end int) {
for i := 0; i < end; i++ {
u[start1+i], u[start2+i] = u[start2+i], u[start1+i]
}
} | go | {
"resource": ""
} |
q36063 | symRotate | train | func symRotate(u Comparators, start1, start2, end int) {
i := start2 - start1
if i == 0 {
return
}
j := end - start2
if j == 0 {
return
}
if i == j {
symSwap(u, start1, start2, i)
return
}
p := start1 + i
for i != j {
if i > j {
symSwap(u, p-i, p, j)
i -= j
} else {
symSwap(u, p-i, p+j... | go | {
"resource": ""
} |
q36064 | symMerge | train | func symMerge(u Comparators, start1, start2, last int) {
if start1 < start2 && start2 < last {
mid := (start1 + last) / 2
n := mid + start2
var start int
if start2 > mid {
start = symBinarySearch(u, n-last, mid, n-1)
} else {
start = symBinarySearch(u, start1, start2, n-1)
}
end := n - start
sym... | go | {
"resource": ""
} |
q36065 | Int63 | train | func (ls *lockedSource) Int63() (n int64) {
ls.mu.Lock()
n = ls.src.Int63()
ls.mu.Unlock()
return
} | go | {
"resource": ""
} |
q36066 | Seed | train | func (ls *lockedSource) Seed(seed int64) {
ls.mu.Lock()
ls.src.Seed(seed)
ls.mu.Unlock()
} | go | {
"resource": ""
} |
q36067 | init | train | func (sl *SkipList) init(ifc interface{}) {
switch ifc.(type) {
case uint8:
sl.maxLevel = 8
case uint16:
sl.maxLevel = 16
case uint32:
sl.maxLevel = 32
case uint64, uint:
sl.maxLevel = 64
}
sl.cache = make(nodes, sl.maxLevel)
sl.posCache = make(widths, sl.maxLevel)
sl.head = newNode(nil, sl.maxLevel)
} | go | {
"resource": ""
} |
q36068 | GetWithPosition | train | func (sl *SkipList) GetWithPosition(cmp common.Comparator) (common.Comparator, uint64) {
n, pos := sl.search(cmp, nil, nil)
if n == nil {
return nil, 0
}
return n.entry, pos - 1
} | go | {
"resource": ""
} |
q36069 | ByPosition | train | func (sl *SkipList) ByPosition(position uint64) common.Comparator {
n, _ := sl.searchByPosition(position+1, nil, nil)
if n == nil {
return nil
}
return n.entry
} | go | {
"resource": ""
} |
q36070 | InsertAtPosition | train | func (sl *SkipList) InsertAtPosition(position uint64, cmp common.Comparator) {
sl.insertAtPosition(position, cmp)
} | go | {
"resource": ""
} |
q36071 | ReplaceAtPosition | train | func (sl *SkipList) ReplaceAtPosition(position uint64, cmp common.Comparator) {
sl.replaceAtPosition(position, cmp)
} | go | {
"resource": ""
} |
q36072 | Iter | train | func (sl *SkipList) Iter(cmp common.Comparator) Iterator {
return sl.iter(cmp)
} | go | {
"resource": ""
} |
q36073 | SplitAt | train | func (sl *SkipList) SplitAt(index uint64) (*SkipList, *SkipList) {
index++ // 0-index offset
if index >= sl.Len() {
return sl, nil
}
return splitAt(sl, index)
} | go | {
"resource": ""
} |
q36074 | Less | train | func (c Comparators) Less(i, j int) bool {
return c[i].Compare(c[j]) < 0
} | go | {
"resource": ""
} |
q36075 | Swap | train | func (c Comparators) Swap(i, j int) {
c[j], c[i] = c[i], c[j]
} | go | {
"resource": ""
} |
q36076 | newNode | train | func newNode(cmp common.Comparator, maxLevels uint8) *node {
return &node{
entry: cmp,
forward: make(nodes, maxLevels),
widths: make(widths, maxLevels),
}
} | go | {
"resource": ""
} |
q36077 | GetResult | train | func (f *Future) GetResult() (interface{}, error) {
f.lock.Lock()
if f.triggered {
f.lock.Unlock()
return f.item, f.err
}
f.lock.Unlock()
f.wg.Wait()
return f.item, f.err
} | go | {
"resource": ""
} |
q36078 | HasResult | train | func (f *Future) HasResult() bool {
f.lock.Lock()
hasResult := f.triggered
f.lock.Unlock()
return hasResult
} | go | {
"resource": ""
} |
q36079 | New | train | func New(completer Completer, timeout time.Duration) *Future {
f := &Future{}
f.wg.Add(1)
var wg sync.WaitGroup
wg.Add(1)
go listenForResult(f, completer, timeout, &wg)
wg.Wait()
return f
} | go | {
"resource": ""
} |
q36080 | addAt | train | func (nodes *orderedNodes) addAt(i int, node *node) *node {
if i == len(*nodes) {
*nodes = append(*nodes, node)
return nil
}
if (*nodes)[i].value == node.value {
overwritten := (*nodes)[i]
// this is a duplicate, there can't be a duplicate
// point in the last dimension
(*nodes)[i] = node
return overw... | go | {
"resource": ""
} |
q36081 | getBucketKey | train | func (yfast *YFastTrie) getBucketKey(key uint64) uint64 {
i := key/uint64(yfast.bits) + 1
return uint64(yfast.bits)*i - 1
} | go | {
"resource": ""
} |
q36082 | Insert | train | func (yfast *YFastTrie) Insert(entries ...Entry) Entries {
overwritten := make(Entries, 0, len(entries))
for _, e := range entries {
overwritten = append(overwritten, yfast.insert(e))
}
return overwritten
} | go | {
"resource": ""
} |
q36083 | Delete | train | func (yfast *YFastTrie) Delete(keys ...uint64) Entries {
entries := make(Entries, 0, len(keys))
for _, key := range keys {
entries = append(entries, yfast.delete(key))
}
return entries
} | go | {
"resource": ""
} |
q36084 | Get | train | func (yfast *YFastTrie) Get(key uint64) Entry {
entry := yfast.get(key)
if entry == nil {
return nil
}
return entry
} | go | {
"resource": ""
} |
q36085 | Successor | train | func (yfast *YFastTrie) Successor(key uint64) Entry {
entry := yfast.successor(key)
if entry == nil {
return nil
}
return entry
} | go | {
"resource": ""
} |
q36086 | Predecessor | train | func (yfast *YFastTrie) Predecessor(key uint64) Entry {
entry := yfast.predecessor(key)
if entry == nil {
return nil
}
return entry
} | go | {
"resource": ""
} |
q36087 | V | train | func (g *SimpleGraph) V() int {
g.mutex.RLock()
defer g.mutex.RUnlock()
return g.v
} | go | {
"resource": ""
} |
q36088 | E | train | func (g *SimpleGraph) E() int {
g.mutex.RLock()
defer g.mutex.RUnlock()
return g.e
} | go | {
"resource": ""
} |
q36089 | AddEdge | train | func (g *SimpleGraph) AddEdge(v, w interface{}) error {
g.mutex.Lock()
defer g.mutex.Unlock()
if v == w {
return ErrSelfLoop
}
g.addVertex(v)
g.addVertex(w)
if _, ok := g.adjacencyList[v][w]; ok {
return ErrParallelEdge
}
g.adjacencyList[v][w] = struct{}{}
g.adjacencyList[w][v] = struct{}{}
g.e++
re... | go | {
"resource": ""
} |
q36090 | Adj | train | func (g *SimpleGraph) Adj(v interface{}) ([]interface{}, error) {
g.mutex.RLock()
defer g.mutex.RUnlock()
deg, err := g.Degree(v)
if err != nil {
return nil, ErrVertexNotFound
}
adj := make([]interface{}, deg)
i := 0
for key := range g.adjacencyList[v] {
adj[i] = key
i++
}
return adj, nil
} | go | {
"resource": ""
} |
q36091 | Degree | train | func (g *SimpleGraph) Degree(v interface{}) (int, error) {
g.mutex.RLock()
defer g.mutex.RUnlock()
val, ok := g.adjacencyList[v]
if !ok {
return 0, ErrVertexNotFound
}
return len(val), nil
} | go | {
"resource": ""
} |
q36092 | pop | train | func (p *path) pop() *pathBundle {
if pb := p.tail; pb != nil {
p.tail = pb.prev
pb.prev = nil
return pb
}
return nil
} | go | {
"resource": ""
} |
q36093 | copyToGen | train | func (i *iNode) copyToGen(gen *generation, ctrie *Ctrie) *iNode {
nin := &iNode{gen: gen}
main := gcasRead(i, ctrie)
atomic.StorePointer(
(*unsafe.Pointer)(unsafe.Pointer(&nin.main)), unsafe.Pointer(main))
return nin
} | go | {
"resource": ""
} |
q36094 | newMainNode | train | func newMainNode(x *sNode, xhc uint32, y *sNode, yhc uint32, lev uint, gen *generation) *mainNode {
if lev < exp2 {
xidx := (xhc >> lev) & 0x1f
yidx := (yhc >> lev) & 0x1f
bmp := uint32((1 << xidx) | (1 << yidx))
if xidx == yidx {
// Recurse when indexes are equal.
main := newMainNode(x, xhc, y, yhc, le... | go | {
"resource": ""
} |
q36095 | inserted | train | func (c *cNode) inserted(pos, flag uint32, br branch, gen *generation) *cNode {
length := uint32(len(c.array))
bmp := c.bmp
array := make([]branch, length+1)
copy(array, c.array)
array[pos] = br
for i, x := pos, uint32(0); x < length-pos; i++ {
array[i+1] = c.array[i]
x++
}
ncn := &cNode{bmp: bmp | flag, ar... | go | {
"resource": ""
} |
q36096 | updated | train | func (c *cNode) updated(pos uint32, br branch, gen *generation) *cNode {
array := make([]branch, len(c.array))
copy(array, c.array)
array[pos] = br
ncn := &cNode{bmp: c.bmp, array: array, gen: gen}
return ncn
} | go | {
"resource": ""
} |
q36097 | renewed | train | func (c *cNode) renewed(gen *generation, ctrie *Ctrie) *cNode {
array := make([]branch, len(c.array))
for i, br := range c.array {
switch t := br.(type) {
case *iNode:
array[i] = t.copyToGen(gen, ctrie)
default:
array[i] = br
}
}
return &cNode{bmp: c.bmp, array: array, gen: gen}
} | go | {
"resource": ""
} |
q36098 | untombed | train | func (t *tNode) untombed() *sNode {
return &sNode{&Entry{Key: t.Key, hash: t.hash, Value: t.Value}}
} | go | {
"resource": ""
} |
q36099 | entry | train | func (l *lNode) entry() *sNode {
head, _ := l.Head()
return head.(*sNode)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.