Full Code of Workiva/go-datastructures for AI

gitextract_a5x2r3bc/

├── .github/
│   ├── CODEOWNERS
│   └── workflows/
│       └── tests.yaml
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
├── augmentedtree/
│   ├── atree.go
│   ├── atree_test.go
│   ├── interface.go
│   ├── intervals.go
│   ├── intervals_test.go
│   ├── mock_test.go
│   └── multidimensional_test.go
├── aviary.yaml
├── batcher/
│   ├── batcher.go
│   └── batcher_test.go
├── bitarray/
│   ├── and.go
│   ├── and_test.go
│   ├── bitarray.go
│   ├── bitarray_test.go
│   ├── bitmap.go
│   ├── bitmap_test.go
│   ├── block.go
│   ├── block_test.go
│   ├── encoding.go
│   ├── encoding_test.go
│   ├── error.go
│   ├── interface.go
│   ├── iterator.go
│   ├── nand.go
│   ├── nand_test.go
│   ├── or.go
│   ├── or_test.go
│   ├── sparse_bitarray.go
│   ├── sparse_bitarray_test.go
│   └── util.go
├── btree/
│   ├── _link/
│   │   ├── interface.go
│   │   ├── key.go
│   │   ├── mock_test.go
│   │   ├── node.go
│   │   ├── node_test.go
│   │   ├── tree.go
│   │   └── tree_test.go
│   ├── immutable/
│   │   ├── add.go
│   │   ├── cacher.go
│   │   ├── config.go
│   │   ├── delete.go
│   │   ├── error.go
│   │   ├── interface.go
│   │   ├── item.go
│   │   ├── node.go
│   │   ├── node_gen.go
│   │   ├── path.go
│   │   ├── query.go
│   │   ├── rt.go
│   │   ├── rt_gen.go
│   │   └── rt_test.go
│   ├── palm/
│   │   ├── action.go
│   │   ├── interface.go
│   │   ├── key.go
│   │   ├── mock_test.go
│   │   ├── node.go
│   │   ├── tree.go
│   │   └── tree_test.go
│   └── plus/
│       ├── btree.go
│       ├── btree_test.go
│       ├── interface.go
│       ├── iterator.go
│       ├── mock_test.go
│       ├── node.go
│       └── node_test.go
├── cache/
│   ├── cache.go
│   └── cache_test.go
├── common/
│   └── interface.go
├── datastructures.go
├── documentation.md
├── fibheap/
│   ├── Test Generator/
│   │   ├── EnqDecrKey.py
│   │   ├── EnqDelete.py
│   │   ├── EnqDeqMin.py
│   │   ├── Merge.py
│   │   └── README.md
│   ├── benchmarks.txt
│   ├── fibheap.go
│   ├── fibheap_examples_test.go
│   ├── fibheap_single_example_test.go
│   └── fibheap_test.go
├── futures/
│   ├── futures.go
│   ├── futures_test.go
│   ├── selectable.go
│   └── selectable_test.go
├── go.mod
├── go.sum
├── graph/
│   ├── simple.go
│   └── simple_test.go
├── hashmap/
│   └── fastinteger/
│       ├── hash.go
│       ├── hash_test.go
│       ├── hashmap.go
│       └── hashmap_test.go
├── list/
│   ├── persistent.go
│   └── persistent_test.go
├── mock/
│   ├── batcher.go
│   └── rangetree.go
├── numerics/
│   ├── hilbert/
│   │   ├── hilbert.go
│   │   └── hilbert_test.go
│   └── optimization/
│       ├── global.go
│       ├── nelder_mead.go
│       └── nelder_mead_test.go
├── queue/
│   ├── error.go
│   ├── mock_test.go
│   ├── priority_queue.go
│   ├── priority_queue_test.go
│   ├── queue.go
│   ├── queue_test.go
│   ├── ring.go
│   └── ring_test.go
├── rangetree/
│   ├── entries.go
│   ├── entries_test.go
│   ├── error.go
│   ├── immutable.go
│   ├── immutable_test.go
│   ├── interface.go
│   ├── mock_test.go
│   ├── node.go
│   ├── ordered.go
│   ├── ordered_test.go
│   ├── orderedtree.go
│   ├── orderedtree_test.go
│   └── skiplist/
│       ├── mock_test.go
│       ├── skiplist.go
│       └── skiplist_test.go
├── rtree/
│   ├── hilbert/
│   │   ├── action.go
│   │   ├── cpu.prof
│   │   ├── hilbert.go
│   │   ├── mock_test.go
│   │   ├── node.go
│   │   ├── rectangle.go
│   │   ├── tree.go
│   │   └── tree_test.go
│   └── interface.go
├── set/
│   ├── dict.go
│   └── dict_test.go
├── slice/
│   ├── int64.go
│   ├── int64_test.go
│   └── skip/
│       ├── interface.go
│       ├── iterator.go
│       ├── iterator_test.go
│       ├── mock_test.go
│       ├── node.go
│       ├── skip.go
│       └── skip_test.go
├── sort/
│   ├── interface.go
│   ├── sort.go
│   ├── sort_test.go
│   ├── symmerge.go
│   └── symmerge_test.go
├── threadsafe/
│   └── err/
│       ├── error.go
│       └── error_test.go
├── tree/
│   └── avl/
│       ├── avl.go
│       ├── avl_test.go
│       ├── interface.go
│       ├── mock_test.go
│       └── node.go
└── trie/
    ├── ctrie/
    │   ├── ctrie.go
    │   └── ctrie_test.go
    ├── dtrie/
    │   ├── dtrie.go
    │   ├── dtrie_test.go
    │   ├── node.go
    │   └── util.go
    ├── xfast/
    │   ├── iterator.go
    │   ├── iterator_test.go
    │   ├── mock_test.go
    │   ├── xfast.go
    │   └── xfast_test.go
    └── yfast/
        ├── entries.go
        ├── entries_test.go
        ├── interface.go
        ├── iterator.go
        ├── mock_test.go
        ├── yfast.go
        └── yfast_test.go

SYMBOL INDEX (2051 symbols across 160 files)

FILE: augmentedtree/atree.go
  function intervalOverlaps (line 19) | func intervalOverlaps(n *node, low, high int64, interval Interval, maxDi...
  function overlaps (line 37) | func overlaps(high, otherHigh, low, otherLow int64) bool {
  function compare (line 43) | func compare(nodeLow, ivLow int64, nodeID, ivID uint64) int {
  type node (line 55) | type node struct
    method query (line 63) | func (n *node) query(low, high int64, interval Interval, maxDimension ...
    method adjustRanges (line 77) | func (n *node) adjustRanges() {
    method adjustRange (line 87) | func (n *node) adjustRange() {
  function newDummy (line 92) | func newDummy() node {
  function newNode (line 98) | func newNode(interval Interval, min, max int64, dimension uint64) *node {
  type tree (line 113) | type tree struct
    method Traverse (line 119) | func (t *tree) Traverse(fn func(id Interval)) {
    method resetDummy (line 137) | func (tree *tree) resetDummy() {
    method Len (line 143) | func (tree *tree) Len() uint64 {
    method add (line 148) | func (tree *tree) add(iv Interval) {
    method Add (line 222) | func (tree *tree) Add(intervals ...Interval) {
    method delete (line 229) | func (tree *tree) delete(iv Interval) {
    method Delete (line 310) | func (tree *tree) Delete(intervals ...Interval) {
    method Query (line 322) | func (tree *tree) Query(interval Interval) Intervals {
  function isRed (line 340) | func isRed(node *node) bool {
  function setMax (line 344) | func setMax(parent *node) {
  function setMin (line 356) | func setMin(parent *node) {
  function rotate (line 371) | func rotate(parent *node, dir int) *node {
  function doubleRotate (line 388) | func doubleRotate(parent *node, dir int) *node {
  function intFromBool (line 395) | func intFromBool(value bool) int {
  function takeOpposite (line 403) | func takeOpposite(value int) int {
  function newTree (line 407) | func newTree(maxDimension uint64) *tree {
  function New (line 416) | func New(dimensions uint64) Tree {

FILE: augmentedtree/atree_test.go
  function min (line 25) | func min(one, two int64) int64 {
  function max (line 41) | func max(one, two int64) int64 {
  function checkRedBlack (line 57) | func checkRedBlack(tb testing.TB, node *node, dimension int) (int64, int...
  function constructSingleDimensionTestTree (line 115) | func constructSingleDimensionTestTree(number int) (*tree, Intervals) {
  function TestSimpleAddNilRoot (line 128) | func TestSimpleAddNilRoot(t *testing.T) {
  function TestSimpleAddRootLeft (line 143) | func TestSimpleAddRootLeft(t *testing.T) {
  function TestSimpleAddRootRight (line 163) | func TestSimpleAddRootRight(t *testing.T) {
  function TestAddRootLeftAndRight (line 183) | func TestAddRootLeftAndRight(t *testing.T) {
  function TestAddRebalanceInOrder (line 209) | func TestAddRebalanceInOrder(t *testing.T) {
  function TestAddRebalanceOutOfOrder (line 223) | func TestAddRebalanceOutOfOrder(t *testing.T) {
  function TestAddRebalanceRandomOrder (line 237) | func TestAddRebalanceRandomOrder(t *testing.T) {
  function TestAddLargeNumberOfItems (line 253) | func TestAddLargeNumberOfItems(t *testing.T) {
  function BenchmarkAddItems (line 268) | func BenchmarkAddItems(b *testing.B) {
  function BenchmarkQueryItems (line 285) | func BenchmarkQueryItems(b *testing.B) {
  function constructSingleDimensionQueryTestTree (line 303) | func constructSingleDimensionQueryTestTree() (
  function TestSimpleQuery (line 320) | func TestSimpleQuery(t *testing.T) {
  function TestRightQuery (line 329) | func TestRightQuery(t *testing.T) {
  function TestLeftQuery (line 338) | func TestLeftQuery(t *testing.T) {
  function TestMatchingQuery (line 347) | func TestMatchingQuery(t *testing.T) {
  function TestNoMatchLeft (line 356) | func TestNoMatchLeft(t *testing.T) {
  function TestNoMatchRight (line 365) | func TestNoMatchRight(t *testing.T) {
  function TestAllQuery (line 374) | func TestAllQuery(t *testing.T) {
  function TestQueryDuplicate (line 383) | func TestQueryDuplicate(t *testing.T) {
  function TestRootDelete (line 394) | func TestRootDelete(t *testing.T) {
  function TestDeleteLeft (line 407) | func TestDeleteLeft(t *testing.T) {
  function TestDeleteRight (line 420) | func TestDeleteRight(t *testing.T) {
  function TestDeleteCenter (line 433) | func TestDeleteCenter(t *testing.T) {
  function TestDeleteRebalanceInOrder (line 446) | func TestDeleteRebalanceInOrder(t *testing.T) {
  function TestDeleteRebalanceOutOfOrder (line 467) | func TestDeleteRebalanceOutOfOrder(t *testing.T) {
  function TestDeleteRebalanceRandomOrder (line 487) | func TestDeleteRebalanceRandomOrder(t *testing.T) {
  function TestDeleteEmptyTree (line 509) | func TestDeleteEmptyTree(t *testing.T) {
  function BenchmarkDeleteItems (line 517) | func BenchmarkDeleteItems(b *testing.B) {
  function TestAddDuplicateRanges (line 540) | func TestAddDuplicateRanges(t *testing.T) {
  function TestAddDeleteDuplicatesRebalanceInOrder (line 552) | func TestAddDeleteDuplicatesRebalanceInOrder(t *testing.T) {
  function TestAddDeleteDuplicatesRebalanceReverseOrder (line 568) | func TestAddDeleteDuplicatesRebalanceReverseOrder(t *testing.T) {
  function TestAddDeleteDuplicatesRebalanceRandomOrder (line 584) | func TestAddDeleteDuplicatesRebalanceRandomOrder(t *testing.T) {
  function TestInsertDuplicateIntervalsToRoot (line 601) | func TestInsertDuplicateIntervalsToRoot(t *testing.T) {
  function TestInsertDuplicateIntervalChildren (line 612) | func TestInsertDuplicateIntervalChildren(t *testing.T) {
  function TestTraverse (line 626) | func TestTraverse(t *testing.T) {

FILE: augmentedtree/interface.go
  type Interval (line 41) | type Interval interface
  type Tree (line 61) | type Tree interface

FILE: augmentedtree/intervals.go
  type Intervals (line 28) | type Intervals
    method Dispose (line 32) | func (ivs *Intervals) Dispose() {

FILE: augmentedtree/intervals_test.go
  function TestIntervalsDispose (line 25) | func TestIntervalsDispose(t *testing.T) {

FILE: augmentedtree/mock_test.go
  type dimension (line 21) | type dimension struct
  type mockInterval (line 25) | type mockInterval struct
    method checkDimension (line 30) | func (mi *mockInterval) checkDimension(dimension uint64) {
    method LowAtDimension (line 36) | func (mi *mockInterval) LowAtDimension(dimension uint64) int64 {
    method HighAtDimension (line 40) | func (mi *mockInterval) HighAtDimension(dimension uint64) int64 {
    method OverlapsAtDimension (line 44) | func (mi *mockInterval) OverlapsAtDimension(iv Interval, dimension uin...
    method ID (line 49) | func (mi mockInterval) ID() uint64 {
  function constructSingleDimensionInterval (line 53) | func constructSingleDimensionInterval(low, high int64, id uint64) *mockI...
  function constructMultiDimensionInterval (line 57) | func constructMultiDimensionInterval(id uint64, dimensions ...*dimension...

FILE: augmentedtree/multidimensional_test.go
  function constructMultiDimensionQueryTestTree (line 25) | func constructMultiDimensionQueryTestTree() (
  function TestRootAddMultipleDimensions (line 48) | func TestRootAddMultipleDimensions(t *testing.T) {
  function TestMultipleAddMultipleDimensions (line 72) | func TestMultipleAddMultipleDimensions(t *testing.T) {
  function TestAddRebalanceInOrderMultiDimensions (line 113) | func TestAddRebalanceInOrderMultiDimensions(t *testing.T) {
  function TestAddRebalanceReverseOrderMultiDimensions (line 133) | func TestAddRebalanceReverseOrderMultiDimensions(t *testing.T) {
  function TestAddRebalanceRandomOrderMultiDimensions (line 153) | func TestAddRebalanceRandomOrderMultiDimensions(t *testing.T) {
  function TestAddLargeNumbersMultiDimensions (line 175) | func TestAddLargeNumbersMultiDimensions(t *testing.T) {
  function BenchmarkAddItemsMultiDimensions (line 196) | func BenchmarkAddItemsMultiDimensions(b *testing.B) {
  function BenchmarkQueryItemsMultiDimensions (line 215) | func BenchmarkQueryItemsMultiDimensions(b *testing.B) {
  function TestRootDeleteMultiDimensions (line 239) | func TestRootDeleteMultiDimensions(t *testing.T) {
  function TestDeleteMultiDimensions (line 258) | func TestDeleteMultiDimensions(t *testing.T) {
  function TestDeleteRebalanceInOrderMultiDimensions (line 301) | func TestDeleteRebalanceInOrderMultiDimensions(t *testing.T) {
  function TestDeleteRebalanceReverseOrderMultiDimensions (line 328) | func TestDeleteRebalanceReverseOrderMultiDimensions(t *testing.T) {
  function TestDeleteRebalanceRandomOrderMultiDimensions (line 355) | func TestDeleteRebalanceRandomOrderMultiDimensions(t *testing.T) {
  function TestDeleteEmptyTreeMultiDimensions (line 384) | func TestDeleteEmptyTreeMultiDimensions(t *testing.T) {
  function BenchmarkDeleteItemsMultiDimensions (line 395) | func BenchmarkDeleteItemsMultiDimensions(b *testing.B) {
  function TestAddDeleteDuplicatesRebalanceInOrderMultiDimensions (line 420) | func TestAddDeleteDuplicatesRebalanceInOrderMultiDimensions(t *testing.T) {
  function TestAddDeleteDuplicatesRebalanceReverseOrderMultiDimensions (line 437) | func TestAddDeleteDuplicatesRebalanceReverseOrderMultiDimensions(t *test...
  function TestAddDeleteDuplicatesRebalanceRandomOrderMultiDimensions (line 454) | func TestAddDeleteDuplicatesRebalanceRandomOrderMultiDimensions(t *testi...

FILE: batcher/batcher.go
  type mutex (line 27) | type mutex struct
    method Lock (line 37) | func (m *mutex) Lock() {
    method Unlock (line 41) | func (m *mutex) Unlock() {
    method TryLock (line 45) | func (m *mutex) TryLock() bool {
  function newMutex (line 33) | func newMutex() *mutex {
  type Batcher (line 55) | type Batcher interface
  type CalculateBytes (line 79) | type CalculateBytes
  type basicBatcher (line 81) | type basicBatcher struct
    method Put (line 121) | func (b *basicBatcher) Put(item interface{}) error {
    method Get (line 146) | func (b *basicBatcher) Get() ([]interface{}, error) {
    method Flush (line 213) | func (b *basicBatcher) Flush() error {
    method Dispose (line 229) | func (b *basicBatcher) Dispose() {
    method IsDisposed (line 257) | func (b *basicBatcher) IsDisposed() bool {
    method flush (line 266) | func (b *basicBatcher) flush() {
    method ready (line 272) | func (b *basicBatcher) ready() bool {
    method drainBatchChan (line 282) | func (b *basicBatcher) drainBatchChan() {
  function New (line 104) | func New(maxTime time.Duration, maxItems, maxBytes, queueLen uint, calcu...

FILE: batcher/batcher_test.go
  function TestNoCalculateBytes (line 27) | func TestNoCalculateBytes(t *testing.T) {
  function TestMaxItems (line 32) | func TestMaxItems(t *testing.T) {
  function TestMaxBytes (line 48) | func TestMaxBytes(t *testing.T) {
  function TestMaxTime (line 66) | func TestMaxTime(t *testing.T) {
  function TestFlush (line 92) | func TestFlush(t *testing.T) {
  function TestMultiConsumer (line 111) | func TestMultiConsumer(t *testing.T) {
  function TestDispose (line 138) | func TestDispose(t *testing.T) {
  function TestIsDisposed (line 170) | func TestIsDisposed(t *testing.T) {

FILE: bitarray/and.go
  function andSparseWithSparseBitArray (line 19) | func andSparseWithSparseBitArray(sba, other *sparseBitArray) BitArray {
  function andSparseWithDenseBitArray (line 73) | func andSparseWithDenseBitArray(sba *sparseBitArray, other *bitArray) Bi...
  function andDenseWithDenseBitArray (line 121) | func andDenseWithDenseBitArray(dba, other *bitArray) BitArray {

FILE: bitarray/and_test.go
  function checkBit (line 26) | func checkBit(t *testing.T, ba BitArray, position uint64, expected bool) {
  function TestAndSparseWithSparseBitArray (line 37) | func TestAndSparseWithSparseBitArray(t *testing.T) {
  function TestAndSparseWithDenseBitArray (line 78) | func TestAndSparseWithDenseBitArray(t *testing.T) {
  function TestAndSparseWithSmallerDenseBitArray (line 108) | func TestAndSparseWithSmallerDenseBitArray(t *testing.T) {
  function TestAndDenseWithDenseBitArray (line 139) | func TestAndDenseWithDenseBitArray(t *testing.T) {
  function TestAndSparseWithEmptySparse (line 165) | func TestAndSparseWithEmptySparse(t *testing.T) {
  function TestAndSparseWithEmptyDense (line 178) | func TestAndSparseWithEmptyDense(t *testing.T) {
  function TestAndDenseWithEmptyDense (line 193) | func TestAndDenseWithEmptyDense(t *testing.T) {

FILE: bitarray/bitarray.go
  type bitArray (line 26) | type bitArray struct
    method setLowest (line 37) | func (ba *bitArray) setLowest() {
    method setHighest (line 54) | func (ba *bitArray) setHighest() {
    method Capacity (line 72) | func (ba *bitArray) Capacity() uint64 {
    method ToNums (line 77) | func (ba *bitArray) ToNums() []uint64 {
    method SetBit (line 87) | func (ba *bitArray) SetBit(k uint64) error {
    method GetBit (line 111) | func (ba *bitArray) GetBit(k uint64) (bool, error) {
    method GetSetBits (line 122) | func (ba *bitArray) GetSetBits(from uint64, buffer []uint64) []uint64 {
    method ClearBit (line 189) | func (ba *bitArray) ClearBit(k uint64) error {
    method Count (line 210) | func (ba *bitArray) Count() int {
    method Or (line 220) | func (ba *bitArray) Or(other BitArray) BitArray {
    method And (line 230) | func (ba *bitArray) And(other BitArray) BitArray {
    method Nand (line 240) | func (ba *bitArray) Nand(other BitArray) BitArray {
    method Reset (line 249) | func (ba *bitArray) Reset() {
    method Equals (line 257) | func (ba *bitArray) Equals(other BitArray) bool {
    method Intersects (line 296) | func (ba *bitArray) Intersects(other BitArray) bool {
    method Blocks (line 309) | func (ba *bitArray) Blocks() Iterator {
    method IsEmpty (line 313) | func (ba *bitArray) IsEmpty() bool {
    method complement (line 318) | func (ba *bitArray) complement() {
    method intersectsSparseBitArray (line 329) | func (ba *bitArray) intersectsSparseBitArray(other *sparseBitArray) bo...
    method intersectsDenseBitArray (line 339) | func (ba *bitArray) intersectsDenseBitArray(other *bitArray) bool {
    method copy (line 349) | func (ba *bitArray) copy() BitArray {
  function getIndexAndRemainder (line 33) | func getIndexAndRemainder(k uint64) (uint64, uint64) {
  function getSetBitsInBlocks (line 135) | func getSetBitsInBlocks(
  function newBitArray (line 363) | func newBitArray(size uint64, args ...bool) *bitArray {
  function NewBitArray (line 390) | func NewBitArray(size uint64, args ...bool) BitArray {

FILE: bitarray/bitarray_test.go
  function TestBitOperations (line 26) | func TestBitOperations(t *testing.T) {
  function TestDuplicateOperation (line 81) | func TestDuplicateOperation(t *testing.T) {
  function TestOutOfBounds (line 123) | func TestOutOfBounds(t *testing.T) {
  function TestIsEmpty (line 138) | func TestIsEmpty(t *testing.T) {
  function TestCount (line 146) | func TestCount(t *testing.T) {
  function TestClear (line 168) | func TestClear(t *testing.T) {
  function BenchmarkGetBit (line 203) | func BenchmarkGetBit(b *testing.B) {
  function TestGetSetBits (line 221) | func TestGetSetBits(t *testing.T) {
  function BenchmarkGetSetBits (line 250) | func BenchmarkGetSetBits(b *testing.B) {
  function TestEquality (line 268) | func TestEquality(t *testing.T) {
  function BenchmarkEquality (line 290) | func BenchmarkEquality(b *testing.B) {
  function TestIntersects (line 301) | func TestIntersects(t *testing.T) {
  function BenchmarkIntersects (line 328) | func BenchmarkIntersects(b *testing.B) {
  function TestComplement (line 342) | func TestComplement(t *testing.T) {
  function BenchmarkComplement (line 358) | func BenchmarkComplement(b *testing.B) {
  function TestSetHighestLowest (line 368) | func TestSetHighestLowest(t *testing.T) {
  function TestGetBitAtCapacity (line 386) | func TestGetBitAtCapacity(t *testing.T) {
  function TestSetBitAtCapacity (line 392) | func TestSetBitAtCapacity(t *testing.T) {
  function TestClearBitAtCapacity (line 398) | func TestClearBitAtCapacity(t *testing.T) {
  function TestClearHighestLowest (line 404) | func TestClearHighestLowest(t *testing.T) {
  function TestComplementResetsBounds (line 440) | func TestComplementResetsBounds(t *testing.T) {
  function TestBitArrayIntersectsSparse (line 449) | func TestBitArrayIntersectsSparse(t *testing.T) {
  function TestBitArrayEqualsSparse (line 468) | func TestBitArrayEqualsSparse(t *testing.T) {
  function TestConstructorSetBitArray (line 487) | func TestConstructorSetBitArray(t *testing.T) {
  function TestCopyBitArray (line 498) | func TestCopyBitArray(t *testing.T) {
  function BenchmarkDenseIntersectsCompressed (line 510) | func BenchmarkDenseIntersectsCompressed(b *testing.B) {
  function TestBitArrayToNums (line 527) | func TestBitArrayToNums(t *testing.T) {
  function BenchmarkBitArrayToNums (line 540) | func BenchmarkBitArrayToNums(b *testing.B) {

FILE: bitarray/bitmap.go
  type Bitmap32 (line 32) | type Bitmap32
    method SetBit (line 35) | func (b Bitmap32) SetBit(pos uint) Bitmap32 {
    method ClearBit (line 40) | func (b Bitmap32) ClearBit(pos uint) Bitmap32 {
    method GetBit (line 45) | func (b Bitmap32) GetBit(pos uint) bool {
    method PopCount (line 50) | func (b Bitmap32) PopCount() int {
  type Bitmap64 (line 61) | type Bitmap64
    method SetBit (line 64) | func (b Bitmap64) SetBit(pos uint) Bitmap64 {
    method ClearBit (line 69) | func (b Bitmap64) ClearBit(pos uint) Bitmap64 {
    method GetBit (line 74) | func (b Bitmap64) GetBit(pos uint) bool {
    method PopCount (line 79) | func (b Bitmap64) PopCount() int {

FILE: bitarray/bitmap_test.go
  function TestBitmap32_PopCount (line 35) | func TestBitmap32_PopCount(t *testing.T) {
  function TestBitmap64_PopCount (line 48) | func TestBitmap64_PopCount(t *testing.T) {
  function TestBitmap32_SetBit (line 61) | func TestBitmap32_SetBit(t *testing.T) {
  function TestBitmap32_ClearBit (line 66) | func TestBitmap32_ClearBit(t *testing.T) {
  function TestBitmap32_zGetBit (line 71) | func TestBitmap32_zGetBit(t *testing.T) {
  function TestBitmap64_SetBit (line 76) | func TestBitmap64_SetBit(t *testing.T) {
  function TestBitmap64_ClearBit (line 81) | func TestBitmap64_ClearBit(t *testing.T) {
  function TestBitmap64_GetBit (line 86) | func TestBitmap64_GetBit(t *testing.T) {
  function BenchmarkBitmap32_PopCount (line 91) | func BenchmarkBitmap32_PopCount(b *testing.B) {
  function BenchmarkBitmap64_PopCount (line 99) | func BenchmarkBitmap64_PopCount(b *testing.B) {

FILE: bitarray/block.go
  type block (line 27) | type block
    method toNums (line 38) | func (b block) toNums(offset uint64, nums *[]uint64) {
    method findLeftPosition (line 46) | func (b block) findLeftPosition() uint64 {
    method findRightPosition (line 57) | func (b block) findRightPosition() uint64 {
    method insert (line 68) | func (b block) insert(position uint64) block {
    method remove (line 72) | func (b block) remove(position uint64) block {
    method or (line 76) | func (b block) or(other block) block {
    method and (line 80) | func (b block) and(other block) block {
    method nand (line 84) | func (b block) nand(other block) block {
    method get (line 88) | func (b block) get(position uint64) bool {
    method equals (line 92) | func (b block) equals(other block) bool {
    method intersects (line 96) | func (b block) intersects(other block) bool {
    method String (line 100) | func (b block) String() string {
  constant s (line 33) | s = uint64(unsafe.Sizeof(block(0)) * 8)
  constant maximumBlock (line 36) | maximumBlock = block(0) | ^block(0)

FILE: bitarray/block_test.go
  function TestBlockToNums (line 25) | func TestBlockToNums(t *testing.T) {
  function BenchmarkBlockToNums (line 38) | func BenchmarkBlockToNums(b *testing.B) {

FILE: bitarray/encoding.go
  function Marshal (line 28) | func Marshal(ba BitArray) ([]byte, error) {
  function Unmarshal (line 40) | func Unmarshal(input []byte) (BitArray, error) {
  method Serialize (line 64) | func (ba *sparseBitArray) Serialize() ([]byte, error) {
  function Uint64FromBytes (line 102) | func Uint64FromBytes(b []byte) (uint64, int) {
  method Deserialize (line 117) | func (ret *sparseBitArray) Deserialize(incoming []byte) error {
  method Serialize (line 160) | func (ba *bitArray) Serialize() ([]byte, error) {
  method Deserialize (line 200) | func (ret *bitArray) Deserialize(incoming []byte) error {

FILE: bitarray/encoding_test.go
  function TestSparseBitArraySerialization (line 25) | func TestSparseBitArraySerialization(t *testing.T) {
  function TestBitArraySerialization (line 49) | func TestBitArraySerialization(t *testing.T) {
  function TestBitArrayMarshalUnmarshal (line 75) | func TestBitArrayMarshalUnmarshal(t *testing.T) {
  function TestSparseBitArrayMarshalUnmarshal (line 96) | func TestSparseBitArrayMarshalUnmarshal(t *testing.T) {
  function TestUnmarshalErrors (line 117) | func TestUnmarshalErrors(t *testing.T) {

FILE: bitarray/error.go
  type OutOfRangeError (line 23) | type OutOfRangeError
    method Error (line 26) | func (err OutOfRangeError) Error() string {

FILE: bitarray/interface.go
  type BitArray (line 30) | type BitArray interface
  type Iterator (line 81) | type Iterator interface

FILE: bitarray/iterator.go
  type sparseBitArrayIterator (line 19) | type sparseBitArrayIterator struct
    method Next (line 26) | func (iter *sparseBitArrayIterator) Next() bool {
    method Value (line 32) | func (iter *sparseBitArrayIterator) Value() (uint64, block) {
  function newCompressedBitArrayIterator (line 36) | func newCompressedBitArrayIterator(sba *sparseBitArray) *sparseBitArrayI...
  type bitArrayIterator (line 43) | type bitArrayIterator struct
    method Next (line 51) | func (iter *bitArrayIterator) Next() bool {
    method Value (line 57) | func (iter *bitArrayIterator) Value() (uint64, block) {
  function newBitArrayIterator (line 61) | func newBitArrayIterator(ba *bitArray) *bitArrayIterator {

FILE: bitarray/nand.go
  function nandSparseWithSparseBitArray (line 19) | func nandSparseWithSparseBitArray(sba, other *sparseBitArray) BitArray {
  function nandSparseWithDenseBitArray (line 86) | func nandSparseWithDenseBitArray(sba *sparseBitArray, other *bitArray) B...
  function nandDenseWithSparseBitArray (line 118) | func nandDenseWithSparseBitArray(sba *bitArray, other *sparseBitArray) B...
  function nandDenseWithDenseBitArray (line 139) | func nandDenseWithDenseBitArray(dba, other *bitArray) BitArray {

FILE: bitarray/nand_test.go
  function TestNandSparseWithSparseBitArray (line 25) | func TestNandSparseWithSparseBitArray(t *testing.T) {
  function TestNandSparseWithDenseBitArray (line 66) | func TestNandSparseWithDenseBitArray(t *testing.T) {
  function TestNandDenseWithSparseBitArray (line 96) | func TestNandDenseWithSparseBitArray(t *testing.T) {
  function TestNandSparseWithSmallerDenseBitArray (line 126) | func TestNandSparseWithSmallerDenseBitArray(t *testing.T) {
  function TestNandDenseWithDenseBitArray (line 160) | func TestNandDenseWithDenseBitArray(t *testing.T) {
  function TestNandSparseWithEmptySparse (line 196) | func TestNandSparseWithEmptySparse(t *testing.T) {
  function TestNandSparseWithEmptyDense (line 209) | func TestNandSparseWithEmptyDense(t *testing.T) {
  function TestNandDenseWithEmptyDense (line 224) | func TestNandDenseWithEmptyDense(t *testing.T) {
  function BenchmarkNandSparseWithSparse (line 238) | func BenchmarkNandSparseWithSparse(b *testing.B) {
  function BenchmarkNandSparseWithDense (line 258) | func BenchmarkNandSparseWithDense(b *testing.B) {
  function BenchmarkNandDenseWithSparse (line 278) | func BenchmarkNandDenseWithSparse(b *testing.B) {
  function BenchmarkNandDenseWithDense (line 298) | func BenchmarkNandDenseWithDense(b *testing.B) {

FILE: bitarray/or.go
  function orSparseWithSparseBitArray (line 19) | func orSparseWithSparseBitArray(sba *sparseBitArray,
  function orSparseWithDenseBitArray (line 76) | func orSparseWithDenseBitArray(sba *sparseBitArray, other *bitArray) Bit...
  function orDenseWithDenseBitArray (line 121) | func orDenseWithDenseBitArray(dba *bitArray, other *bitArray) BitArray {

FILE: bitarray/or_test.go
  function TestOrSparseWithSparseBitArray (line 25) | func TestOrSparseWithSparseBitArray(t *testing.T) {
  function BenchmarkOrSparseWithSparse (line 74) | func BenchmarkOrSparseWithSparse(b *testing.B) {
  function TestOrSparseWithDenseBitArray (line 97) | func TestOrSparseWithDenseBitArray(t *testing.T) {
  function BenchmarkOrSparseWithDense (line 144) | func BenchmarkOrSparseWithDense(b *testing.B) {
  function TestOrDenseWithDenseBitArray (line 167) | func TestOrDenseWithDenseBitArray(t *testing.T) {
  function BenchmarkOrDenseWithDense (line 207) | func BenchmarkOrDenseWithDense(b *testing.B) {
  function TestOrSparseWithEmptySparse (line 230) | func TestOrSparseWithEmptySparse(t *testing.T) {
  function TestOrSparseWithEmptyDense (line 246) | func TestOrSparseWithEmptyDense(t *testing.T) {
  function TestOrDenseWithEmptyDense (line 261) | func TestOrDenseWithEmptyDense(t *testing.T) {

FILE: bitarray/sparse_bitarray.go
  type uintSlice (line 27) | type uintSlice
    method Len (line 30) | func (u uintSlice) Len() int64 {
    method Swap (line 35) | func (u uintSlice) Swap(i, j int64) {
    method Less (line 41) | func (u uintSlice) Less(i, j int64) bool {
    method search (line 45) | func (u uintSlice) search(x uint64) int64 {
    method insert (line 49) | func (u *uintSlice) insert(x uint64) (int64, bool) {
    method deleteAtIndex (line 67) | func (u *uintSlice) deleteAtIndex(i int64) {
    method get (line 73) | func (u uintSlice) get(x uint64) int64 {
  type blocks (line 86) | type blocks
    method insert (line 88) | func (b *blocks) insert(index int64) {
    method deleteAtIndex (line 99) | func (b *blocks) deleteAtIndex(i int64) {
  type sparseBitArray (line 105) | type sparseBitArray struct
    method SetBit (line 111) | func (sba *sparseBitArray) SetBit(k uint64) error {
    method GetBit (line 123) | func (sba *sparseBitArray) GetBit(k uint64) (bool, error) {
    method GetSetBits (line 134) | func (sba *sparseBitArray) GetSetBits(from uint64, buffer []uint64) []...
    method ToNums (line 153) | func (sba *sparseBitArray) ToNums() []uint64 {
    method ClearBit (line 169) | func (sba *sparseBitArray) ClearBit(k uint64) error {
    method Reset (line 186) | func (sba *sparseBitArray) Reset() {
    method Blocks (line 192) | func (sba *sparseBitArray) Blocks() Iterator {
    method Capacity (line 198) | func (sba *sparseBitArray) Capacity() uint64 {
    method Equals (line 208) | func (sba *sparseBitArray) Equals(other BitArray) bool {
    method Count (line 250) | func (sba *sparseBitArray) Count() int {
    method Or (line 260) | func (sba *sparseBitArray) Or(other BitArray) BitArray {
    method And (line 270) | func (sba *sparseBitArray) And(other BitArray) BitArray {
    method Nand (line 280) | func (sba *sparseBitArray) Nand(other BitArray) BitArray {
    method IsEmpty (line 288) | func (sba *sparseBitArray) IsEmpty() bool {
    method copy (line 294) | func (sba *sparseBitArray) copy() *sparseBitArray {
    method Intersects (line 307) | func (sba *sparseBitArray) Intersects(other BitArray) bool {
    method IntersectsBetween (line 342) | func (sba *sparseBitArray) IntersectsBetween(other BitArray, start, st...
  function newSparseBitArray (line 346) | func newSparseBitArray() *sparseBitArray {
  function NewSparseBitArray (line 352) | func NewSparseBitArray() BitArray {

FILE: bitarray/sparse_bitarray_test.go
  function TestGetCompressedBit (line 26) | func TestGetCompressedBit(t *testing.T) {
  function BenchmarkGetCompressedBit (line 34) | func BenchmarkGetCompressedBit(b *testing.B) {
  function TestGetSetCompressedBit (line 49) | func TestGetSetCompressedBit(t *testing.T) {
  function BenchmarkSetCompressedBit (line 68) | func BenchmarkSetCompressedBit(b *testing.B) {
  function TestGetSetCompressedBits (line 80) | func TestGetSetCompressedBits(t *testing.T) {
  function BenchmarkGetSetCompressedBits (line 109) | func BenchmarkGetSetCompressedBits(b *testing.B) {
  function TestCompressedCount (line 125) | func TestCompressedCount(t *testing.T) {
  function TestClearCompressedBit (line 147) | func TestClearCompressedBit(t *testing.T) {
  function BenchmarkClearCompressedBit (line 167) | func BenchmarkClearCompressedBit(b *testing.B) {
  function TestClearCompressedBitArray (line 181) | func TestClearCompressedBitArray(t *testing.T) {
  function TestCompressedEquals (line 201) | func TestCompressedEquals(t *testing.T) {
  function TestCompressedIntersects (line 217) | func TestCompressedIntersects(t *testing.T) {
  function TestLongCompressedIntersects (line 239) | func TestLongCompressedIntersects(t *testing.T) {
  function BenchmarkCompressedIntersects (line 264) | func BenchmarkCompressedIntersects(b *testing.B) {
  function TestSparseIntersectsBitArray (line 282) | func TestSparseIntersectsBitArray(t *testing.T) {
  function TestSparseEqualsBitArray (line 307) | func TestSparseEqualsBitArray(t *testing.T) {
  function BenchmarkCompressedEquals (line 326) | func BenchmarkCompressedEquals(b *testing.B) {
  function TestInsertPreviousBlockInSparse (line 343) | func TestInsertPreviousBlockInSparse(t *testing.T) {
  function TestSparseBitArrayToNums (line 354) | func TestSparseBitArrayToNums(t *testing.T) {
  function BenchmarkSparseBitArrayToNums (line 366) | func BenchmarkSparseBitArrayToNums(b *testing.B) {

FILE: bitarray/util.go
  function maxInt64 (line 20) | func maxInt64(ints ...int64) int64 {
  function maxUint64 (line 32) | func maxUint64(ints ...uint64) uint64 {
  function minUint64 (line 44) | func minUint64(ints ...uint64) uint64 {

FILE: btree/_link/interface.go
  type Keys (line 20) | type Keys
  type Key (line 22) | type Key interface

FILE: btree/_link/key.go
  method search (line 21) | func (keys Keys) search(key Key) int {
  method insert (line 27) | func (keys *Keys) insert(key Key) Key {
  method insertAt (line 32) | func (keys *Keys) insertAt(key Key, i int) Key {
  method split (line 50) | func (keys *Keys) split() (Key, Keys, Keys) {
  method splitAt (line 58) | func (keys *Keys) splitAt(i int) (Keys, Keys) {
  method last (line 69) | func (keys Keys) last() Key {
  method first (line 73) | func (keys Keys) first() Key {
  method needsSplit (line 77) | func (keys Keys) needsSplit() bool {
  method reverse (line 81) | func (keys Keys) reverse() Keys {
  function chunkKeys (line 90) | func chunkKeys(keys Keys, numParts int64) []Keys {

FILE: btree/_link/mock_test.go
  type mockKey (line 19) | type mockKey
    method Compare (line 21) | func (mk mockKey) Compare(other Key) int {

FILE: btree/_link/node.go
  function search (line 24) | func search(parent *node, key Key) Key {
  function getParent (line 38) | func getParent(parent *node, stack *nodes, key Key) *node {
  function insert (line 55) | func insert(tree *blink, parent *node, stack *nodes, key Key) Key {
  function split (line 77) | func split(tree *blink, n *node, stack *nodes) {
  function moveRight (line 116) | func moveRight(n *node, key Key, getLock bool) *node {
  type nodes (line 139) | type nodes
    method reset (line 141) | func (ns *nodes) reset() {
    method push (line 149) | func (ns *nodes) push(n *node) {
    method pop (line 153) | func (ns *nodes) pop() *node {
    method insertAt (line 164) | func (ns *nodes) insertAt(n *node, i int) {
    method splitAt (line 175) | func (ns *nodes) splitAt(i int) (nodes, nodes) {
  type node (line 186) | type node struct
    method key (line 195) | func (n *node) key() Key {
    method insert (line 199) | func (n *node) insert(key Key) Key {
    method insertNode (line 208) | func (n *node) insertNode(other *node) {
    method needsSplit (line 215) | func (n *node) needsSplit() bool {
    method max (line 219) | func (n *node) max() Key {
    method splitLeaf (line 227) | func (n *node) splitLeaf() (Key, *node, *node) {
    method splitInternal (line 240) | func (n *node) splitInternal() (Key, *node, *node) {
    method split (line 269) | func (n *node) split() (Key, *node, *node) {
    method search (line 277) | func (n *node) search(key Key) int {
    method searchNode (line 281) | func (n *node) searchNode(key Key) *node {
    method print (line 287) | func (n *node) print(output *log.Logger) {
  function newNode (line 300) | func newNode(isLeaf bool, keys Keys, ns nodes) *node {

FILE: btree/_link/node_test.go
  function newTestNode (line 25) | func newTestNode(isLeaf bool, ary int) *node {
  function checkTree (line 33) | func checkTree(t testing.TB, tree *blink) bool {
  function checkNode (line 41) | func checkNode(t testing.TB, n *node) bool {
  function TestSplitInternalNodeOddAry (line 79) | func TestSplitInternalNodeOddAry(t *testing.T) {
  function TestSplitInternalNodeEvenAry (line 105) | func TestSplitInternalNodeEvenAry(t *testing.T) {
  function TestSplitLeafNodeOddAry (line 133) | func TestSplitLeafNodeOddAry(t *testing.T) {
  function TestSplitLeafNodeEvenAry (line 149) | func TestSplitLeafNodeEvenAry(t *testing.T) {

FILE: btree/_link/tree.go
  constant numberOfItemsBeforeMultithread (line 49) | numberOfItemsBeforeMultithread = 10
  type blink (line 51) | type blink struct
    method insert (line 57) | func (blink *blink) insert(key Key, stack *nodes) Key {
    method multithreadedInsert (line 79) | func (blink *blink) multithreadedInsert(keys Keys) Keys {
    method Insert (line 108) | func (blink *blink) Insert(keys ...Key) Keys {
    method Len (line 123) | func (blink *blink) Len() uint64 {
    method get (line 127) | func (blink *blink) get(key Key) Key {
    method Get (line 147) | func (blink *blink) Get(keys ...Key) Keys {
    method print (line 156) | func (blink *blink) print(output *log.Logger) {
  function newTree (line 165) | func newTree(ary, numRoutines uint64) *blink {

FILE: btree/_link/tree_test.go
  function getConsoleLogger (line 28) | func getConsoleLogger() *log.Logger {
  function generateRandomKeys (line 32) | func generateRandomKeys(num int) Keys {
  function generateKeys (line 41) | func generateKeys(num int) Keys {
  function TestSimpleInsert (line 50) | func TestSimpleInsert(t *testing.T) {
  function TestMultipleInsert (line 62) | func TestMultipleInsert(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAryReverseOrder (line 74) | func TestMultipleInsertCausesSplitOddAryReverseOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAry (line 87) | func TestMultipleInsertCausesSplitOddAry(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAryRandomOrder (line 100) | func TestMultipleInsertCausesSplitOddAryRandomOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAryReverseOrder (line 113) | func TestMultipleInsertCausesSplitEvenAryReverseOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAry (line 127) | func TestMultipleInsertCausesSplitEvenAry(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAryRandomOrder (line 140) | func TestMultipleInsertCausesSplitEvenAryRandomOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAryMultiThreaded (line 153) | func TestMultipleInsertCausesSplitEvenAryMultiThreaded(t *testing.T) {
  function TestMultipleInsertCausesCascadingSplitsOddAry (line 165) | func TestMultipleInsertCausesCascadingSplitsOddAry(t *testing.T) {
  function TestMultipleInsertCausesCascadingSplitsOddAryReverseOrder (line 179) | func TestMultipleInsertCausesCascadingSplitsOddAryReverseOrder(t *testin...
  function TestMultipleInsertCausesCascadingSplitsEvenAry (line 195) | func TestMultipleInsertCausesCascadingSplitsEvenAry(t *testing.T) {
  function TestOverwriteOddAry (line 206) | func TestOverwriteOddAry(t *testing.T) {
  function TestOverwriteEvenAry (line 220) | func TestOverwriteEvenAry(t *testing.T) {
  function BenchmarkSimpleAdd (line 234) | func BenchmarkSimpleAdd(b *testing.B) {
  function BenchmarkGet (line 246) | func BenchmarkGet(b *testing.B) {
  function BenchmarkBulkAdd (line 259) | func BenchmarkBulkAdd(b *testing.B) {

FILE: btree/immutable/add.go
  method AddItems (line 27) | func (t *Tr) AddItems(its ...*Item) ([]*Item, error) {
  method add (line 45) | func (t *Tr) add(keys Keys) (Keys, error) {
  method determinePaths (line 118) | func (t *Tr) determinePaths(keys Keys) (map[string][]*nodeBundle, error) {
  function insertByMerge (line 164) | func insertByMerge(comparator Comparator, n *Node, bundles []*nodeBundle...
  function insertLastDimension (line 205) | func insertLastDimension(t *Tr, n *Node, bundles []*nodeBundle) (Keys, e...
  method iterativeSplit (line 221) | func (t *Tr) iterativeSplit(n *Node) Keys {
  method walkupInsert (line 235) | func (t *Tr) walkupInsert(nodes map[string]*path) error {

FILE: btree/immutable/cacher.go
  type cacher (line 32) | type cacher struct
    method asyncLoadNode (line 38) | func (c *cacher) asyncLoadNode(t *Tr, key ID, completer chan interface...
    method clear (line 54) | func (c *cacher) clear() {
    method deleteFromCache (line 63) | func (c *cacher) deleteFromCache(id ID) {
    method loadNode (line 70) | func (c *cacher) loadNode(t *Tr, key ID) (*Node, error) {
    method getNode (line 88) | func (c *cacher) getNode(t *Tr, key ID, useCache bool) (*Node, error) {
  function newCacher (line 128) | func newCacher(persister Persister) *cacher {

FILE: btree/immutable/config.go
  type Config (line 22) | type Config struct
  function DefaultConfig (line 37) | func DefaultConfig(persister Persister, comparator Comparator) Config {

FILE: btree/immutable/delete.go
  method DeleteItems (line 21) | func (t *Tr) DeleteItems(values ...interface{}) ([]*Item, error) {
  method delete (line 49) | func (t *Tr) delete(keys Keys) error {
  method walkupDelete (line 145) | func (t *Tr) walkupDelete(key *Key, node *Node, path *path, mapping map[...

FILE: btree/immutable/interface.go
  type Tree (line 46) | type Tree interface
  type ReadableTree (line 62) | type ReadableTree interface
  type MutableTree (line 72) | type MutableTree interface
  type Comparator (line 90) | type Comparator
  type Payload (line 93) | type Payload struct
  type Persister (line 101) | type Persister interface

FILE: btree/immutable/item.go
  type Item (line 19) | type Item struct
  type items (line 24) | type items
    method split (line 26) | func (its items) split(numParts int) []items {

FILE: btree/immutable/node.go
  function newID (line 27) | func newID() []byte {
  type ID (line 39) | type ID
  type Key (line 44) | type Key struct
    method ID (line 51) | func (k Key) ID() []byte {
    method ToItem (line 55) | func (k Key) ToItem() *Item {
  type Keys (line 62) | type Keys
    method toItems (line 64) | func (k Keys) toItems() items {
    method sort (line 73) | func (k Keys) sort(comparator Comparator) Keys {
  type keySortWrapper (line 77) | type keySortWrapper struct
    method Len (line 82) | func (sw *keySortWrapper) Len() int {
    method Swap (line 86) | func (sw *keySortWrapper) Swap(i, j int) {
    method Less (line 90) | func (sw *keySortWrapper) Less(i, j int) bool {
    method sort (line 94) | func (sw *keySortWrapper) sort() Keys {
  function splitKeys (line 99) | func splitKeys(keys Keys, numParts int) []Keys {
  type Node (line 111) | type Node struct
    method copy (line 127) | func (n *Node) copy() *Node {
    method searchKey (line 145) | func (n *Node) searchKey(comparator Comparator, value interface{}) (*K...
    method insert (line 165) | func (n *Node) insert(comparator Comparator, key *Key) *Key {
    method delete (line 195) | func (n *Node) delete(comparator Comparator, key *Key) *Key {
    method multiDelete (line 207) | func (n *Node) multiDelete(comparator Comparator, keys ...*Key) {
    method replaceKeyAt (line 245) | func (n *Node) replaceKeyAt(key *Key, i int) {
    method flatten (line 250) | func (n *Node) flatten() ([]interface{}, Keys) {
    method iter (line 256) | func (n *Node) iter(comparator Comparator, start, stop interface{}) it...
    method valueAt (line 267) | func (n *Node) valueAt(i int) interface{} {
    method keyAt (line 271) | func (n *Node) keyAt(i int) *Key {
    method needsSplit (line 275) | func (n *Node) needsSplit(max int) bool {
    method lastValue (line 279) | func (n *Node) lastValue() interface{} {
    method firstValue (line 283) | func (n *Node) firstValue() interface{} {
    method append (line 287) | func (n *Node) append(other *Node) {
    method replaceValueAt (line 292) | func (n *Node) replaceValueAt(i int, value interface{}) {
    method deleteValueAt (line 296) | func (n *Node) deleteValueAt(i int) {
    method deleteKeyAt (line 302) | func (n *Node) deleteKeyAt(i int) {
    method splitLeafAt (line 308) | func (n *Node) splitLeafAt(i int) (interface{}, *Node) {
    method splitInternalAt (line 331) | func (n *Node) splitInternalAt(i int) (interface{}, *Node) {
    method splitAt (line 352) | func (n *Node) splitAt(i int) (interface{}, *Node) {
    method lenKeys (line 360) | func (n *Node) lenKeys() int {
    method lenValues (line 364) | func (n *Node) lenValues() int {
    method appendChild (line 368) | func (n *Node) appendChild(key *Key) {
    method appendValue (line 372) | func (n *Node) appendValue(value interface{}) {
    method popFirstKey (line 376) | func (n *Node) popFirstKey() *Key {
    method popFirstValue (line 382) | func (n *Node) popFirstValue() interface{} {
    method popKey (line 388) | func (n *Node) popKey() *Key {
    method popValue (line 394) | func (n *Node) popValue() interface{} {
    method prependKey (line 400) | func (n *Node) prependKey(key *Key) {
    method prependValue (line 406) | func (n *Node) prependValue(value interface{}) {
    method search (line 412) | func (n *Node) search(comparator Comparator, value interface{}) int {
  function nodeFromBytes (line 420) | func nodeFromBytes(t *Tr, data []byte) (*Node, error) {
  function newNode (line 433) | func newNode() *Node {
  type sliceIterator (line 439) | type sliceIterator struct
    method next (line 446) | func (s *sliceIterator) next() bool {
    method value (line 466) | func (s *sliceIterator) value() (*Key, int) {
  type iterator (line 470) | type iterator interface
  type nodeBundle (line 475) | type nodeBundle struct
  type nodeSortWrapper (line 480) | type nodeSortWrapper struct
    method Len (line 486) | func (n *nodeSortWrapper) Len() int {
    method Swap (line 490) | func (n *nodeSortWrapper) Swap(i, j int) {
    method Less (line 495) | func (n *nodeSortWrapper) Less(i, j int) bool {
  function splitValues (line 499) | func splitValues(values []interface{}, numParts int) [][]interface{} {

FILE: btree/immutable/node_gen.go
  method MarshalMsg (line 12) | func (z ID) MarshalMsg(b []byte) (o []byte, err error) {
  method UnmarshalMsg (line 19) | func (z *ID) UnmarshalMsg(bts []byte) (o []byte, err error) {
  method Msgsize (line 32) | func (z ID) Msgsize() (s int) {
  method MarshalMsg (line 38) | func (z *Key) MarshalMsg(b []byte) (o []byte, err error) {
  method UnmarshalMsg (line 57) | func (z *Key) UnmarshalMsg(bts []byte) (o []byte, err error) {
  method Msgsize (line 102) | func (z *Key) Msgsize() (s int) {
  method MarshalMsg (line 108) | func (z Keys) MarshalMsg(b []byte) (o []byte, err error) {
  method UnmarshalMsg (line 125) | func (z *Keys) UnmarshalMsg(bts []byte) (o []byte, err error) {
  method Msgsize (line 157) | func (z Keys) Msgsize() (s int) {
  method MarshalMsg (line 170) | func (z *Node) MarshalMsg(b []byte) (o []byte, err error) {
  method UnmarshalMsg (line 205) | func (z *Node) UnmarshalMsg(bts []byte) (o []byte, err error) {
  method Msgsize (line 290) | func (z *Node) Msgsize() (s int) {

FILE: btree/immutable/path.go
  type pathBundle (line 24) | type pathBundle struct
  type path (line 34) | type path struct
    method append (line 39) | func (p *path) append(pb *pathBundle) {
    method pop (line 53) | func (p *path) pop() *pathBundle {
    method peek (line 63) | func (p *path) peek() *pathBundle {

FILE: btree/immutable/query.go
  method Apply (line 26) | func (t *Tr) Apply(fn func(item *Item), keys ...interface{}) error {
  method filter (line 92) | func (t *Tr) filter(start, stop interface{}, n *Node, fn func(key *Key) ...
  method iter (line 103) | func (t *Tr) iter(start, stop interface{}, fn func(*Key) bool) error {
  method iterativeFind (line 138) | func (t *Tr) iterativeFind(value interface{}, id ID) (*path, error) {
  method iterativeFindWithoutPath (line 168) | func (t *Tr) iterativeFindWithoutPath(value interface{}, id ID) (*Node, ...

FILE: btree/immutable/rt.go
  type context (line 28) | type context struct
    method nodeExists (line 33) | func (c *context) nodeExists(id ID) bool {
    method addNode (line 40) | func (c *context) addNode(n *Node) {
    method getNode (line 46) | func (c *context) getNode(id ID) *Node {
  function newContext (line 52) | func newContext() *context {
  type Tr (line 61) | type Tr struct
    method createRoot (line 72) | func (t *Tr) createRoot() *Node {
    method contextOrCachedNode (line 80) | func (t *Tr) contextOrCachedNode(id ID, cache bool) (*Node, error) {
    method ID (line 91) | func (t *Tr) ID() ID {
    method toBytes (line 97) | func (t *Tr) toBytes() []byte {
    method reset (line 107) | func (t *Tr) reset() {
    method commit (line 114) | func (t *Tr) commit() []*Payload {
    method copyNode (line 131) | func (t *Tr) copyNode(n *Node) *Node {
    method Len (line 141) | func (t *Tr) Len() int {
    method AsMutable (line 145) | func (t *Tr) AsMutable() MutableTree {
    method Commit (line 158) | func (t *Tr) Commit() (ReadableTree, error) {
  function treeFromBytes (line 176) | func treeFromBytes(p Persister, data []byte, comparator Comparator) (*Tr...
  function newTree (line 193) | func newTree(cfg Config) *Tr {
  function New (line 202) | func New(cfg Config) ReadableTree {
  function Load (line 210) | func Load(p Persister, id []byte, comparator Comparator) (ReadableTree, ...

FILE: btree/immutable/rt_gen.go
  method MarshalMsg (line 12) | func (z *Tr) MarshalMsg(b []byte) (o []byte, err error) {
  method UnmarshalMsg (line 37) | func (z *Tr) UnmarshalMsg(bts []byte) (o []byte, err error) {
  method Msgsize (line 83) | func (z *Tr) Msgsize() (s int) {

FILE: btree/immutable/rt_test.go
  type ephemeral (line 31) | type ephemeral struct
    method Save (line 36) | func (e *ephemeral) Save(items ...*Payload) error {
    method Load (line 51) | func (e *ephemeral) Load(keys ...[]byte) ([]*Payload, error) {
  constant maxValue (line 68) | maxValue = int64(100000)
  function init (line 71) | func init() {
  type valueSortWrapper (line 75) | type valueSortWrapper struct
    method Len (line 80) | func (v *valueSortWrapper) Len() int {
    method Swap (line 84) | func (v *valueSortWrapper) Swap(i, j int) {
    method Less (line 88) | func (v *valueSortWrapper) Less(i, j int) bool {
    method sort (line 92) | func (v *valueSortWrapper) sort() {
  function reverse (line 96) | func reverse(items items) items {
  type orderedItems (line 121) | type orderedItems
    method Len (line 123) | func (o orderedItems) Len() int {
    method Swap (line 127) | func (o orderedItems) Swap(i, j int) {
    method Less (line 131) | func (o orderedItems) Less(i, j int) bool {
    method equal (line 135) | func (o orderedItems) equal(item1, item2 *Item) bool {
    method copy (line 139) | func (o orderedItems) copy() orderedItems {
    method search (line 145) | func (o orderedItems) search(value interface{}) int {
    method add (line 151) | func (o orderedItems) add(item *Item) orderedItems {
    method delete (line 171) | func (o orderedItems) delete(item *Item) orderedItems {
    method toItems (line 190) | func (o orderedItems) toItems() items {
    method query (line 199) | func (o orderedItems) query(start, stop interface{}) items {
  function generateRandomQuery (line 213) | func generateRandomQuery() (interface{}, interface{}) {
  function newItem (line 219) | func newItem(value interface{}) *Item {
  function newEphemeral (line 226) | func newEphemeral() Persister {
  type delayedPersister (line 232) | type delayedPersister struct
    method Load (line 236) | func (d *delayedPersister) Load(keys ...[]byte) ([]*Payload, error) {
  function newDelayed (line 241) | func newDelayed() Persister {
  function defaultConfig (line 245) | func defaultConfig() Config {
  function generateRandomItem (line 253) | func generateRandomItem() *Item {
  function generateRandomItems (line 259) | func generateRandomItems(num int) items {
  function generateLinearItems (line 276) | func generateLinearItems(num int) items {
  function toOrdered (line 286) | func toOrdered(items items) orderedItems {
  method toList (line 297) | func (t *Tr) toList(values ...interface{}) (items, error) {
  method pprint (line 306) | func (t *Tr) pprint(id ID) {
  method verify (line 330) | func (t *Tr) verify(id ID, tb testing.TB) (interface{}, interface{}) {
  function itemsToValues (line 371) | func itemsToValues(items ...*Item) []interface{} {
  function TestNodeSplit (line 380) | func TestNodeSplit(t *testing.T) {
  function TestReverseNodeSplit (line 423) | func TestReverseNodeSplit(t *testing.T) {
  function TestDuplicate (line 455) | func TestDuplicate(t *testing.T) {
  function TestCommit (line 474) | func TestCommit(t *testing.T) {
  function TestRandom (line 498) | func TestRandom(t *testing.T) {
  function TestLoad (line 517) | func TestLoad(t *testing.T) {
  function TestDeleteFromRoot (line 538) | func TestDeleteFromRoot(t *testing.T) {
  function TestDeleteAllFromRoot (line 556) | func TestDeleteAllFromRoot(t *testing.T) {
  function TestDeleteAfterSplitIncreasing (line 572) | func TestDeleteAfterSplitIncreasing(t *testing.T) {
  function TestDeleteMultipleLevelsRandomlyBulk (line 589) | func TestDeleteMultipleLevelsRandomlyBulk(t *testing.T) {
  function TestDeleteAfterSplitDecreasing (line 601) | func TestDeleteAfterSplitDecreasing(t *testing.T) {
  function TestDeleteMultipleLevels (line 620) | func TestDeleteMultipleLevels(t *testing.T) {
  function TestDeleteMultipleLevelsRandomly (line 654) | func TestDeleteMultipleLevelsRandomly(t *testing.T) {
  function TestDeleteMultipleLevelsWithCommit (line 679) | func TestDeleteMultipleLevelsWithCommit(t *testing.T) {
  function TestCommitAfterDelete (line 710) | func TestCommitAfterDelete(t *testing.T) {
  function TestSecondCommitSplitsRoot (line 731) | func TestSecondCommitSplitsRoot(t *testing.T) {
  function TestSecondCommitMultipleSplits (line 756) | func TestSecondCommitMultipleSplits(t *testing.T) {
  function TestLargeAdd (line 784) | func TestLargeAdd(t *testing.T) {
  function TestNodeInfiniteLoop (line 809) | func TestNodeInfiniteLoop(t *testing.T) {
  function TestGenerativeAdds (line 826) | func TestGenerativeAdds(t *testing.T) {
  function TestGenerativeDeletes (line 878) | func TestGenerativeDeletes(t *testing.T) {
  function TestGenerativeOperations (line 918) | func TestGenerativeOperations(t *testing.T) {
  function BenchmarkGetitems (line 971) | func BenchmarkGetitems(b *testing.B) {
  function BenchmarkBulkAdd (line 996) | func BenchmarkBulkAdd(b *testing.B) {

FILE: btree/palm/action.go
  type actions (line 27) | type actions
  type action (line 29) | type action interface
  type getAction (line 37) | type getAction struct
    method complete (line 42) | func (ga *getAction) complete() {
    method operation (line 46) | func (ga *getAction) operation() operation {
    method keys (line 50) | func (ga *getAction) keys() common.Comparators {
    method addNode (line 54) | func (ga *getAction) addNode(i int64, n *node) {
    method nodes (line 58) | func (ga *getAction) nodes() []*node {
  function newGetAction (line 62) | func newGetAction(keys common.Comparators) *getAction {
  type insertAction (line 73) | type insertAction struct
    method complete (line 79) | func (ia *insertAction) complete() {
    method operation (line 83) | func (ia *insertAction) operation() operation {
    method keys (line 87) | func (ia *insertAction) keys() common.Comparators {
    method addNode (line 91) | func (ia *insertAction) addNode(i int64, n *node) {
    method nodes (line 95) | func (ia *insertAction) nodes() []*node {
  function newInsertAction (line 99) | func newInsertAction(keys common.Comparators) *insertAction {
  type removeAction (line 111) | type removeAction struct
    method operation (line 115) | func (ra *removeAction) operation() operation {
  function newRemoveAction (line 119) | func newRemoveAction(keys common.Comparators) *removeAction {
  type applyAction (line 125) | type applyAction struct
    method operation (line 131) | func (aa *applyAction) operation() operation {
    method nodes (line 135) | func (aa *applyAction) nodes() []*node {
    method addNode (line 139) | func (aa *applyAction) addNode(i int64, n *node) {}
    method keys (line 141) | func (aa *applyAction) keys() common.Comparators {
    method complete (line 145) | func (aa *applyAction) complete() {
  function newApplyAction (line 149) | func newApplyAction(fn func(common.Comparator) bool, start, stop common....
  function minUint64 (line 160) | func minUint64(choices ...uint64) uint64 {
  type interfaces (line 171) | type interfaces
  function executeInterfacesInParallel (line 173) | func executeInterfacesInParallel(ifs interfaces, fn func(interface{})) {
  function executeInterfacesInSerial (line 207) | func executeInterfacesInSerial(ifs interfaces, fn func(interface{})) {

FILE: btree/palm/interface.go
  type BTree (line 51) | type BTree interface

FILE: btree/palm/key.go
  function reverseKeys (line 21) | func reverseKeys(cmps common.Comparators) common.Comparators {
  function chunkKeys (line 30) | func chunkKeys(keys common.Comparators, numParts int64) []common.Compara...

FILE: btree/palm/mock_test.go
  type mockKey (line 20) | type mockKey
    method Compare (line 22) | func (mk mockKey) Compare(other common.Comparator) int {

FILE: btree/palm/node.go
  function getParent (line 26) | func getParent(parent *node, key common.Comparator) *node {
  type nodes (line 36) | type nodes struct
    method push (line 40) | func (ns *nodes) push(n *node) {
    method splitAt (line 44) | func (ns *nodes) splitAt(i, capacity uint64) (*nodes, *nodes) {
    method byPosition (line 55) | func (ns *nodes) byPosition(pos uint64) *node {
    method insertAt (line 63) | func (ns *nodes) insertAt(i uint64, n *node) {
    method replaceAt (line 69) | func (ns *nodes) replaceAt(i uint64, n *node) {
    method len (line 73) | func (ns *nodes) len() uint64 {
  function newNodes (line 77) | func newNodes(size uint64) *nodes {
  type keys (line 83) | type keys struct
    method splitAt (line 87) | func (ks *keys) splitAt(i, capacity uint64) (*keys, *keys) {
    method len (line 98) | func (ks *keys) len() uint64 {
    method byPosition (line 102) | func (ks *keys) byPosition(i uint64) common.Comparator {
    method delete (line 109) | func (ks *keys) delete(k common.Comparator) common.Comparator {
    method search (line 126) | func (ks *keys) search(key common.Comparator) uint64 {
    method insert (line 134) | func (ks *keys) insert(key common.Comparator) (common.Comparator, uint...
    method last (line 152) | func (ks *keys) last() common.Comparator {
    method insertAt (line 156) | func (ks *keys) insertAt(i uint64, k common.Comparator) {
    method withPosition (line 162) | func (ks *keys) withPosition(k common.Comparator) (common.Comparator, ...
  function newKeys (line 174) | func newKeys(size uint64) *keys {
  type node (line 180) | type node struct
    method needsSplit (line 187) | func (n *node) needsSplit(ary uint64) bool {
    method splitLeaf (line 191) | func (n *node) splitLeaf(i, capacity uint64) (common.Comparator, *node...
    method splitInternal (line 204) | func (n *node) splitInternal(i, capacity uint64) (common.Comparator, *...
    method split (line 219) | func (n *node) split(i, capacity uint64) (common.Comparator, *node, *n...
    method search (line 227) | func (n *node) search(key common.Comparator) uint64 {
    method searchNode (line 231) | func (n *node) searchNode(key common.Comparator) *node {
    method key (line 237) | func (n *node) key() common.Comparator {
    method print (line 241) | func (n *node) print(output *log.Logger) {
    method Compare (line 261) | func (n *node) Compare(e common.Comparator) int {
  function newNode (line 265) | func newNode(isLeaf bool, keys *keys, ns *nodes) *node {

FILE: btree/palm/tree.go
  type operation (line 29) | type operation
  constant get (line 32) | get operation = iota
  constant add (line 33) | add
  constant remove (line 34) | remove
  constant apply (line 35) | apply
  constant multiThreadAt (line 38) | multiThreadAt = 400
  type keyBundle (line 40) | type keyBundle struct
    method dispose (line 45) | func (kb *keyBundle) dispose(ptree *ptree) {
  type ptree (line 53) | type ptree struct
    method checkAndRun (line 71) | func (ptree *ptree) checkAndRun(action action) {
    method init (line 119) | func (ptree *ptree) init(bufferSize, ary uint64) {
    method newKeyBundle (line 137) | func (ptree *ptree) newKeyBundle(key common.Comparator) *keyBundle {
    method operationRunner (line 150) | func (ptree *ptree) operationRunner(xns interfaces, threaded bool) {
    method read (line 160) | func (ptree *ptree) read(action action) {
    method fetchKeys (line 176) | func (ptree *ptree) fetchKeys(xns interfaces, inParallel bool) (map[*n...
    method apply (line 207) | func (ptree *ptree) apply(n *node, aa *applyAction) {
    method disposer (line 226) | func (ptree *ptree) disposer(wg *sync.WaitGroup) {
    method fetchKeysInSerial (line 239) | func (ptree *ptree) fetchKeysInSerial(xns interfaces) {
    method reset (line 266) | func (ptree *ptree) reset() {
    method fetchKeysInParallel (line 276) | func (ptree *ptree) fetchKeysInParallel(xns []interface{}) {
    method splitNode (line 336) | func (ptree *ptree) splitNode(n, parent *node, nodes *[]*node, keys *c...
    method applyNode (line 355) | func (ptree *ptree) applyNode(n *node, adds, deletes []*keyBundle) {
    method cleanMap (line 391) | func (ptree *ptree) cleanMap(op map[*node][]*keyBundle) {
    method recursiveMutate (line 399) | func (ptree *ptree) recursiveMutate(adds, deletes map[*node][]*keyBund...
    method Insert (line 488) | func (ptree *ptree) Insert(keys ...common.Comparator) {
    method Delete (line 496) | func (ptree *ptree) Delete(keys ...common.Comparator) {
    method Get (line 503) | func (ptree *ptree) Get(keys ...common.Comparator) common.Comparators {
    method Len (line 511) | func (ptree *ptree) Len() uint64 {
    method Query (line 518) | func (ptree *ptree) Query(start, stop common.Comparator) common.Compar...
    method Dispose (line 531) | func (ptree *ptree) Dispose() {
    method print (line 540) | func (ptree *ptree) print(output *log.Logger) {
  function newTree (line 549) | func newTree(bufferSize, ary uint64) *ptree {
  function New (line 558) | func New(bufferSize, ary uint64) BTree {

FILE: btree/palm/tree_test.go
  function checkTree (line 31) | func checkTree(t testing.TB, tree *ptree) bool {
  function checkNode (line 41) | func checkNode(t testing.TB, n *node) bool {
  function getConsoleLogger (line 86) | func getConsoleLogger() *log.Logger {
  function generateRandomKeys (line 90) | func generateRandomKeys(num int) common.Comparators {
  function generateKeys (line 99) | func generateKeys(num int) common.Comparators {
  function TestSimpleInsert (line 108) | func TestSimpleInsert(t *testing.T) {
  function TestSimpleDelete (line 119) | func TestSimpleDelete(t *testing.T) {
  function TestMultipleAdd (line 131) | func TestMultipleAdd(t *testing.T) {
  function TestMultipleDelete (line 145) | func TestMultipleDelete(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAryReverseOrder (line 158) | func TestMultipleInsertCausesSplitOddAryReverseOrder(t *testing.T) {
  function TestMultipleDeleteOddAryReverseOrder (line 171) | func TestMultipleDeleteOddAryReverseOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAry (line 187) | func TestMultipleInsertCausesSplitOddAry(t *testing.T) {
  function TestMultipleInsertCausesSplitOddAryRandomOrder (line 199) | func TestMultipleInsertCausesSplitOddAryRandomOrder(t *testing.T) {
  function TestMultipleBulkInsertOddAry (line 211) | func TestMultipleBulkInsertOddAry(t *testing.T) {
  function TestMultipleBulkInsertEvenAry (line 231) | func TestMultipleBulkInsertEvenAry(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAryReverseOrder (line 250) | func TestMultipleInsertCausesSplitEvenAryReverseOrder(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAry (line 263) | func TestMultipleInsertCausesSplitEvenAry(t *testing.T) {
  function TestMultipleInsertCausesSplitEvenAryRandomOrder (line 275) | func TestMultipleInsertCausesSplitEvenAryRandomOrder(t *testing.T) {
  function TestInsertOverwrite (line 287) | func TestInsertOverwrite(t *testing.T) {
  function TestSimultaneousReadsAndWrites (line 299) | func TestSimultaneousReadsAndWrites(t *testing.T) {
  function TestInsertAndDelete (line 326) | func TestInsertAndDelete(t *testing.T) {
  function TestInsertAndDeletesWithSplits (line 354) | func TestInsertAndDeletesWithSplits(t *testing.T) {
  function TestSimpleQuery (line 382) | func TestSimpleQuery(t *testing.T) {
  function TestMultipleQuery (line 401) | func TestMultipleQuery(t *testing.T) {
  function TestCrossNodeQuery (line 421) | func TestCrossNodeQuery(t *testing.T) {
  function BenchmarkReadAndWrites (line 433) | func BenchmarkReadAndWrites(b *testing.B) {
  function BenchmarkSimultaneousReadsAndWrites (line 449) | func BenchmarkSimultaneousReadsAndWrites(b *testing.B) {
  function BenchmarkBulkAdd (line 477) | func BenchmarkBulkAdd(b *testing.B) {
  function BenchmarkAdd (line 492) | func BenchmarkAdd(b *testing.B) {
  function BenchmarkBulkAddToExisting (line 504) | func BenchmarkBulkAddToExisting(b *testing.B) {
  function BenchmarkGet (line 520) | func BenchmarkGet(b *testing.B) {
  function BenchmarkBulkGet (line 533) | func BenchmarkBulkGet(b *testing.B) {
  function BenchmarkDelete (line 546) | func BenchmarkDelete(b *testing.B) {
  function BenchmarkBulkDelete (line 559) | func BenchmarkBulkDelete(b *testing.B) {
  function BenchmarkFindQuery (line 576) | func BenchmarkFindQuery(b *testing.B) {
  function BenchmarkExecuteQuery (line 589) | func BenchmarkExecuteQuery(b *testing.B) {

FILE: btree/plus/btree.go
  function keySearch (line 36) | func keySearch(keys keys, key Key) int {
  type btree (line 53) | type btree struct
    method insert (line 58) | func (tree *btree) insert(key Key) {
    method Insert (line 79) | func (tree *btree) Insert(keys ...Key) {
    method Iter (line 87) | func (tree *btree) Iter(key Key) Iterator {
    method get (line 95) | func (tree *btree) get(key Key) Key {
    method Get (line 111) | func (tree *btree) Get(keys ...Key) Keys {
    method Len (line 121) | func (tree *btree) Len() uint64 {
  function newBTree (line 125) | func newBTree(nodeSize uint64) *btree {

FILE: btree/plus/btree_test.go
  function TestSearchKeys (line 26) | func TestSearchKeys(t *testing.T) {
  function TestTreeInsert2_3_4 (line 44) | func TestTreeInsert2_3_4(t *testing.T) {
  function TestTreeInsert3_4_5 (line 55) | func TestTreeInsert3_4_5(t *testing.T) {
  function TestTreeInsertQuery2_3_4 (line 66) | func TestTreeInsertQuery2_3_4(t *testing.T) {
  function TestTreeInsertQuery3_4_5 (line 78) | func TestTreeInsertQuery3_4_5(t *testing.T) {
  function TestTreeInsertReverseOrder2_3_4 (line 90) | func TestTreeInsertReverseOrder2_3_4(t *testing.T) {
  function TestTreeInsertReverseOrder3_4_5 (line 105) | func TestTreeInsertReverseOrder3_4_5(t *testing.T) {
  function TestTreeInsert3_4_5_WithEndDuplicate (line 120) | func TestTreeInsert3_4_5_WithEndDuplicate(t *testing.T) {
  function TestTreeInsert3_4_5_WithMiddleDuplicate (line 135) | func TestTreeInsert3_4_5_WithMiddleDuplicate(t *testing.T) {
  function TestTreeInsert3_4_5WithEarlyDuplicate (line 150) | func TestTreeInsert3_4_5WithEarlyDuplicate(t *testing.T) {
  function TestTreeInsert3_4_5WithDuplicateID (line 165) | func TestTreeInsert3_4_5WithDuplicateID(t *testing.T) {
  function TestTreeInsert3_4_5MiddleQuery (line 179) | func TestTreeInsert3_4_5MiddleQuery(t *testing.T) {
  function TestTreeInsert3_4_5LateQuery (line 191) | func TestTreeInsert3_4_5LateQuery(t *testing.T) {
  function TestTreeInsert3_4_5AfterQuery (line 203) | func TestTreeInsert3_4_5AfterQuery(t *testing.T) {
  function TestTreeInternalNodeSplit (line 215) | func TestTreeInternalNodeSplit(t *testing.T) {
  function TestTreeInternalNodeSplitReverseOrder (line 227) | func TestTreeInternalNodeSplitReverseOrder(t *testing.T) {
  function TestTreeInternalNodeSplitRandomOrder (line 241) | func TestTreeInternalNodeSplitRandomOrder(t *testing.T) {
  function TestTreeRandomOrderQuery (line 261) | func TestTreeRandomOrderQuery(t *testing.T) {
  function TestTreeGet (line 281) | func TestTreeGet(t *testing.T) {
  function TestTreeGetNotFound (line 293) | func TestTreeGetNotFound(t *testing.T) {
  function TestGetExactMatchesOnly (line 301) | func TestGetExactMatchesOnly(t *testing.T) {
  function BenchmarkIteration (line 310) | func BenchmarkIteration(b *testing.B) {
  function BenchmarkInsert (line 327) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkBulkAdd (line 340) | func BenchmarkBulkAdd(b *testing.B) {
  function BenchmarkGet (line 352) | func BenchmarkGet(b *testing.B) {
  function BenchmarkBulkAddToExisting (line 367) | func BenchmarkBulkAddToExisting(b *testing.B) {
  function BenchmarkReadAndWrites (line 383) | func BenchmarkReadAndWrites(b *testing.B) {
  function BenchmarkSimultaneousReadsAndWrites (line 399) | func BenchmarkSimultaneousReadsAndWrites(b *testing.B) {

FILE: btree/plus/interface.go
  type Keys (line 20) | type Keys
  type Key (line 22) | type Key interface
  type Iterator (line 32) | type Iterator interface

FILE: btree/plus/iterator.go
  constant iteratorExhausted (line 19) | iteratorExhausted = -2
  type iterator (line 21) | type iterator struct
    method Next (line 26) | func (iter *iterator) Next() bool {
    method Value (line 44) | func (iter *iterator) Value() Key {
    method exhaust (line 55) | func (iter *iterator) exhaust() keys {
  function nilIterator (line 64) | func nilIterator() *iterator {

FILE: btree/plus/mock_test.go
  function chunkKeys (line 19) | func chunkKeys(ks keys, numParts int64) []keys {
  type mockKey (line 27) | type mockKey struct
    method Compare (line 31) | func (mk *mockKey) Compare(other Key) int {
  function newMockKey (line 43) | func newMockKey(value int) *mockKey {

FILE: btree/plus/node.go
  function split (line 19) | func split(tree *btree, parent, child node) node {
  type node (line 49) | type node interface
  type nodes (line 59) | type nodes
    method insertAt (line 61) | func (nodes *nodes) insertAt(i int, node node) {
    method splitAt (line 72) | func (ns nodes) splitAt(i int) (nodes, nodes) {
  type inode (line 80) | type inode struct
    method search (line 85) | func (node *inode) search(key Key) int {
    method find (line 89) | func (node *inode) find(key Key) *iterator {
    method insert (line 104) | func (n *inode) insert(tree *btree, key Key) bool {
    method needsSplit (line 131) | func (n *inode) needsSplit(nodeSize uint64) bool {
    method split (line 135) | func (n *inode) split() (Key, node, node) {
  function newInternalNode (line 157) | func newInternalNode(size uint64) *inode {
  type lnode (line 164) | type lnode struct
    method search (line 170) | func (node *lnode) search(key Key) int {
    method insert (line 174) | func (lnode *lnode) insert(tree *btree, key Key) bool {
    method find (line 196) | func (node *lnode) find(key Key) *iterator {
    method split (line 216) | func (node *lnode) split() (Key, node, node) {
    method needsSplit (line 239) | func (lnode *lnode) needsSplit(nodeSize uint64) bool {
  function newLeafNode (line 243) | func newLeafNode(size uint64) *lnode {
  type keys (line 249) | type keys
    method search (line 251) | func (keys keys) search(key Key) int {
    method insertAt (line 255) | func (keys *keys) insertAt(i int, key Key) {
    method reverse (line 266) | func (keys keys) reverse() {

FILE: btree/plus/node_test.go
  function constructMockPayloads (line 26) | func constructMockPayloads(num int) keys {
  function constructMockKeys (line 35) | func constructMockKeys(num int) keys {
  function constructRandomMockKeys (line 45) | func constructRandomMockKeys(num int) keys {
  function constructMockNodes (line 54) | func constructMockNodes(num int) nodes {
  function constructMockInternalNode (line 74) | func constructMockInternalNode(nodes nodes) *inode {
  function TestLeafNodeInsert (line 91) | func TestLeafNodeInsert(t *testing.T) {
  function TestDuplicateLeafNodeInsert (line 104) | func TestDuplicateLeafNodeInsert(t *testing.T) {
  function TestMultipleLeafNodeInsert (line 115) | func TestMultipleLeafNodeInsert(t *testing.T) {
  function TestLeafNodeSplitEvenNumber (line 133) | func TestLeafNodeSplitEvenNumber(t *testing.T) {
  function TestLeafNodeSplitOddNumber (line 147) | func TestLeafNodeSplitOddNumber(t *testing.T) {
  function TestTwoKeysLeafNodeSplit (line 161) | func TestTwoKeysLeafNodeSplit(t *testing.T) {
  function TestLessThanTwoKeysSplit (line 175) | func TestLessThanTwoKeysSplit(t *testing.T) {
  function TestInternalNodeSplit2_3_4 (line 188) | func TestInternalNodeSplit2_3_4(t *testing.T) {
  function TestInternalNodeSplit3_4_5 (line 200) | func TestInternalNodeSplit3_4_5(t *testing.T) {
  function TestInternalNodeLessThan3Keys (line 212) | func TestInternalNodeLessThan3Keys(t *testing.T) {

FILE: cache/cache.go
  type Cache (line 9) | type Cache interface
  type Item (line 25) | type Item interface
  type cached (line 31) | type cached struct
    method setElementIfNotNil (line 37) | func (c *cached) setElementIfNotNil(element *list.Element) {
  type cache (line 44) | type cache struct
    method Get (line 101) | func (c *cache) Get(keys ...string) []Item {
    method Put (line 119) | func (c *cache) Put(key string, item Item) {
    method Remove (line 137) | func (c *cache) Remove(keys ...string) {
    method Size (line 146) | func (c *cache) Size() uint64 {
    method ensureCapacity (line 156) | func (c *cache) ensureCapacity(toAdd uint64) {
    method remove (line 167) | func (c *cache) remove(key string) {
    method noop (line 176) | func (c *cache) noop(string) *list.Element { return nil }
    method record (line 179) | func (c *cache) record(key string) *list.Element {
  type CacheOption (line 55) | type CacheOption
  type Policy (line 58) | type Policy
  constant LeastRecentlyAdded (line 62) | LeastRecentlyAdded Policy = iota
  constant LeastRecentlyUsed (line 64) | LeastRecentlyUsed
  function EvictionPolicy (line 69) | func EvictionPolicy(policy Policy) CacheOption {
  function New (line 85) | func New(capacity uint64, options ...CacheOption) Cache {

FILE: cache/cache_test.go
  function TestEvictionPolicy (line 10) | func TestEvictionPolicy(t *testing.T) {
  function TestNew (line 24) | func TestNew(t *testing.T) {
  type testItem (line 43) | type testItem
    method Size (line 45) | func (ti testItem) Size() uint64 {
  function TestPutGetRemoveSize (line 49) | func TestPutGetRemoveSize(t *testing.T) {

FILE: common/interface.go
  type Comparator (line 21) | type Comparator interface
  type Comparators (line 29) | type Comparators

FILE: fibheap/fibheap.go
  type FloatingFibonacciHeap (line 83) | type FloatingFibonacciHeap struct
    method Enqueue (line 118) | func (heap *FloatingFibonacciHeap) Enqueue(priority float64) *Entry {
    method Min (line 128) | func (heap *FloatingFibonacciHeap) Min() (*Entry, error) {
    method IsEmpty (line 136) | func (heap *FloatingFibonacciHeap) IsEmpty() bool {
    method Size (line 141) | func (heap *FloatingFibonacciHeap) Size() uint {
    method DequeueMin (line 147) | func (heap *FloatingFibonacciHeap) DequeueMin() (*Entry, error) {
    method DecreaseKey (line 251) | func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriorit...
    method Delete (line 271) | func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
    method Merge (line 291) | func (heap *FloatingFibonacciHeap) Merge(other *FloatingFibonacciHeap)...
  type Entry (line 90) | type Entry struct
  type EmptyHeapError (line 100) | type EmptyHeapError
    method Error (line 102) | func (e EmptyHeapError) Error() string {
  type NilError (line 108) | type NilError
    method Error (line 110) | func (e NilError) Error() string {
  function NewFloatFibHeap (line 115) | func NewFloatFibHeap() FloatingFibonacciHeap { return FloatingFibonacciH...
  function newEntry (line 317) | func newEntry(priority float64) *Entry {
  function mergeLists (line 329) | func mergeLists(one, two *Entry) *Entry {
  function decreaseKeyUnchecked (line 351) | func decreaseKeyUnchecked(heap *FloatingFibonacciHeap, node *Entry, prio...
  function cutNode (line 363) | func cutNode(heap *FloatingFibonacciHeap, node *Entry) {

FILE: fibheap/fibheap_examples_test.go
  constant SomeNumber (line 9) | SomeNumber float64 = 15.5
  constant SomeSmallerNumber (line 10) | SomeSmallerNumber float64 = -10.1
  constant SomeLargerNumber (line 11) | SomeLargerNumber float64 = 112.211
  function ExampleFloatingFibonacciHeap_Enqueue (line 13) | func ExampleFloatingFibonacciHeap_Enqueue() {
  function ExampleFloatingFibonacciHeap_Min (line 22) | func ExampleFloatingFibonacciHeap_Min() {
  function ExampleFloatingFibonacciHeap_IsEmpty (line 31) | func ExampleFloatingFibonacciHeap_IsEmpty() {
  function ExampleFloatingFibonacciHeap_Size (line 41) | func ExampleFloatingFibonacciHeap_Size() {
  function ExampleFloatingFibonacciHeap_DequeueMin (line 51) | func ExampleFloatingFibonacciHeap_DequeueMin() {
  function ExampleFloatingFibonacciHeap_DecreaseKey (line 60) | func ExampleFloatingFibonacciHeap_DecreaseKey() {
  function ExampleFloatingFibonacciHeap_Delete (line 73) | func ExampleFloatingFibonacciHeap_Delete() {
  function ExampleFloatingFibonacciHeap_Merge (line 87) | func ExampleFloatingFibonacciHeap_Merge() {

FILE: fibheap/fibheap_single_example_test.go
  constant SomeNumberAround0 (line 9) | SomeNumberAround0 float64 = -0.001
  constant SomeLargerNumberAround15 (line 10) | SomeLargerNumberAround15 float64 = 15.77
  constant SomeNumberAroundMinus1000 (line 11) | SomeNumberAroundMinus1000 float64 = -1002.2001
  constant SomeNumberAroundMinus1003 (line 12) | SomeNumberAroundMinus1003 float64 = -1003.4
  function Example (line 14) | func Example() {

FILE: fibheap/fibheap_test.go
  constant Seq1FirstMinimum (line 68) | Seq1FirstMinimum float64 = -9990847539.012056
  constant Seq1ThirdMinimum (line 69) | Seq1ThirdMinimum float64 = -9969381716.563528
  constant Seq1FifthMinimum (line 70) | Seq1FifthMinimum float64 = -9453697711.29756
  constant Seq1LastMinimum (line 71) | Seq1LastMinimum float64 = 9981219597.001732
  constant Seq2DecreaseKey1Orig (line 80) | Seq2DecreaseKey1Orig float64 = 9913821013.519611
  constant Seq2DecreaseKey1Trgt (line 81) | Seq2DecreaseKey1Trgt float64 = -8722989752.449871
  constant Seq2DecreaseKey2Orig (line 82) | Seq2DecreaseKey2Orig float64 = 9866088144.060883
  constant Seq2DecreaseKey2Trgt (line 83) | Seq2DecreaseKey2Trgt float64 = -9698869735.322557
  constant Seq2DecreaseKey3Orig (line 84) | Seq2DecreaseKey3Orig float64 = 9204710651.257133
  constant Seq2DecreaseKey3Trgt (line 85) | Seq2DecreaseKey3Trgt float64 = -9804710651.257133
  function TestEnqueueDequeueMin (line 126) | func TestEnqueueDequeueMin(t *testing.T) {
  function TestFibHeap_Enqueue_Min (line 152) | func TestFibHeap_Enqueue_Min(t *testing.T) {
  function TestFibHeap_Min_EmptyHeap (line 163) | func TestFibHeap_Min_EmptyHeap(t *testing.T) {
  function TestFibHeap_DequeueMin_EmptyHeap (line 178) | func TestFibHeap_DequeueMin_EmptyHeap(t *testing.T) {
  function TestEnqueueDecreaseKey (line 187) | func TestEnqueueDecreaseKey(t *testing.T) {
  function TestFibHeap_DecreaseKey_EmptyHeap (line 221) | func TestFibHeap_DecreaseKey_EmptyHeap(t *testing.T) {
  function TestFibHeap_DecreaseKey_NilNode (line 235) | func TestFibHeap_DecreaseKey_NilNode(t *testing.T) {
  function TestFibHeap_DecreaseKey_LargerNewPriority (line 245) | func TestFibHeap_DecreaseKey_LargerNewPriority(t *testing.T) {
  function TestEnqueueDelete (line 254) | func TestEnqueueDelete(t *testing.T) {
  function TestFibHeap_Delete_EmptyHeap (line 290) | func TestFibHeap_Delete_EmptyHeap(t *testing.T) {
  function TestFibHeap_Delete_NilNode (line 302) | func TestFibHeap_Delete_NilNode(t *testing.T) {
  function TestMerge (line 310) | func TestMerge(t *testing.T) {
  function TestFibHeap_Merge_NilHeap (line 332) | func TestFibHeap_Merge_NilHeap(t *testing.T) {
  function BenchmarkFibHeap_Enqueue (line 361) | func BenchmarkFibHeap_Enqueue(b *testing.B) {
  function BenchmarkFibHeap_DequeueMin (line 371) | func BenchmarkFibHeap_DequeueMin(b *testing.B) {
  function BenchmarkFibHeap_DecreaseKey (line 389) | func BenchmarkFibHeap_DecreaseKey(b *testing.B) {
  function BenchmarkFibHeap_Delete (line 413) | func BenchmarkFibHeap_Delete(b *testing.B) {
  function BenchmarkFibHeap_Merge (line 434) | func BenchmarkFibHeap_Merge(b *testing.B) {

FILE: futures/futures.go
  type Completer (line 34) | type Completer
  type Future (line 42) | type Future struct
    method GetResult (line 52) | func (f *Future) GetResult() (interface{}, error) {
    method HasResult (line 65) | func (f *Future) HasResult() bool {
    method setItem (line 72) | func (f *Future) setItem(item interface{}, err error) {
  function listenForResult (line 81) | func listenForResult(f *Future, ch Completer, timeout time.Duration, wg ...
  function New (line 97) | func New(completer Completer, timeout time.Duration) *Future {

FILE: futures/futures_test.go
  function TestWaitOnGetResult (line 27) | func TestWaitOnGetResult(t *testing.T) {
  function TestHasResult (line 52) | func TestHasResult(t *testing.T) {
  function TestTimeout (line 71) | func TestTimeout(t *testing.T) {
  function BenchmarkFuture (line 81) | func BenchmarkFuture(b *testing.B) {

FILE: futures/selectable.go
  type Selectable (line 34) | type Selectable struct
    method wchan (line 49) | func (f *Selectable) wchan() <-chan struct{} {
    method WaitChan (line 60) | func (f *Selectable) WaitChan() <-chan struct{} {
    method GetResult (line 69) | func (f *Selectable) GetResult() (interface{}, error) {
    method Fill (line 78) | func (f *Selectable) Fill(v interface{}, e error) error {
    method SetValue (line 95) | func (f *Selectable) SetValue(v interface{}) error {
    method SetError (line 100) | func (f *Selectable) SetError(e error) {
    method Cancel (line 105) | func (f *Selectable) Cancel() {
  function NewSelectable (line 45) | func NewSelectable() *Selectable {
  function init (line 111) | func init() {

FILE: futures/selectable_test.go
  function TestSelectableGetResult (line 29) | func TestSelectableGetResult(t *testing.T) {
  function TestSelectableSetError (line 53) | func TestSelectableSetError(t *testing.T) {
  function BenchmarkSelectable (line 67) | func BenchmarkSelectable(b *testing.B) {

FILE: graph/simple.go
  type SimpleGraph (line 45) | type SimpleGraph struct
    method V (line 52) | func (g *SimpleGraph) V() int {
    method E (line 60) | func (g *SimpleGraph) E() int {
    method AddEdge (line 68) | func (g *SimpleGraph) AddEdge(v, w interface{}) error {
    method Adj (line 90) | func (g *SimpleGraph) Adj(v interface{}) ([]interface{}, error) {
    method Degree (line 109) | func (g *SimpleGraph) Degree(v interface{}) (int, error) {
    method addVertex (line 120) | func (g *SimpleGraph) addVertex(v interface{}) {
  function NewSimpleGraph (line 130) | func NewSimpleGraph() *SimpleGraph {

FILE: graph/simple_test.go
  function TestV (line 25) | func TestV(t *testing.T) {
  function TestE (line 52) | func TestE(t *testing.T) {
  function TestDegree (line 80) | func TestDegree(t *testing.T) {
  function TestAddEdge (line 146) | func TestAddEdge(t *testing.T) {
  function TestAdj (line 170) | func TestAdj(t *testing.T) {

FILE: hashmap/fastinteger/hash.go
  function hash (line 6) | func hash(key uint64) uint64 {

FILE: hashmap/fastinteger/hash_test.go
  function TestHash (line 13) | func TestHash(t *testing.T) {
  function BenchmarkHash (line 20) | func BenchmarkHash(b *testing.B) {
  function BenchmarkFnvHash (line 38) | func BenchmarkFnvHash(b *testing.B) {

FILE: hashmap/fastinteger/hashmap.go
  constant ratio (line 23) | ratio = .75
  function roundUp (line 27) | func roundUp(v uint64) uint64 {
  type packet (line 39) | type packet struct
  type packets (line 43) | type packets
    method find (line 45) | func (packets packets) find(key uint64) uint64 {
    method set (line 55) | func (packets packets) set(packet *packet) {
    method get (line 65) | func (packets packets) get(key uint64) (uint64, bool) {
    method delete (line 74) | func (packets packets) delete(key uint64) bool {
    method exists (line 90) | func (packets packets) exists(key uint64) bool {
  type FastIntegerHashMap (line 100) | type FastIntegerHashMap struct
    method rebuild (line 109) | func (fi *FastIntegerHashMap) rebuild() {
    method Get (line 123) | func (fi *FastIntegerHashMap) Get(key uint64) (uint64, bool) {
    method Set (line 128) | func (fi *FastIntegerHashMap) Set(key, value uint64) {
    method Exists (line 139) | func (fi *FastIntegerHashMap) Exists(key uint64) bool {
    method Delete (line 145) | func (fi *FastIntegerHashMap) Delete(key uint64) {
    method Len (line 152) | func (fi *FastIntegerHashMap) Len() uint64 {
    method Cap (line 157) | func (fi *FastIntegerHashMap) Cap() uint64 {
  function New (line 163) | func New(hint uint64) *FastIntegerHashMap {

FILE: hashmap/fastinteger/hashmap_test.go
  function generateKeys (line 11) | func generateKeys(num int) []uint64 {
  function TestRoundUp (line 23) | func TestRoundUp(t *testing.T) {
  function TestInsert (line 34) | func TestInsert(t *testing.T) {
  function TestInsertOverwrite (line 46) | func TestInsertOverwrite(t *testing.T) {
  function TestGet (line 58) | func TestGet(t *testing.T) {
  function TestMultipleInserts (line 66) | func TestMultipleInserts(t *testing.T) {
  function TestRebuild (line 78) | func TestRebuild(t *testing.T) {
  function TestDelete (line 93) | func TestDelete(t *testing.T) {
  function TestDeleteAll (line 109) | func TestDeleteAll(t *testing.T) {
  function TestDeleteCollision (line 124) | func TestDeleteCollision(t *testing.T) {
  function BenchmarkInsert (line 141) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkGoMapInsert (line 156) | func BenchmarkGoMapInsert(b *testing.B) {
  function BenchmarkExists (line 171) | func BenchmarkExists(b *testing.B) {
  function BenchmarkGoMapExists (line 189) | func BenchmarkGoMapExists(b *testing.B) {
  function BenchmarkDelete (line 212) | func BenchmarkDelete(b *testing.B) {
  function BenchmarkGoDelete (line 234) | func BenchmarkGoDelete(b *testing.B) {
  function BenchmarkInsertWithExpand (line 256) | func BenchmarkInsertWithExpand(b *testing.B) {
  function BenchmarkGoInsertWithExpand (line 275) | func BenchmarkGoInsertWithExpand(b *testing.B) {

FILE: list/persistent.go
  type PersistentList (line 35) | type PersistentList interface
  type emptyList (line 78) | type emptyList struct
    method Head (line 82) | func (e *emptyList) Head() (interface{}, bool) {
    method Tail (line 88) | func (e *emptyList) Tail() (PersistentList, bool) {
    method IsEmpty (line 93) | func (e *emptyList) IsEmpty() bool {
    method Length (line 98) | func (e *emptyList) Length() uint {
    method Add (line 103) | func (e *emptyList) Add(head interface{}) PersistentList {
    method Insert (line 109) | func (e *emptyList) Insert(val interface{}, pos uint) (PersistentList,...
    method Get (line 118) | func (e *emptyList) Get(pos uint) (interface{}, bool) {
    method Remove (line 124) | func (e *emptyList) Remove(pos uint) (PersistentList, error) {
    method Find (line 130) | func (e *emptyList) Find(func(interface{}) bool) (interface{}, bool) {
    method FindIndex (line 136) | func (e *emptyList) FindIndex(func(interface{}) bool) int {
    method Map (line 142) | func (e *emptyList) Map(func(interface{}) interface{}) []interface{} {
  type list (line 146) | type list struct
    method Head (line 153) | func (l *list) Head() (interface{}, bool) {
    method Tail (line 159) | func (l *list) Tail() (PersistentList, bool) {
    method IsEmpty (line 164) | func (l *list) IsEmpty() bool {
    method Length (line 169) | func (l *list) Length() uint {
    method Add (line 183) | func (l *list) Add(head interface{}) PersistentList {
    method Insert (line 189) | func (l *list) Insert(val interface{}, pos uint) (PersistentList, erro...
    method Get (line 202) | func (l *list) Get(pos uint) (interface{}, bool) {
    method Remove (line 211) | func (l *list) Remove(pos uint) (PersistentList, error) {
    method Find (line 226) | func (l *list) Find(pred func(interface{}) bool) (interface{}, bool) {
    method FindIndex (line 235) | func (l *list) FindIndex(pred func(interface{}) bool) int {
    method Map (line 253) | func (l *list) Map(f func(interface{}) interface{}) []interface{} {

FILE: list/persistent_test.go
  function TestEmptyList (line 25) | func TestEmptyList(t *testing.T) {
  function TestAdd (line 38) | func TestAdd(t *testing.T) {
  function TestInsertAndGet (line 92) | func TestInsertAndGet(t *testing.T) {
  function TestRemove (line 124) | func TestRemove(t *testing.T) {
  function TestFind (line 227) | func TestFind(t *testing.T) {
  function TestFindIndex (line 250) | func TestFindIndex(t *testing.T) {
  function TestLength (line 270) | func TestLength(t *testing.T) {
  function TestMap (line 280) | func TestMap(t *testing.T) {

FILE: mock/batcher.go
  type Batcher (line 27) | type Batcher struct
    method Put (line 32) | func (m *Batcher) Put(items interface{}) error {
    method Get (line 40) | func (m *Batcher) Get() ([]interface{}, error) {
    method Flush (line 45) | func (m *Batcher) Flush() error {
    method Dispose (line 50) | func (m *Batcher) Dispose() {
    method IsDisposed (line 54) | func (m *Batcher) IsDisposed() bool {

FILE: mock/rangetree.go
  type RangeTree (line 9) | type RangeTree struct
    method Add (line 15) | func (m *RangeTree) Add(entries ...rangetree.Entry) rangetree.Entries {
    method Len (line 25) | func (m *RangeTree) Len() uint64 {
    method Delete (line 29) | func (m *RangeTree) Delete(entries ...rangetree.Entry) rangetree.Entri...
    method Query (line 33) | func (m *RangeTree) Query(interval rangetree.Interval) rangetree.Entri...
    method InsertAtDimension (line 43) | func (m *RangeTree) InsertAtDimension(dimension uint64, index,
    method Apply (line 50) | func (m *RangeTree) Apply(interval rangetree.Interval, fn func(rangetr...
    method Get (line 54) | func (m *RangeTree) Get(entries ...rangetree.Entry) rangetree.Entries {

FILE: numerics/hilbert/hilbert.go
  constant n (line 37) | n = 1 << 31
  function boolToInt (line 39) | func boolToInt(value bool) int32 {
  function rotate (line 47) | func rotate(n, rx, ry int32, x, y *int32) {
  function Encode (line 62) | func Encode(x, y int32) int64 {
  function Decode (line 77) | func Decode(h int64) (int32, int32) {

FILE: numerics/hilbert/hilbert_test.go
  function TestHilbert (line 25) | func TestHilbert(t *testing.T) {
  function TestHilbertAtMaxRange (line 51) | func TestHilbertAtMaxRange(t *testing.T) {
  function BenchmarkEncode (line 59) | func BenchmarkEncode(b *testing.B) {
  function BenchmarkDecode (line 65) | func BenchmarkDecode(b *testing.B) {

FILE: numerics/optimization/global.go
  type pbs (line 8) | type pbs
    method calculateProbabilities (line 43) | func (pbs pbs) calculateProbabilities(bestGuess *nmVertex, sigma float...
    method sort (line 49) | func (pbs pbs) sort() {
    method Less (line 53) | func (pbs pbs) Less(i, j int) bool {
    method Swap (line 57) | func (pbs pbs) Swap(i, j int) {
    method Len (line 61) | func (pbs pbs) Len() int {
  type vertexProbabilityBundle (line 10) | type vertexProbabilityBundle struct
  function calculateVVP (line 26) | func calculateVVP(guess, vertex *nmVertex, sigma float64) float64 {
  function calculateSigma (line 39) | func calculateSigma(dimensions, guesses int) float64 {
  type results (line 67) | type results struct
    method search (line 79) | func (results *results) search(result *nmVertex) int {
    method exists (line 85) | func (results *results) exists(result *nmVertex, hint int) bool {
    method insert (line 104) | func (results *results) insert(vertex *nmVertex) {
    method grab (line 120) | func (results *results) grab(num int) vertices {
    method reSort (line 145) | func (results *results) reSort(vertex *nmVertex) {
  function newResults (line 154) | func newResults(guess *nmVertex, config NelderMeadConfiguration, num int...

FILE: numerics/optimization/nelder_mead.go
  constant alpha (line 12) | alpha         = 1
  constant beta (line 13) | beta          = 2
  constant gamma (line 14) | gamma         = .5
  constant sigma (line 15) | sigma         = .5
  constant delta (line 16) | delta         = .0001
  constant maxRuns (line 17) | maxRuns       = 130
  constant maxIterations (line 18) | maxIterations = 5
  function generateRandomVerticesFromGuess (line 29) | func generateRandomVerticesFromGuess(guess *nmVertex, num int) vertices {
  function isInf (line 84) | func isInf(num float64) bool {
  function findMin (line 88) | func findMin(vertices ...*nmVertex) *nmVertex {
  function findMidpoint (line 101) | func findMidpoint(vertices ...*nmVertex) *nmVertex {
  function determineDistance (line 121) | func determineDistance(value, target float64) float64 {
  type vertices (line 131) | type vertices
    method evaluate (line 135) | func (vertices vertices) evaluate(config NelderMeadConfiguration) {
    method sort (line 143) | func (vertices vertices) sort(config NelderMeadConfiguration) {
    method String (line 180) | func (vertices vertices) String() string {
  type sorter (line 151) | type sorter struct
    method sort (line 156) | func (sorter sorter) sort() {
    method Less (line 166) | func (sorter sorter) Less(i, j int) bool {
    method Len (line 170) | func (sorter sorter) Len() int {
    method Swap (line 174) | func (sorter sorter) Swap(i, j int) {
  type NelderMeadConfiguration (line 194) | type NelderMeadConfiguration struct
  type nmVertex (line 215) | type nmVertex struct
    method evaluate (line 231) | func (nm *nmVertex) evaluate(config NelderMeadConfiguration) {
    method add (line 236) | func (nm *nmVertex) add(other *nmVertex) *nmVertex {
    method multiply (line 247) | func (nm *nmVertex) multiply(scalar float64) *nmVertex {
    method subtract (line 258) | func (nm *nmVertex) subtract(other *nmVertex) *nmVertex {
    method less (line 279) | func (nm *nmVertex) less(config NelderMeadConfiguration, other *nmVert...
    method equal (line 290) | func (nm *nmVertex) equal(config NelderMeadConfiguration, other *nmVer...
    method euclideanDistance (line 301) | func (nm *nmVertex) euclideanDistance(other *nmVertex) float64 {
    method equalToVertex (line 315) | func (nm *nmVertex) equalToVertex(other *nmVertex) bool {
    method approximatelyEqualToVertex (line 331) | func (nm *nmVertex) approximatelyEqualToVertex(other *nmVertex) bool {
  type nelderMead (line 335) | type nelderMead struct
    method evaluateWithConstraints (line 346) | func (nm *nelderMead) evaluateWithConstraints(vertices vertices, verte...
    method reflect (line 365) | func (nm *nelderMead) reflect(vertices vertices, midpoint *nmVertex) *...
    method expand (line 372) | func (nm *nelderMead) expand(vertices vertices, midpoint, reflection *...
    method lastDimensionVertex (line 382) | func (nm *nelderMead) lastDimensionVertex(vertices vertices) *nmVertex {
    method lastVertex (line 389) | func (nm *nelderMead) lastVertex(vertices vertices) *nmVertex {
    method outsideContract (line 393) | func (nm *nelderMead) outsideContract(vertices vertices, midpoint, ref...
    method insideContract (line 400) | func (nm *nelderMead) insideContract(vertices vertices, midpoint, refl...
    method shrink (line 407) | func (nm *nelderMead) shrink(vertices vertices) {
    method checkIteration (line 419) | func (nm *nelderMead) checkIteration(vertices vertices) bool {
    method evaluate (line 454) | func (nm *nelderMead) evaluate() {
  function newNelderMead (line 542) | func newNelderMead(config NelderMeadConfiguration) *nelderMead {
  function NelderMead (line 555) | func NelderMead(config NelderMeadConfiguration) []float64 {

FILE: numerics/optimization/nelder_mead_test.go
  function TestNelderMead (line 10) | func TestNelderMead(t *testing.T) {
  function TestNelderMeadPolynomial (line 24) | func TestNelderMeadPolynomial(t *testing.T) {
  function TestNelderMeadPolynomialMin (line 42) | func TestNelderMeadPolynomialMin(t *testing.T) {
  function TestNelderMeadPolynomialMax (line 60) | func TestNelderMeadPolynomialMax(t *testing.T) {
  function TestNelderMeadConstrained (line 77) | func TestNelderMeadConstrained(t *testing.T) {
  function TestNelderMeadConstrainedBadGuess (line 125) | func TestNelderMeadConstrainedBadGuess(t *testing.T) {

FILE: queue/mock_test.go
  type mockItem (line 19) | type mockItem
    method Compare (line 21) | func (mi mockItem) Compare(other Item) int {

FILE: queue/priority_queue.go
  type Item (line 30) | type Item interface
  type priorityItems (line 40) | type priorityItems
    method swap (line 42) | func (items *priorityItems) swap(i, j int) {
    method pop (line 46) | func (items *priorityItems) pop() Item {
    method get (line 76) | func (items *priorityItems) get(number int) []Item {
    method push (line 89) | func (items *priorityItems) push(item Item) {
  type PriorityQueue (line 107) | type PriorityQueue struct
    method Put (line 118) | func (pq *PriorityQueue) Put(items ...Item) error {
    method Get (line 159) | func (pq *PriorityQueue) Get(number int) ([]Item, error) {
    method Peek (line 206) | func (pq *PriorityQueue) Peek() Item {
    method Empty (line 217) | func (pq *PriorityQueue) Empty() bool {
    method Len (line 225) | func (pq *PriorityQueue) Len() int {
    method Disposed (line 233) | func (pq *PriorityQueue) Disposed() bool {
    method Dispose (line 242) | func (pq *PriorityQueue) Dispose() {
  function NewPriorityQueue (line 260) | func NewPriorityQueue(hint int, allowDuplicates bool) *PriorityQueue {

FILE: queue/priority_queue_test.go
  function TestPriorityPut (line 26) | func TestPriorityPut(t *testing.T) {
  function TestPriorityGet (line 43) | func TestPriorityGet(t *testing.T) {
  function TestAddEmptyPriorityPut (line 86) | func TestAddEmptyPriorityPut(t *testing.T) {
  function TestPriorityGetNonPositiveNumber (line 94) | func TestPriorityGetNonPositiveNumber(t *testing.T) {
  function TestPriorityEmpty (line 114) | func TestPriorityEmpty(t *testing.T) {
  function TestPriorityGetEmpty (line 123) | func TestPriorityGetEmpty(t *testing.T) {
  function TestMultiplePriorityGetEmpty (line 141) | func TestMultiplePriorityGetEmpty(t *testing.T) {
  function TestEmptyPriorityGetWithDispose (line 177) | func TestEmptyPriorityGetWithDispose(t *testing.T) {
  function TestPriorityGetPutDisposed (line 199) | func TestPriorityGetPutDisposed(t *testing.T) {
  function BenchmarkPriorityQueue (line 210) | func BenchmarkPriorityQueue(b *testing.B) {
  function TestPriorityPeek (line 234) | func TestPriorityPeek(t *testing.T) {
  function TestInsertDuplicate (line 241) | func TestInsertDuplicate(t *testing.T) {
  function TestAllowDuplicates (line 249) | func TestAllowDuplicates(t *testing.T) {

FILE: queue/queue.go
  type waiters (line 61) | type waiters
    method get (line 63) | func (w *waiters) get() *sema {
    method put (line 75) | func (w *waiters) put(sema *sema) {
    method remove (line 79) | func (w *waiters) remove(sema *sema) {
  type items (line 94) | type items
    method get (line 96) | func (items *items) get(number int64) []interface{} {
    method peek (line 113) | func (items *items) peek() (interface{}, bool) {
    method getUntil (line 123) | func (items *items) getUntil(checker func(item interface{}) bool) []in...
  type sema (line 148) | type sema struct
  function newSema (line 153) | func newSema() *sema {
  type Queue (line 162) | type Queue struct
    method Put (line 170) | func (q *Queue) Put(items ...interface{}) error {
    method Get (line 208) | func (q *Queue) Get(number int64) ([]interface{}, error) {
    method Poll (line 217) | func (q *Queue) Poll(number int64, timeout time.Duration) ([]interface...
    method Peek (line 274) | func (q *Queue) Peek() (interface{}, error) {
    method TakeUntil (line 293) | func (q *Queue) TakeUntil(checker func(item interface{}) bool) ([]inte...
    method Empty (line 311) | func (q *Queue) Empty() bool {
    method Len (line 319) | func (q *Queue) Len() int64 {
    method Disposed (line 328) | func (q *Queue) Disposed() bool {
    method Dispose (line 338) | func (q *Queue) Dispose() []interface{} {
  function New (line 362) | func New(hint int64) *Queue {
  function ExecuteInParallel (line 372) | func ExecuteInParallel(q *Queue, fn func(interface{})) {

FILE: queue/queue_test.go
  function TestPut (line 28) | func TestPut(t *testing.T) {
  function TestGet (line 52) | func TestGet(t *testing.T) {
  function TestPoll (line 85) | func TestPoll(t *testing.T) {
  function TestPollNoMemoryLeak (line 128) | func TestPollNoMemoryLeak(t *testing.T) {
  function TestAddEmptyPut (line 140) | func TestAddEmptyPut(t *testing.T) {
  function TestGetNonPositiveNumber (line 150) | func TestGetNonPositiveNumber(t *testing.T) {
  function TestEmpty (line 164) | func TestEmpty(t *testing.T) {
  function TestGetEmpty (line 177) | func TestGetEmpty(t *testing.T) {
  function TestMultipleGetEmpty (line 193) | func TestMultipleGetEmpty(t *testing.T) {
  function TestDispose (line 228) | func TestDispose(t *testing.T) {
  function TestEmptyGetWithDispose (line 248) | func TestEmptyGetWithDispose(t *testing.T) {
  function TestDisposeAfterEmptyPoll (line 271) | func TestDisposeAfterEmptyPoll(t *testing.T) {
  function TestGetPutDisposed (line 284) | func TestGetPutDisposed(t *testing.T) {
  function BenchmarkQueue (line 296) | func BenchmarkQueue(b *testing.B) {
  function BenchmarkChannel (line 320) | func BenchmarkChannel(b *testing.B) {
  function TestPeek (line 344) | func TestPeek(t *testing.T) {
  function TestPeekOnDisposedQueue (line 361) | func TestPeekOnDisposedQueue(t *testing.T) {
  function TestTakeUntil (line 370) | func TestTakeUntil(t *testing.T) {
  function TestTakeUntilEmptyQueue (line 385) | func TestTakeUntilEmptyQueue(t *testing.T) {
  function TestTakeUntilThenGet (line 399) | func TestTakeUntilThenGet(t *testing.T) {
  function TestTakeUntilNoMatches (line 411) | func TestTakeUntilNoMatches(t *testing.T) {
  function TestTakeUntilOnDisposedQueue (line 423) | func TestTakeUntilOnDisposedQueue(t *testing.T) {
  function TestWaiters (line 434) | func TestWaiters(t *testing.T) {
  function TestExecuteInParallel (line 496) | func TestExecuteInParallel(t *testing.T) {
  function TestExecuteInParallelEmptyQueue (line 513) | func TestExecuteInParallelEmptyQueue(t *testing.T) {
  function BenchmarkQueuePut (line 522) | func BenchmarkQueuePut(b *testing.B) {
  function BenchmarkQueueGet (line 541) | func BenchmarkQueueGet(b *testing.B) {
  function BenchmarkQueuePoll (line 564) | func BenchmarkQueuePoll(b *testing.B) {
  function BenchmarkExecuteInParallel (line 586) | func BenchmarkExecuteInParallel(b *testing.B) {

FILE: queue/ring.go
  function roundUp (line 27) | func roundUp(v uint64) uint64 {
  type node (line 39) | type node struct
  type nodes (line 44) | type nodes
  type RingBuffer (line 52) | type RingBuffer struct
    method init (line 63) | func (rb *RingBuffer) init(size uint64) {
    method Put (line 75) | func (rb *RingBuffer) Put(item interface{}) error {
    method Offer (line 83) | func (rb *RingBuffer) Offer(item interface{}) (bool, error) {
    method put (line 87) | func (rb *RingBuffer) put(item interface{}, offer bool) (bool, error) {
    method Get (line 125) | func (rb *RingBuffer) Get() (interface{}, error) {
    method Poll (line 134) | func (rb *RingBuffer) Poll(timeout time.Duration) (interface{}, error) {
    method Len (line 175) | func (rb *RingBuffer) Len() uint64 {
    method Cap (line 180) | func (rb *RingBuffer) Cap() uint64 {
    method Dispose (line 187) | func (rb *RingBuffer) Dispose() {
    method IsDisposed (line 193) | func (rb *RingBuffer) IsDisposed() bool {
  function NewRingBuffer (line 199) | func NewRingBuffer(size uint64) *RingBuffer {

FILE: queue/ring_test.go
  function TestRingInsert (line 28) | func TestRingInsert(t *testing.T) {
  function TestRingMultipleInserts (line 45) | func TestRingMultipleInserts(t *testing.T) {
  function TestIntertwinedGetAndPut (line 73) | func TestIntertwinedGetAndPut(t *testing.T) {
  function TestPutToFull (line 100) | func TestPutToFull(t *testing.T) {
  function TestOffer (line 132) | func TestOffer(t *testing.T) {
  function TestRingGetEmpty (line 153) | func TestRingGetEmpty(t *testing.T) {
  function TestRingPollEmpty (line 180) | func TestRingPollEmpty(t *testing.T) {
  function TestRingPoll (line 187) | func TestRingPoll(t *testing.T) {
  function TestRingLen (line 228) | func TestRingLen(t *testing.T) {
  function TestDisposeOnGet (line 247) | func TestDisposeOnGet(t *testing.T) {
  function TestDisposeOnPut (line 271) | func TestDisposeOnPut(t *testing.T) {
  function BenchmarkRBLifeCycle (line 303) | func BenchmarkRBLifeCycle(b *testing.B) {
  function BenchmarkRBLifeCycleContention (line 331) | func BenchmarkRBLifeCycleContention(b *testing.B) {
  function BenchmarkRBPut (line 369) | func BenchmarkRBPut(b *testing.B) {
  function BenchmarkRBGet (line 386) | func BenchmarkRBGet(b *testing.B) {
  function BenchmarkRBAllocation (line 400) | func BenchmarkRBAllocation(b *testing.B) {

FILE: rangetree/entries.go
  type Entries (line 29) | type Entries
    method Dispose (line 33) | func (entries *Entries) Dispose() {
  function NewEntries (line 43) | func NewEntries() Entries {

FILE: rangetree/entries_test.go
  function TestDisposeEntries (line 25) | func TestDisposeEntries(t *testing.T) {

FILE: rangetree/error.go
  type NoEntriesError (line 23) | type NoEntriesError struct
    method Error (line 25) | func (nee NoEntriesError) Error() string {
  type OutOfDimensionError (line 31) | type OutOfDimensionError struct
    method Error (line 35) | func (oode OutOfDimensionError) Error() string {

FILE: rangetree/immutable.go
  type immutableRangeTree (line 21) | type immutableRangeTree struct
    method needNextDimension (line 35) | func (irt *immutableRangeTree) needNextDimension() bool {
    method add (line 39) | func (irt *immutableRangeTree) add(nodes *orderedNodes, cache []slice....
    method Add (line 78) | func (irt *immutableRangeTree) Add(entries ...Entry) *immutableRangeTr...
    method InsertAtDimension (line 102) | func (irt *immutableRangeTree) InsertAtDimension(dimension uint64,
    method Delete (line 129) | func (irt *immutableRangeTree) Delete(entries ...Entry) *immutableRang...
    method delete (line 144) | func (irt *immutableRangeTree) delete(top *orderedNodes,
    method apply (line 200) | func (irt *immutableRangeTree) apply(list orderedNodes, interval Inter...
    method Query (line 226) | func (irt *immutableRangeTree) Query(interval Interval) Entries {
    method get (line 237) | func (irt *immutableRangeTree) get(entry Entry) Entry {
    method Get (line 257) | func (irt *immutableRangeTree) Get(entries ...Entry) Entries {
    method Len (line 267) | func (irt *immutableRangeTree) Len() uint64 {
  function newCache (line 27) | func newCache(dimensions uint64) []slice.Int64Slice {
  type immutableNodeBundle (line 122) | type immutableNodeBundle struct
  function newImmutableRangeTree (line 271) | func newImmutableRangeTree(dimensions uint64) *immutableRangeTree {

FILE: rangetree/immutable_test.go
  function TestImmutableSingleDimensionAdd (line 25) | func TestImmutableSingleDimensionAdd(t *testing.T) {
  function TestImmutableSingleDimensionMultipleAdds (line 41) | func TestImmutableSingleDimensionMultipleAdds(t *testing.T) {
  function TestImmutableSingleDimensionBulkAdd (line 66) | func TestImmutableSingleDimensionBulkAdd(t *testing.T) {
  function TestImmutableMultiDimensionAdd (line 81) | func TestImmutableMultiDimensionAdd(t *testing.T) {
  function TestImmutableMultiDimensionMultipleAdds (line 97) | func TestImmutableMultiDimensionMultipleAdds(t *testing.T) {
  function TestImmutableMultiDimensionBulkAdd (line 122) | func TestImmutableMultiDimensionBulkAdd(t *testing.T) {
  function BenchmarkImmutableMultiDimensionInserts (line 137) | func BenchmarkImmutableMultiDimensionInserts(b *testing.B) {
  function BenchmarkImmutableMultiDimensionBulkInsert (line 156) | func BenchmarkImmutableMultiDimensionBulkInsert(b *testing.B) {
  function BenchmarkMultiDimensionBulkInsert (line 173) | func BenchmarkMultiDimensionBulkInsert(b *testing.B) {
  function TestImmutableSingleDimensionDelete (line 190) | func TestImmutableSingleDimensionDelete(t *testing.T) {
  function TestImmutableSingleDimensionMultipleDeletes (line 202) | func TestImmutableSingleDimensionMultipleDeletes(t *testing.T) {
  function TestImmutableSingleDimensionBulkDeletes (line 237) | func TestImmutableSingleDimensionBulkDeletes(t *testing.T) {
  function TestImmutableMultiDimensionDelete (line 259) | func TestImmutableMultiDimensionDelete(t *testing.T) {
  function TestImmutableMultiDimensionMultipleDeletes (line 272) | func TestImmutableMultiDimensionMultipleDeletes(t *testing.T) {
  function TestImmutableMultiDimensionBulkDeletes (line 307) | func TestImmutableMultiDimensionBulkDeletes(t *testing.T) {
  function constructMultiDimensionalImmutableTree (line 329) | func constructMultiDimensionalImmutableTree(number int64) (*immutableRan...
  function TestImmutableInsertPositiveIndexFirstDimension (line 339) | func TestImmutableInsertPositiveIndexFirstDimension(t *testing.T) {
  function TestImmutableInsertPositiveIndexSecondDimension (line 353) | func TestImmutableInsertPositiveIndexSecondDimension(t *testing.T) {
  function TestImmutableInsertPositiveIndexOutOfBoundsFirstDimension (line 367) | func TestImmutableInsertPositiveIndexOutOfBoundsFirstDimension(t *testin...
  function TestImmutableInsertPositiveIndexOutOfBoundsSecondDimension (line 376) | func TestImmutableInsertPositiveIndexOutOfBoundsSecondDimension(t *testi...
  function TestImmutableInsertMultiplePositiveIndexFirstDimension (line 385) | func TestImmutableInsertMultiplePositiveIndexFirstDimension(t *testing.T) {
  function TestImmutableInsertMultiplePositiveIndexSecondDimension (line 399) | func TestImmutableInsertMultiplePositiveIndexSecondDimension(t *testing....
  function TestImmutableInsertNegativeIndexFirstDimension (line 413) | func TestImmutableInsertNegativeIndexFirstDimension(t *testing.T) {
  function TestImmutableInsertNegativeIndexSecondDimension (line 432) | func TestImmutableInsertNegativeIndexSecondDimension(t *testing.T) {
  function TestImmutableInsertNegativeIndexOutOfBoundsFirstDimension (line 451) | func TestImmutableInsertNegativeIndexOutOfBoundsFirstDimension(t *testin...
  function TestImmutableInsertNegativeIndexOutOfBoundsSecondDimension (line 460) | func TestImmutableInsertNegativeIndexOutOfBoundsSecondDimension(t *testi...
  function TestImmutableInsertMultipleNegativeIndexFirstDimension (line 469) | func TestImmutableInsertMultipleNegativeIndexFirstDimension(t *testing.T) {
  function TestImmutableInsertMultipleNegativeIndexSecondDimension (line 484) | func TestImmutableInsertMultipleNegativeIndexSecondDimension(t *testing....
  function TestImmutableInsertInvalidDimension (line 499) | func TestImmutableInsertInvalidDimension(t *testing.T) {
  function TestImmutableInsertInvalidNumber (line 508) | func TestImmutableInsertInvalidNumber(t *testing.T) {
  function TestImmutableGet (line 517) | func TestImmutableGet(t *testing.T) {
  function BenchmarkImmutableInsertFirstDimension (line 527) | func BenchmarkImmutableInsertFirstDimension(b *testing.B) {
  function BenchmarkImmutableInsertSecondDimension (line 539) | func BenchmarkImmutableInsertSecondDimension(b *testing.B) {

FILE: rangetree/interface.go
  type Entry (line 32) | type Entry interface
  type Interval (line 40) | type Interval interface
  type RangeTree (line 50) | type RangeTree interface

FILE: rangetree/mock_test.go
  type mockEntry (line 19) | type mockEntry struct
    method ID (line 24) | func (me *mockEntry) ID() uint64 {
    method ValueAtDimension (line 28) | func (me *mockEntry) ValueAtDimension(dimension uint64) int64 {
  function constructMockEntry (line 32) | func constructMockEntry(id uint64, values ...int64) *mockEntry {
  type dimension (line 39) | type dimension struct
  type mockInterval (line 43) | type mockInterval struct
    method LowAtDimension (line 47) | func (mi *mockInterval) LowAtDimension(dimension uint64) int64 {
    method HighAtDimension (line 51) | func (mi *mockInterval) HighAtDimension(dimension uint64) int64 {
  function constructMockInterval (line 55) | func constructMockInterval(dimensions ...dimension) *mockInterval {

FILE: rangetree/node.go
  type nodes (line 19) | type nodes
  type node (line 21) | type node struct
  function newNode (line 27) | func newNode(value int64, entry Entry, needNextDimension bool) *node {

FILE: rangetree/ordered.go
  type orderedNodes (line 23) | type orderedNodes
    method search (line 25) | func (nodes orderedNodes) search(value int64) int {
    method addAt (line 34) | func (nodes *orderedNodes) addAt(i int, node *node) *node {
    method add (line 54) | func (nodes *orderedNodes) add(node *node) *node {
    method deleteAt (line 59) | func (nodes *orderedNodes) deleteAt(i int) *node {
    method delete (line 71) | func (nodes *orderedNodes) delete(value int64) *node {
    method apply (line 81) | func (nodes orderedNodes) apply(low, high int64, fn func(*node) bool) ...
    method get (line 100) | func (nodes orderedNodes) get(value int64) (*node, int) {
    method getOrAdd (line 113) | func (nodes *orderedNodes) getOrAdd(entry Entry,
    method flatten (line 137) | func (nodes orderedNodes) flatten(entries *Entries) {
    method insert (line 147) | func (nodes *orderedNodes) insert(insertDimension, dimension, maxDimen...
    method immutableInsert (line 189) | func (nodes orderedNodes) immutableInsert(insertDimension, dimension, ...

FILE: rangetree/ordered_test.go
  function TestOrderedAdd (line 25) | func TestOrderedAdd(t *testing.T) {
  function TestOrderedDelete (line 47) | func TestOrderedDelete(t *testing.T) {
  function TestApply (line 73) | func TestApply(t *testing.T) {
  function TestInsertDelete (line 141) | func TestInsertDelete(t *testing.T) {
  function BenchmarkPrepend (line 161) | func BenchmarkPrepend(b *testing.B) {

FILE: rangetree/orderedtree.go
  function isLastDimension (line 18) | func isLastDimension(value, test uint64) bool {
  type nodeBundle (line 22) | type nodeBundle struct
  type orderedTree (line 27) | type orderedTree struct
    method resetPath (line 34) | func (ot *orderedTree) resetPath() {
    method needNextDimension (line 38) | func (ot *orderedTree) needNextDimension() bool {
    method add (line 44) | func (ot *orderedTree) add(entry Entry) *node {
    method Add (line 70) | func (ot *orderedTree) Add(entries ...Entry) Entries {
    method delete (line 90) | func (ot *orderedTree) delete(entry Entry) *node {
    method get (line 122) | func (ot *orderedTree) get(entry Entry) Entry {
    method Get (line 142) | func (ot *orderedTree) Get(entries ...Entry) Entries {
    method Delete (line 155) | func (ot *orderedTree) Delete(entries ...Entry) Entries {
    method Len (line 176) | func (ot *orderedTree) Len() uint64 {
    method apply (line 180) | func (ot *orderedTree) apply(list orderedNodes, interval Interval,
    method Apply (line 208) | func (ot *orderedTree) Apply(interval Interval, fn func(Entry) bool) {
    method Query (line 216) | func (ot *orderedTree) Query(interval Interval) Entries {
    method InsertAtDimension (line 232) | func (ot *orderedTree) InsertAtDimension(dimension uint64,
  function newOrderedTree (line 252) | func newOrderedTree(dimensions uint64) *orderedTree {
  function New (line 261) | func New(dimensions uint64) RangeTree {

FILE: rangetree/orderedtree_test.go
  function constructMultiDimensionalOrderedTree (line 26) | func constructMultiDimensionalOrderedTree(number uint64) (
  function TestOTRootAddMultipleDimensions (line 41) | func TestOTRootAddMultipleDimensions(t *testing.T) {
  function TestOTMultipleAddMultipleDimensions (line 50) | func TestOTMultipleAddMultipleDimensions(t *testing.T) {
  function TestOTAddInOrderMultiDimensions (line 80) | func TestOTAddInOrderMultiDimensions(t *testing.T) {
  function TestOTAddReverseOrderMultiDimensions (line 89) | func TestOTAddReverseOrderMultiDimensions(t *testing.T) {
  function TestOTAddRandomOrderMultiDimensions (line 101) | func TestOTAddRandomOrderMultiDimensions(t *testing.T) {
  function TestOTAddLargeNumbersMultiDimension (line 115) | func TestOTAddLargeNumbersMultiDimension(t *testing.T) {
  function TestOTAddReturnsOverwritten (line 133) | func TestOTAddReturnsOverwritten(t *testing.T) {
  function BenchmarkOTAddItemsMultiDimensions (line 159) | func BenchmarkOTAddItemsMultiDimensions(b *testing.B) {
  function BenchmarkOTQueryItemsMultiDimensions (line 176) | func BenchmarkOTQueryItemsMultiDimensions(b *testing.B) {
  function TestOTRootDeleteMultiDimensions (line 198) | func TestOTRootDeleteMultiDimensions(t *testing.T) {
  function TestOTDeleteMultiDimensions (line 208) | func TestOTDeleteMultiDimensions(t *testing.T) {
  function TestOTDeleteInOrderMultiDimensions (line 225) | func TestOTDeleteInOrderMultiDimensions(t *testing.T) {
  function TestOTDeleteReverseOrderMultiDimensions (line 237) | func TestOTDeleteReverseOrderMultiDimensions(t *testing.T) {
  function TestOTDeleteRandomOrderMultiDimensions (line 256) | func TestOTDeleteRandomOrderMultiDimensions(t *testing.T) {
  function TestOTDeleteEmptyTreeMultiDimensions (line 277) | func TestOTDeleteEmptyTreeMultiDimensions(t *testing.T) {
  function TestOTDeleteReturnsDeleted (line 285) | func TestOTDeleteReturnsDeleted(t *testing.T) {
  function BenchmarkOTDeleteItemsMultiDimensions (line 308) | func BenchmarkOTDeleteItemsMultiDimensions(b *testing.B) {
  function TestOverwrites (line 330) | func TestOverwrites(t *testing.T) {
  function TestGet (line 349) | func TestGet(t *testing.T) {
  function TestTreeApply (line 359) | func TestTreeApply(t *testing.T) {
  function TestApplyWithBail (line 374) | func TestApplyWithBail(t *testing.T) {
  function BenchmarkApply (line 389) | func BenchmarkApply(b *testing.B) {
  function TestInsertPositiveIndexFirstDimension (line 406) | func TestInsertPositiveIndexFirstDimension(t *testing.T) {
  function TestInsertPositiveIndexSecondDimension (line 417) | func TestInsertPositiveIndexSecondDimension(t *testing.T) {
  function TestInsertPositiveIndexOutOfBoundsFirstDimension (line 428) | func TestInsertPositiveIndexOutOfBoundsFirstDimension(t *testing.T) {
  function TestInsertPositiveIndexOutOfBoundsSecondDimension (line 440) | func TestInsertPositiveIndexOutOfBoundsSecondDimension(t *testing.T) {
  function TestInsertMultiplePositiveIndexFirstDimension (line 452) | func TestInsertMultiplePositiveIndexFirstDimension(t *testing.T) {
  function TestInsertMultiplePositiveIndexSecondDimension (line 463) | func TestInsertMultiplePositiveIndexSecondDimension(t *testing.T) {
  function TestInsertNegativeIndexFirstDimension (line 474) | func TestInsertNegativeIndexFirstDimension(t *testing.T) {
  function TestInsertNegativeIndexSecondDimension (line 489) | func TestInsertNegativeIndexSecondDimension(t *testing.T) {
  function TestInsertNegativeIndexOutOfBoundsFirstDimension (line 504) | func TestInsertNegativeIndexOutOfBoundsFirstDimension(t *testing.T) {
  function TestInsertNegativeIndexOutOfBoundsSecondDimension (line 517) | func TestInsertNegativeIndexOutOfBoundsSecondDimension(t *testing.T) {
  function TestInsertMultipleNegativeIndexFirstDimension (line 530) | func TestInsertMultipleNegativeIndexFirstDimension(t *testing.T) {
  function TestInsertMultipleNegativeIndexSecondDimension (line 542) | func TestInsertMultipleNegativeIndexSecondDimension(t *testing.T) {
  function TestInsertInvalidDimension (line 554) | func TestInsertInvalidDimension(t *testing.T) {
  function TestInsertInvalidNumber (line 565) | func TestInsertInvalidNumber(t *testing.T) {
  function BenchmarkInsertFirstDimension (line 576) | func BenchmarkInsertFirstDimension(b *testing.B) {
  function BenchmarkInsertSecondDimension (line 588) | func BenchmarkInsertSecondDimension(b *testing.B) {
  function BenchmarkDeleteFirstDimension (line 600) | func BenchmarkDeleteFirstDimension(b *testing.B) {
  function BenchmarkDeleteSecondDimension (line 612) | func BenchmarkDeleteSecondDimension(b *testing.B) {
  function BenchmarkGetMultiDimensions (line 624) | func BenchmarkGetMultiDimensions(b *testing.B) {

FILE: rangetree/skiplist/mock_test.go
  type mockEntry (line 19) | type mockEntry struct
    method ValueAtDimension (line 23) | func (me *mockEntry) ValueAtDimension(dimension uint64) int64 {
  function newMockEntry (line 27) | func newMockEntry(values ...int64) *mockEntry {
  type mockInterval (line 31) | type mockInterval struct
    method LowAtDimension (line 35) | func (mi *mockInterval) LowAtDimension(dimension uint64) int64 {
    method HighAtDimension (line 39) | func (mi *mockInterval) HighAtDimension(dimension uint64) int64 {
  function newMockInterval (line 43) | func newMockInterval(lows, highs []int64) *mockInterval {

FILE: rangetree/skiplist/skiplist.go
  type keyed (line 44) | type keyed interface
  type skipEntry (line 48) | type skipEntry
    method Compare (line 51) | func (se skipEntry) Compare(other common.Comparator) int {
    method key (line 64) | func (se skipEntry) key() uint64 {
  function isLastDimension (line 70) | func isLastDimension(dimension, lastDimension uint64) bool {
  function needsDeletion (line 80) | func needsDeletion(value, index, number int64) bool {
  type dimensionalBundle (line 93) | type dimensionalBundle struct
    method Compare (line 100) | func (db *dimensionalBundle) Compare(e common.Comparator) int {
    method key (line 114) | func (db *dimensionalBundle) key() uint64 {
  type lastBundle (line 120) | type lastBundle struct
    method Compare (line 127) | func (lb *lastBundle) Compare(e common.Comparator) int {
    method key (line 141) | func (lb *lastBundle) key() uint64 {
  type skipListRT (line 145) | type skipListRT struct
    method init (line 150) | func (rt *skipListRT) init(dimensions uint64) {
    method add (line 155) | func (rt *skipListRT) add(entry rangetree.Entry) rangetree.Entry {
    method Add (line 200) | func (rt *skipListRT) Add(entries ...rangetree.Entry) rangetree.Entries {
    method get (line 209) | func (rt *skipListRT) get(entry rangetree.Entry) rangetree.Entry {
    method Get (line 235) | func (rt *skipListRT) Get(entries ...rangetree.Entry) rangetree.Entries {
    method Len (line 245) | func (rt *skipListRT) Len() uint64 {
    method deleteRecursive (line 252) | func (rt *skipListRT) deleteRecursive(sl *skip.SkipList, dimension uin...
    method delete (line 283) | func (rt *skipListRT) delete(entry rangetree.Entry) rangetree.Entry {
    method Delete (line 291) | func (rt *skipListRT) Delete(entries ...rangetree.Entry) rangetree.Ent...
    method apply (line 300) | func (rt *skipListRT) apply(sl *skip.SkipList, dimension uint64,
    method Apply (line 332) | func (rt *skipListRT) Apply(interval rangetree.Interval, fn func(range...
    method Query (line 338) | func (rt *skipListRT) Query(interval rangetree.Interval) rangetree.Ent...
    method flatten (line 348) | func (rt *skipListRT) flatten(sl *skip.SkipList, dimension uint64, ent...
    method insert (line 359) | func (rt *skipListRT) insert(sl *skip.SkipList, dimension, insertDimen...
    method InsertAtDimension (line 417) | func (rt *skipListRT) InsertAtDimension(dimension uint64,
  function new (line 435) | func new(dimensions uint64) *skipListRT {
  function New (line 443) | func New(dimensions uint64) rangetree.RangeTree {

FILE: rangetree/skiplist/skiplist_test.go
  function generateMultiDimensionalEntries (line 29) | func generateMultiDimensionalEntries(num int) rangetree.Entries {
  function generateRandomMultiDimensionalEntries (line 38) | func generateRandomMultiDimensionalEntries(num int) rangetree.Entries {
  function TestRTSingleDimensionAdd (line 48) | func TestRTSingleDimensionAdd(t *testing.T) {
  function TestRTMultiDimensionAdd (line 59) | func TestRTMultiDimensionAdd(t *testing.T) {
  function TestRTSingleDimensionOverwrite (line 70) | func TestRTSingleDimensionOverwrite(t *testing.T) {
  function TestRTMultiDimensionOverwrite (line 85) | func TestRTMultiDimensionOverwrite(t *testing.T) {
  function TestRTSingleDimensionDelete (line 100) | func TestRTSingleDimensionDelete(t *testing.T) {
  function TestRTMultiDimensionDelete (line 112) | func TestRTMultiDimensionDelete(t *testing.T) {
  function TestRTSingleDimensionQuery (line 124) | func TestRTSingleDimensionQuery(t *testing.T) {
  function TestRTMultiDimensionQuery (line 147) | func TestRTMultiDimensionQuery(t *testing.T) {
  function TestRTSingleDimensionInsert (line 179) | func TestRTSingleDimensionInsert(t *testing.T) {
  function TestRTSingleDimensionInsertNegative (line 197) | func TestRTSingleDimensionInsertNegative(t *testing.T) {
  function TestRTMultiDimensionInsert (line 215) | func TestRTMultiDimensionInsert(t *testing.T) {
  function TestRTMultiDimensionInsertNegative (line 233) | func TestRTMultiDimensionInsertNegative(t *testing.T) {
  function TestRTInsertInZeroDimensionMultiDimensionList (line 251) | func TestRTInsertInZeroDimensionMultiDimensionList(t *testing.T) {
  function TestRTInsertNegativeInZeroDimensionMultiDimensionList (line 269) | func TestRTInsertNegativeInZeroDimensionMultiDimensionList(t *testing.T) {
  function TestRTInsertBeyondDimension (line 287) | func TestRTInsertBeyondDimension(t *testing.T) {
  function TestRTInsertZero (line 298) | func TestRTInsertZero(t *testing.T) {
  function BenchmarkMultiDimensionInsert (line 309) | func BenchmarkMultiDimensionInsert(b *testing.B) {
  function BenchmarkMultiDimensionInsertReverse (line 321) | func BenchmarkMultiDimensionInsertReverse(b *testing.B) {
  function BenchmarkMultiDimensionRandomInsert (line 334) | func BenchmarkMultiDimensionRandomInsert(b *testing.B) {
  function BenchmarkMultiDimensionalGet (line 346) | func BenchmarkMultiDimensionalGet(b *testing.B) {
  function BenchmarkMultiDimensionDelete (line 359) | func BenchmarkMultiDimensionDelete(b *testing.B) {
  function BenchmarkMultiDimensionQuery (line 372) | func BenchmarkMultiDimensionQuery(b *testing.B) {
  function BenchmarkMultiDimensionInsertAtZeroDimension (line 389) | func BenchmarkMultiDimensionInsertAtZeroDimension(b *testing.B) {
  function BenchmarkMultiDimensionInsertNegativeAtZeroDimension (line 402) | func BenchmarkMultiDimensionInsertNegativeAtZeroDimension(b *testing.B) {

FILE: rtree/hilbert/action.go
  type actions (line 27) | type actions
  type action (line 29) | type action interface
  type getAction (line 38) | type getAction struct
    method complete (line 44) | func (ga *getAction) complete() {
    method operation (line 48) | func (ga *getAction) operation() operation {
    method keys (line 52) | func (ga *getAction) keys() hilberts {
    method addNode (line 56) | func (ga *getAction) addNode(i int64, n *node) {
    method nodes (line 60) | func (ga *getAction) nodes() []*node {
    method rects (line 64) | func (ga *getAction) rects() []*hilbertBundle {
  function newGetAction (line 68) | func newGetAction(rect rtree.Rectangle) *getAction {
  type insertAction (line 78) | type insertAction struct
    method complete (line 84) | func (ia *insertAction) complete() {
    method operation (line 88) | func (ia *insertAction) operation() operation {
    method keys (line 92) | func (ia *insertAction) keys() hilberts {
    method addNode (line 96) | func (ia *insertAction) addNode(i int64, n *node) {
    method nodes (line 100) | func (ia *insertAction) nodes() []*node {
    method rects (line 104) | func (ia *insertAction) rects() []*hilbertBundle {
  function newInsertAction (line 108) | func newInsertAction(rects rtree.Rectangles) *insertAction {
  type removeAction (line 118) | type removeAction struct
    method operation (line 122) | func (ra *removeAction) operation() operation {
  function newRemoveAction (line 126) | func newRemoveAction(rects rtree.Rectangles) *removeAction {
  function minUint64 (line 132) | func minUint64(choices ...uint64) uint64 {
  type interfaces (line 143) | type interfaces
  function executeInterfacesInParallel (line 145) | func executeInterfacesInParallel(ifs interfaces, fn func(interface{})) {
  function executeInterfacesInSerial (line 179) | func executeInterfacesInSerial(ifs interfaces, fn func(interface{})) {

FILE: rtree/hilbert/hilbert.go
  function getCenter (line 27) | func getCenter(rect rtree.Rectangle) (int32, int32) {
  type hilbertBundle (line 34) | type hilbertBundle struct
  function bundlesFromRects (line 39) | func bundlesFromRects(rects ...rtree.Rectangle) []*hilbertBundle {
  function chunkRectangles (line 73) | func chunkRectangles(slice rtree.Rectangles, numParts int64) []rtree.Rec...

FILE: rtree/hilbert/mock_test.go
  type mockRectangle (line 19) | type mockRectangle struct
    method LowerLeft (line 23) | func (mr *mockRectangle) LowerLeft() (int32, int32) {
    method UpperRight (line 27) | func (mr *mockRectangle) UpperRight() (int32, int32) {
  function newMockRectangle (line 31) | func newMockRectangle(xlow, ylow, xhigh, yhigh int32) *mockRectangle {

FILE: rtree/hilbert/node.go
  type hilbert (line 25) | type hilbert
  type hilberts (line 27) | type hilberts
  function getParent (line 29) | func getParent(parent *node, key hilbert, r1 rtree.Rectangle) *node {
  type nodes (line 63) | type nodes struct
    method push (line 67) | func (ns *nodes) push(n rtree.Rectangle) {
    method splitAt (line 71) | func (ns *nodes) splitAt(i, capacity uint64) (*nodes, *nodes) {
    method byPosition (line 82) | func (ns *nodes) byPosition(pos uint64) *node {
    method insertAt (line 90) | func (ns *nodes) insertAt(i uint64, n rtree.Rectangle) {
    method replaceAt (line 96) | func (ns *nodes) replaceAt(i uint64, n rtree.Rectangle) {
    method len (line 100) | func (ns *nodes) len() uint64 {
    method deleteAt (line 104) | func (ns *nodes) deleteAt(i uint64) {
  function newNodes (line 109) | func newNodes(size uint64) *nodes {
  type keys (line 115) | type keys struct
    method splitAt (line 119) | func (ks *keys) splitAt(i, capacity uint64) (*keys, *keys) {
    method len (line 127) | func (ks *keys) len() uint64 {
    method byPosition (line 131) | func (ks *keys) byPosition(i uint64) hilbert {
    method deleteAt (line 138) | func (ks *keys) deleteAt(i uint64) {
    method delete (line 143) | func (ks *keys) delete(k hilbert) hilbert {
    method search (line 157) | func (ks *keys) search(key hilbert) uint64 {
    method insert (line 165) | func (ks *keys) insert(key hilbert) (hilbert, uint64) {
    method last (line 183) | func (ks *keys) last() hilbert {
    method insertAt (line 187) | func (ks *keys) insertAt(i uint64, k hilbert) {
    method withPosition (line 193) | func (ks *keys) withPosition(k hilbert) (hilbert, uint64) {
  function newKeys (line 205) | func newKeys(size uint64) *keys {
  type node (line 211) | type node struct
    method insert (line 220) | func (n *node) insert(kb *keyBundle) rtree.Rectangle {
    method delete (line 258) | func (n *node) delete(kb *keyBundle) rtree.Rectangle {
    method LowerLeft (line 274) | func (n *node) LowerLeft() (int32, int32) {
    method UpperRight (line 278) | func (n *node) UpperRight() (int32, int32) {
    method needsSplit (line 282) | func (n *node) needsSplit(ary uint64) bool {
    method splitLeaf (line 286) | func (n *node) splitLeaf(i, capacity uint64) (hilbert, *node, *node) {
    method splitInternal (line 305) | func (n *node) splitInternal(i, capacity uint64) (hilbert, *node, *nod...
    method split (line 324) | func (n *node) split(i, capacity uint64) (hilbert, *node, *node) {
    method search (line 332) | func (n *node) search(key hilbert) uint64 {
    method searchNode (line 336) | func (n *node) searchNode(key hilbert) *node {
    method searchRects (line 342) | func (n *node) searchRects(r *rectangle) rtree.Rectangles {
    method key (line 353) | func (n *node) key() hilbert {
  function newNode (line 357) | func newNode(isLeaf bool, keys *keys, ns *nodes) *node {

FILE: rtree/hilbert/rectangle.go
  type rectangle (line 21) | type rectangle struct
    method adjust (line 25) | func (r *rectangle) adjust(rect rtree.Rectangle) {
  function equal (line 44) | func equal(r1, r2 rtree.Rectangle) bool {
  function intersect (line 54) | func intersect(rect1 *rectangle, rect2 rtree.Rectangle) bool {
  function newRectangeFromRect (line 61) | func newRectangeFromRect(rect rtree.Rectangle) *rectangle {
  function newRectangleFromRects (line 74) | func newRectangleFromRects(rects rtree.Rectangles) *rectangle {

FILE: rtree/hilbert/tree.go
  type operation (line 43) | type operation
  constant get (line 46) | get operation = iota
  constant add (line 47) | add
  constant remove (line 48) | remove
  constant multiThreadAt (line 51) | multiThreadAt = 1000
  type keyBundle (line 53) | type keyBundle struct
  type tree (line 58) | type tree struct
    method checkAndRun (line 72) | func (tree *tree) checkAndRun(action action) {
    method init (line 116) | func (tree *tree) init(bufferSize, ary uint64) {
    method operationRunner (line 125) | func (tree *tree) operationRunner(xns interfaces, threaded bool) {
    method fetchKeys (line 135) | func (tree *tree) fetchKeys(xns interfaces, inParallel bool) (map[*nod...
    method fetchKeysInSerial (line 166) | func (tree *tree) fetchKeysInSerial(xns interfaces) {
    method reset (line 183) | func (tree *tree) reset() {
    method fetchKeysInParallel (line 193) | func (tree *tree) fetchKeysInParallel(xns []interface{}) {
    method splitNode (line 244) | func (tree *tree) splitNode(n, parent *node, nodes *[]*node, keys *hil...
    method applyNode (line 263) | func (tree *tree) applyNode(n *node, adds, deletes []*keyBundle) {
    method recursiveMutate (line 283) | func (tree *tree) recursiveMutate(adds, deletes map[*node][]*keyBundle...
    method Insert (line 367) | func (tree *tree) Insert(rects ...rtree.Rectangle) {
    method Delete (line 375) | func (tree *tree) Delete(rects ...rtree.Rectangle) {
    method search (line 381) | func (tree *tree) search(r *rectangle) rtree.Rectangles {
    method Search (line 403) | func (tree *tree) Search(rect rtree.Rectangle) rtree.Rectangles {
    method Len (line 411) | func (tree *tree) Len() uint64 {
    method Dispose (line 417) | func (tree *tree) Dispose() {
  function newTree (line 422) | func newTree(bufferSize, ary uint64) *tree {
  function New (line 429) | func New(bufferSize, ary uint64) rtree.RTree {

FILE: rtree/hilbert/tree_test.go
  function getConsoleLogger (line 31) | func getConsoleLogger() *log.Logger {
  method print (line 35) | func (n *node) print(log *log.Logger) {
  method print (line 50) | func (t *tree) print(log *log.Logger) {
  function constructMockPoints (line 60) | func constructMockPoints(num int) rtree.Rectangles {
  function constructRandomMockPoints (line 68) | func constructRandomMockPoints(num int) rtree.Rectangles {
  function constructInfiniteRect (line 78) | func constructInfiniteRect() rtree.Rectangle {
  function TestSimpleInsert (line 82) | func TestSimpleInsert(t *testing.T) {
  function TestSimpleDelete (line 94) | func TestSimpleDelete(t *testing.T) {
  function TestDeleteIdenticalHilbergNumber (line 106) | func TestDeleteIdenticalHilbergNumber(t *testing.T) {
  function TestDeleteAll (line 123) | func TestDeleteAll(t *testing.T) {
  function TestTwoInsert (line 135) | func TestTwoInsert(t *testing.T) {
  function TestInsertCausesRootSplitOddAry (line 156) | func TestInsertCausesRootSplitOddAry(t *testing.T) {
  function TestInsertCausesRootSplitEvenAry (line 172) | func TestInsertCausesRootSplitEvenAry(t *testing.T) {
  function TestQueryWithLine (line 190) | func TestQueryWithLine(t *testing.T) {
  function TestQueryForPoint (line 237) | func TestQueryForPoint(t *testing.T) {
  function TestMultipleInsertsCauseInternalSplitOddAry (line 261) | func TestMultipleInsertsCauseInternalSplitOddAry(t *testing.T) {
  function TestMultipleInsertsCauseInternalSplitOddAryRandomPoints (line 283) | func TestMultipleInsertsCauseInternalSplitOddAryRandomPoints(t *testing....
  function TestMultipleInsertsCauseInternalSplitEvenAry (line 305) | func TestMultipleInsertsCauseInternalSplitEvenAry(t *testing.T) {
  function TestMultipleInsertsCauseInternalSplitEvenAryRandomOrder (line 327) | func TestMultipleInsertsCauseInternalSplitEvenAryRandomOrder(t *testing....
  function TestInsertDuplicateHilbert (line 349) | func TestInsertDuplicateHilbert(t *testing.T) {
  function TestDeleteAllDuplicateHilbert (line 370) | func TestDeleteAllDuplicateHilbert(t *testing.T) {
  function TestInsertDuplicateRect (line 387) | func TestInsertDuplicateRect(t *testing.T) {
  function BenchmarkBulkAddPoints (line 399) | func BenchmarkBulkAddPoints(b *testing.B) {
  function BenchmarkBulkUpdatePoints (line 411) | func BenchmarkBulkUpdatePoints(b *testing.B) {
  function BenchmarkPointInsertion (line 424) | func BenchmarkPointInsertion(b *testing.B) {
  function BenchmarkQueryPoints (line 436) | func BenchmarkQueryPoints(b *testing.B) {
  function BenchmarkQueryBulkPoints (line 449) | func BenchmarkQueryBulkPoints(b *testing.B) {
  function BenchmarkDelete (line 462) | func BenchmarkDelete(b *testing.B) {

FILE: rtree/interface.go
  type Rectangles (line 20) | type Rectangles
  type Rectangle (line 23) | type Rectangle interface
  type RTree (line 32) | type RTree interface

FILE: set/dict.go
  type Set (line 35) | type Set struct
    method Add (line 42) | func (set *Set) Add(items ...interface{}) {
    method Remove (line 53) | func (set *Set) Remove(items ...interface{}) {
    method Exists (line 64) | func (set *Set) Exists(item interface{}) bool {
    method Flatten (line 75) | func (set *Set) Flatten() []interface{} {
    method Len (line 91) | func (set *Set) Len() int64 {
    method Clear (line 102) | func (set *Set) Clear() {
    method All (line 111) | func (set *Set) All(items ...interface{}) bool {
    method Dispose (line 125) | func (set *Set) Dispose() {
  function New (line 144) | func New(items ...interface{}) *Set {
  function init (line 157) | func init() {

FILE: set/dict_test.go
  function TestAddDuplicateItem (line 25) | func TestAddDuplicateItem(t *testing.T) {
  function TestAddItems (line 35) | func TestAddItems(t *testing.T) {
  function TestRemove (line 56) | func TestRemove(t *testing.T) {
  function TestExists (line 66) | func TestExists(t *testing.T) {
  function TestExists_WithNewItems (line 79) | func TestExists_WithNewItems(t *testing.T) {
  function TestLen (line 95) | func TestLen(t *testing.T) {
  function TestFlattenCaches (line 109) | func TestFlattenCaches(t *testing.T) {
  function TestFlattenCaches_CacheReturn (line 121) | func TestFlattenCaches_CacheReturn(t *testing.T) {
  function TestAddClearsCache (line 134) | func TestAddClearsCache(t *testing.T) {
  function TestDeleteClearsCache (line 154) | func TestDeleteClearsCache(t *testing.T) {
  function TestAll (line 167) | func TestAll(t *testing.T) {
  function TestClear (line 185) | func TestClear(t *testing.T) {
  function BenchmarkFlatten (line 196) | func BenchmarkFlatten(b *testing.B) {
  function BenchmarkLen (line 209) | func BenchmarkLen(b *testing.B) {
  function BenchmarkExists (line 222) | func BenchmarkExists(b *testing.B) {
  function BenchmarkClear (line 232) | func BenchmarkClear(b *testing.B) {

FILE: slice/int64.go
  type Int64Slice (line 28) | type Int64Slice
    method Len (line 31) | func (s Int64Slice) Len() int {
    method Less (line 37) | func (s Int64Slice) Less(i, j int) bool {
    method Search (line 45) | func (s Int64Slice) Search(x int64) int {
    method Sort (line 52) | func (s Int64Slice) Sort() {
    method Swap (line 58) | func (s Int64Slice) Swap(i, j int) {
    method Exists (line 65) | func (s Int64Slice) Exists(x int64) bool {
    method Insert (line 77) | func (s Int64Slice) Insert(x int64) Int64Slice {

FILE: slice/int64_test.go
  function TestSort (line 25) | func TestSort(t *testing.T) {
  function TestSearch (line 32) | func TestSearch(t *testing.T) {
  function TestExists (line 40) | func TestExists(t *testing.T) {
  function TestInsert (line 47) | func TestInsert(t *testing.T) {

FILE: slice/skip/interface.go
  type Iterator (line 23) | type Iterator interface

FILE: slice/skip/iterator.go
  constant iteratorExhausted (line 21) | iteratorExhausted = -2
  type iterator (line 26) | type iterator struct
    method Next (line 33) | func (iter *iterator) Next() bool {
    method Value (line 49) | func (iter *iterator) Value() common.Comparator {
    method exhaust (line 59) | func (iter *iterator) exhaust() common.Comparators {
  function nilIterator (line 70) | func nilIterator() *iterator {

FILE: slice/skip/iterator_test.go
  function TestIterate (line 25) | func TestIterate(t *testing.T) {

FILE: slice/skip/mock_test.go
  type mockEntry (line 25) | type mockEntry
    method Compare (line 27) | func (me mockEntry) Compare(other common.Comparator) int {
  function newMockEntry (line 40) | func newMockEntry(key uint64) mockEntry {
  type mockIterator (line 44) | type mockIterator struct
    method Next (line 48) | func (mi *mockIterator) Next() bool {
    method Value (line 53) | func (mi *mockIterator) Value() common.Comparator {
    method exhaust (line 63) | func (mi *mockIterator) exhaust() common.Comparators {

FILE: slice/skip/node.go
  type widths (line 21) | type widths
  type nodes (line 23) | type nodes
  type node (line 25) | type node struct
    method Compare (line 37) | func (n *node) Compare(e common.Comparator) int {
  function newNode (line 44) | func newNode(cmp common.Comparator, maxLevels uint8) *node {

FILE: slice/skip/skip.go
  constant p (line 69) | p = .5
  type lockedSource (line 80) | type lockedSource struct
    method Int63 (line 86) | func (ls *lockedSource) Int63() (n int64) {
    method Seed (line 94) | func (ls *lockedSource) Seed(seed int64) {
  function generateLevel (line 106) | func generateLevel(maxLevel uint8) uint8 {
  function insertNode (line 118) | func insertNode(sl *SkipList, n *node, cmp common.Comparator, pos uint64...
  function splitAt (line 160) | func splitAt(sl *SkipList, index uint64) (*SkipList, *SkipList) {
  type SkipList (line 191) | type SkipList struct
    method init (line 204) | func (sl *SkipList) init(ifc interface{}) {
    method search (line 220) | func (sl *SkipList) search(cmp common.Comparator, update nodes, widths...
    method resetMaxLevel (line 246) | func (sl *SkipList) resetMaxLevel() {
    method searchByPosition (line 256) | func (sl *SkipList) searchByPosition(position uint64, update nodes, wi...
    method Get (line 287) | func (sl *SkipList) Get(comparators ...common.Comparator) common.Compa...
    method GetWithPosition (line 306) | func (sl *SkipList) GetWithPosition(cmp common.Comparator) (common.Com...
    method ByPosition (line 316) | func (sl *SkipList) ByPosition(position uint64) common.Comparator {
    method insert (line 325) | func (sl *SkipList) insert(cmp common.Comparator) common.Comparator {
    method Insert (line 333) | func (sl *SkipList) Insert(comparators ...common.Comparator) common.Co...
    method insertAtPosition (line 342) | func (sl *SkipList) insertAtPosition(position uint64, cmp common.Compa...
    method InsertAtPosition (line 354) | func (sl *SkipList) InsertAtPosition(position uint64, cmp common.Compa...
    method replaceAtPosition (line 358) | func (sl *SkipList) replaceAtPosition(position uint64, cmp common.Comp...
    method ReplaceAtPosition (line 370) | func (sl *SkipList) ReplaceAtPosition(position uint64, cmp common.Comp...
    method delete (line 374) | func (sl *SkipList) delete(cmp common.Comparator) common.Comparator {
    method Delete (line 406) | func (sl *SkipList) Delete(comparators ...common.Comparator) common.Co...
    method Len (line 417) | func (sl *SkipList) Len() uint64 {
    method iterAtPosition (line 421) | func (sl *SkipList) iterAtPosition(pos uint64) *iterator {
    method IterAtPosition (line 435) | func (sl *SkipList) IterAtPosition(pos uint64) Iterator {
    method iter (line 439) | func (sl *SkipList) iter(cmp common.Comparator) *iterator {
    method Iter (line 454) | func (sl *SkipList) Iter(cmp common.Comparator) Iterator {
    method SplitAt (line 464) | func (sl *SkipList) SplitAt(index uint64) (*SkipList, *SkipList) {
  function New (line 477) | func New(ifc interface{}) *SkipList {

FILE: slice/skip/skip_test.go
  function generateMockEntries (line 28) | func generateMockEntries(num int) common.Comparators {
  function generateRandomMockEntries (line 37) | func generateRandomMockEntries(num int) common.Comparators {
  function TestInsertByPosition (line 46) | func TestInsertByPosition(t *testing.T) {
  function TestGetByPosition (line 61) | func TestGetByPosition(t *testing.T) {
  function TestSplitAt (line 72) | func TestSplitAt(t *testing.T) {
  function TestSplitLargeSkipList (line 91) | func TestSplitLargeSkipList(t *testing.T) {
  function TestSplitLargeSkipListOddNumber (line 114) | func TestSplitLargeSkipListOddNumber(t *testing.T) {
  function TestSplitAtSkipListLength (line 137) | func TestSplitAtSkipListLength(t *testing.T) {
  function TestGetWithPosition (line 147) | func TestGetWithPosition(t *testing.T) {
  function TestReplaceAtPosition (line 162) | func TestReplaceAtPosition(t *testing.T) {
  function TestInsertRandomGetByPosition (line 174) | func TestInsertRandomGetByPosition(t *testing.T) {
  function TestGetManyByPosition (line 185) | func TestGetManyByPosition(t *testing.T) {
  function TestGetPositionAfterDelete (line 195) | func TestGetPositionAfterDelete(t *testing.T) {
  function TestGetPositionBulkDelete (line 210) | func TestGetPositionBulkDelete(t *testing.T) {
  function TestSimpleInsert (line 226) | func TestSimpleInsert(t *testing.T) {
  function TestSimpleOverwrite (line 245) | func TestSimpleOverwrite(t *testing.T) {
  function TestInsertOutOfOrder (line 260) | func TestInsertOutOfOrder(t *testing.T) {
  function TestSimpleDelete (line 272) | func TestSimpleDelete(t *testing.T) {
  function TestDeleteAll (line 286) | func TestDeleteAll(t *testing.T) {
  function TestIter (line 298) | func TestIter(t *testing.T) {
  function TestIterAtPosition (line 321) | func TestIterAtPosition(t *testing.T) {
  function BenchmarkInsert (line 338) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkGet (line 351) | func BenchmarkGet(b *testing.B) {
  function BenchmarkDelete (line 365) | func BenchmarkDelete(b *testing.B) {
  function BenchmarkPrepend (line 379) | func BenchmarkPrepend(b *testing.B) {
  function BenchmarkByPosition (line 397) | func BenchmarkByPosition(b *testing.B) {
  function BenchmarkInsertAtPosition (line 410) | func BenchmarkInsertAtPosition(b *testing.B) {

FILE: sort/interface.go
  type Comparators (line 4) | type Comparators
    method Less (line 8) | func (c Comparators) Less(i, j int) bool {
    method Len (line 14) | func (c Comparators) Len() int {
    method Swap (line 19) | func (c Comparators) Swap(i, j int) {
  type Comparator (line 26) | type Comparator interface

FILE: sort/sort.go
  function sortBucket (line 9) | func sortBucket(comparators Comparators) {
  function copyChunk (line 13) | func copyChunk(chunk []Comparators) []Comparators {
  function MultithreadedSortComparators (line 23) | func MultithreadedSortComparators(comparators Comparators) Comparators {
  function chunk (line 69) | func chunk(comparators Comparators, numParts int64) []Comparators {
  function prevPowerOfTwo (line 77) | func prevPowerOfTwo(x uint64) uint64 {

FILE: sort/sort_test.go
  function TestMultiThreadedSortEvenNumber (line 9) | func TestMultiThreadedSortEvenNumber(t *testing.T) {
  function TestMultiThreadedSortOddNumber (line 19) | func TestMultiThreadedSortOddNumber(t *testing.T) {
  function BenchmarkMultiThreadedSort (line 29) | func BenchmarkMultiThreadedSort(b *testing.B) {

FILE: sort/symmerge.go
  function symSearch (line 11) | func symSearch(u, w Comparators) int {
  function swap (line 28) | func swap(u, w Comparators, index int) {
  function decomposeForSymMerge (line 38) | func decomposeForSymMerge(length int,
  function symBinarySearch (line 55) | func symBinarySearch(u Comparators, start, stop, total int) int {
  function symSwap (line 71) | func symSwap(u Comparators, start1, start2, end int) {
  function symRotate (line 79) | func symRotate(u Comparators, start1, start2, end int) {
  function symMerge (line 109) | func symMerge(u Comparators, start1, start2, last int) {
  function SymMerge (line 133) | func SymMerge(u, w Comparators) Comparators {
  function prepareForSymMerge (line 179) | func prepareForSymMerge(u, w Comparators) (u1, w1, u2, w2 Comparators) {

FILE: sort/symmerge_test.go
  type mockComparator (line 9) | type mockComparator
    method Compare (line 11) | func (mc mockComparator) Compare(other Comparator) int {
  function constructMockComparators (line 23) | func constructMockComparators(values ...int) Comparators {
  function constructOrderedMockComparators (line 32) | func constructOrderedMockComparators(upTo int) Comparators {
  function reverseComparators (line 41) | func reverseComparators(comparators Comparators) Comparators {
  function TestDecomposeForSymMergeOddNumber (line 49) | func TestDecomposeForSymMergeOddNumber(t *testing.T) {
  function TestDecomposeForSymMergeEvenNumber (line 58) | func TestDecomposeForSymMergeEvenNumber(t *testing.T) {
  function TestNearCompleteDecomposeForSymMerge (line 67) | func TestNearCompleteDecomposeForSymMerge(t *testing.T) {
  function TestDecomposePanicsWithWrongLength (line 76) | func TestDecomposePanicsWithWrongLength(t *testing.T) {
  function TestSymSearch (line 83) | func TestSymSearch(t *testing.T) {
  function TestSwap (line 97) | func TestSwap(t *testing.T) {
  function TestSymMergeSmallLists (line 109) | func TestSymMergeSmallLists(t *testing.T) {
  function TestSymMergeAlreadySorted (line 118) | func TestSymMergeAlreadySorted(t *testing.T) {
  function TestSymMergeAlreadySortedReverseOrder (line 127) | func TestSymMergeAlreadySortedReverseOrder(t *testing.T) {
  function TestSymMergeUnevenLists (line 136) | func TestSymMergeUnevenLists(t *testing.T) {
  function TestSymMergeUnevenListsWrongOrder (line 145) | func TestSymMergeUnevenListsWrongOrder(t *testing.T) {
  function TestMergeVeryUnevenLists (line 154) | func TestMergeVeryUnevenLists(t *testing.T) {
  function TestMergeVeryUnevenListsWrongOrder (line 163) | func TestMergeVeryUnevenListsWrongOrder(t *testing.T) {
  function TestMergeVeryUnevenListsAlreadySorted (line 172) | func TestMergeVeryUnevenListsAlreadySorted(t *testing.T) {
  function TestMergeVeryUnevenListsAlreadySortedWrongOrder (line 181) | func TestMergeVeryUnevenListsAlreadySortedWrongOrder(t *testing.T) {
  function TestMergeVeryUnevenListIsSubset (line 190) | func TestMergeVeryUnevenListIsSubset(t *testing.T) {
  function TestMergeVeryUnevenListIsSubsetReverseOrder (line 199) | func TestMergeVeryUnevenListIsSubsetReverseOrder(t *testing.T) {
  function TestMergeUnevenOneListIsOne (line 208) | func TestMergeUnevenOneListIsOne(t *testing.T) {
  function TestMergeEmptyList (line 217) | func TestMergeEmptyList(t *testing.T) {

FILE: threadsafe/err/error.go
  type Error (line 29) | type Error struct
    method Set (line 36) | func (e *Error) Set(err error) {
    method Get (line 44) | func (e *Error) Get() error {
  function New (line 53) | func New() *Error {

FILE: threadsafe/err/error_test.go
  function TestGetSetError (line 26) | func TestGetSetError(t *testing.T) {

FILE: tree/avl/avl.go
  type Immutable (line 39) | type Immutable struct
    method copy (line 47) | func (immutable *Immutable) copy() *Immutable {
    method resetDummy (line 60) | func (immutable *Immutable) resetDummy() {
    method init (line 65) | func (immutable *Immutable) init() {
    method get (line 71) | func (immutable *Immutable) get(entry Entry) Entry {
    method Get (line 90) | func (immutable *Immutable) Get(entries ...Entry) Entries {
    method Len (line 100) | func (immutable *Immutable) Len() uint64 {
    method insert (line 104) | func (immutable *Immutable) insert(entry Entry) Entry {
    method Insert (line 190) | func (immutable *Immutable) Insert(entries ...Entry) (*Immutable, Entr...
    method delete (line 204) | func (immutable *Immutable) delete(entry Entry) Entry {
    method Delete (line 314) | func (immutable *Immutable) Delete(entries ...Entry) (*Immutable, Entr...
  function insertBalance (line 328) | func insertBalance(root *node, dir int) *node {
  function removeBalance (line 348) | func removeBalance(root *node, dir int, done *int) *node {
  function intFromBool (line 374) | func intFromBool(value bool) int {
  function takeOpposite (line 382) | func takeOpposite(value int) int {
  function adjustBalance (line 386) | func adjustBalance(root *node, dir, bal int) {
  function rotate (line 402) | func rotate(parent *node, dir int) *node {
  function doubleRotate (line 412) | func doubleRotate(parent *node, dir int) *node {
  function normalizeComparison (line 421) | func normalizeComparison(i int) int {
  function NewImmutable (line 435) | func NewImmutable() *Immutable {

FILE: tree/avl/avl_test.go
  function generateMockEntries (line 25) | func generateMockEntries(num int) Entries {
  function TestAVLSimpleInsert (line 34) | func TestAVLSimpleInsert(t *testing.T) {
  function TestAVLInsertRightLeaning (line 56) | func TestAVLInsertRightLeaning(t *testing.T) {
  function TestAVLInsertRightLeaningDoubleRotation (line 80) | func TestAVLInsertRightLeaningDoubleRotation(t *testing.T) {
  function TestAVLInsertLeftLeaning (line 103) | func TestAVLInsertLeftLeaning(t *testing.T) {
  function TestAVLInsertLeftLeaningDoubleRotation (line 127) | func TestAVLInsertLeftLeaningDoubleRotation(t *testing.T) {
  function TestAVLInsertOverwrite (line 152) | func TestAVLInsertOverwrite(t *testing.T) {
  function TestAVLSimpleDelete (line 169) | func TestAVLSimpleDelete(t *testing.T) {
  function TestAVLDeleteWithRotation (line 199) | func TestAVLDeleteWithRotation(t *testing.T) {
  function TestAVLDeleteWithDoubleRotation (line 217) | func TestAVLDeleteWithDoubleRotation(t *testing.T) {
  function TestAVLDeleteAll (line 234) | func TestAVLDeleteAll(t *testing.T) {
  function TestAVLDeleteNotLeaf (line 251) | func TestAVLDeleteNotLeaf(t *testing.T) {
  function TestAVLBulkDeleteAll (line 264) | func TestAVLBulkDeleteAll(t *testing.T) {
  function TestAVLDeleteReplay (line 278) | func TestAVLDeleteReplay(t *testing.T) {
  function TestAVLFails (line 298) | func TestAVLFails(t *testing.T) {
  function BenchmarkImmutableInsert (line 321) | func BenchmarkImmutableInsert(b *testing.B) {
  function BenchmarkImmutableGet (line 335) | func BenchmarkImmutableGet(b *testing.B) {
  function BenchmarkImmutableBulkInsert (line 349) | func BenchmarkImmutableBulkInsert(b *testing.B) {
  function BenchmarkImmutableDelete (line 362) | func BenchmarkImmutableDelete(b *testing.B) {
  function BenchmarkImmutableBulkDelete (line 376) | func BenchmarkImmutableBulkDelete(b *testing.B) {

FILE: tree/avl/interface.go
  type Entries (line 20) | type Entries
  type Entry (line 26) | type Entry interface

FILE: tree/avl/mock_test.go
  type mockEntry (line 19) | type mockEntry
    method Compare (line 21) | func (me mockEntry) Compare(other Entry) int {

FILE: tree/avl/node.go
  type nodes (line 19) | type nodes
    method reset (line 21) | func (ns nodes) reset() {
  type node (line 27) | type node struct
    method copy (line 35) | func (n *node) copy() *node {
  function newNode (line 45) | func newNode(entry Entry) *node {

FILE: trie/ctrie/ctrie.go
  constant w (line 39) | w = 5
  constant exp2 (line 42) | exp2 = 32
  type HashFactory (line 46) | type HashFactory
  function defaultHashFactory (line 48) | func defaultHashFactory() hash.Hash32 {
  type Ctrie (line 54) | type Ctrie struct
    method Insert (line 287) | func (c *Ctrie) Insert(key []byte, value interface{}) {
    method Lookup (line 298) | func (c *Ctrie) Lookup(key []byte) (interface{}, bool) {
    method Remove (line 304) | func (c *Ctrie) Remove(key []byte) (interface{}, bool) {
    method Snapshot (line 311) | func (c *Ctrie) Snapshot() *Ctrie {
    method ReadOnlySnapshot (line 317) | func (c *Ctrie) ReadOnlySnapshot() *Ctrie {
    method snapshot (line 322) | func (c *Ctrie) snapshot(readOnly bool) *Ctrie {
    method Clear (line 343) | func (c *Ctrie) Clear() {
    method Iterator (line 361) | func (c *Ctrie) Iterator(cancel <-chan struct{}) <-chan *Entry {
    method Size (line 372) | func (c *Ctrie) Size() uint {
    method traverse (line 387) | func (c *Ctrie) traverse(i *iNode, ch chan<- *Entry, cancel <-chan str...
    method assertReadWrite (line 425) | func (c *Ctrie) assertReadWrite() {
    method insert (line 431) | func (c *Ctrie) insert(entry *Entry) {
    method lookup (line 438) | func (c *Ctrie) lookup(entry *Entry) (interface{}, bool) {
    method remove (line 447) | func (c *Ctrie) remove(entry *Entry) (interface{}, bool) {
    method hash (line 456) | func (c *Ctrie) hash(k []byte) uint32 {
    method iinsert (line 464) | func (c *Ctrie) iinsert(i *iNode, entry *Entry, lev uint, parent *iNod...
    method ilookup (line 538) | func (c *Ctrie) ilookup(i *iNode, entry *Entry, lev uint, parent *iNod...
    method iremove (line 594) | func (c *Ctrie) iremove(i *iNode, entry *Entry, lev uint, parent *iNod...
    method readRoot (line 856) | func (c *Ctrie) readRoot() *iNode {
    method rdcssReadRoot (line 862) | func (c *Ctrie) rdcssReadRoot(abort bool) *iNode {
    method rdcssRoot (line 873) | func (c *Ctrie) rdcssRoot(old *iNode, expected *mainNode, nv *iNode) b...
    method rdcssComplete (line 889) | func (c *Ctrie) rdcssComplete(abort bool) *iNode {
    method casRoot (line 927) | func (c *Ctrie) casRoot(ov, nv *iNode) bool {
  type generation (line 64) | type generation struct
  type iNode (line 69) | type iNode struct
    method copyToGen (line 80) | func (i *iNode) copyToGen(gen *generation, ctrie *Ctrie) *iNode {
  type mainNode (line 90) | type mainNode struct
  type cNode (line 106) | type cNode struct
    method inserted (line 139) | func (c *cNode) inserted(pos, flag uint32, br branch, gen *generation)...
    method updated (line 155) | func (c *cNode) updated(pos uint32, br branch, gen *generation) *cNode {
    method removed (line 165) | func (c *cNode) removed(pos, flag uint32, gen *generation) *cNode {
    method renewed (line 182) | func (c *cNode) renewed(gen *generation, ctrie *Ctrie) *cNode {
  function newMainNode (line 116) | func newMainNode(x *sNode, xhc uint32, y *sNode, yhc uint32, lev uint, g...
  type tNode (line 197) | type tNode struct
    method untombed (line 202) | func (t *tNode) untombed() *sNode {
  type lNode (line 208) | type lNode struct
    method entry (line 213) | func (l *lNode) entry() *sNode {
    method lookup (line 220) | func (l *lNode) lookup(e *Entry) (interface{}, bool) {
    method inserted (line 231) | func (l *lNode) inserted(entry *Entry) *lNode {
    method removed (line 236) | func (l *lNode) removed(e *Entry) *lNode {
    method length (line 248) | func (l *lNode) length() uint {
  type branch (line 253) | type branch interface
  type Entry (line 256) | type Entry struct
  type sNode (line 263) | type sNode struct
  function New (line 269) | func New(hashFactory HashFactory) *Ctrie {
  function newCtrie (line 277) | func newCtrie(root *iNode, hashFactory HashFactory, readOnly bool) *Ctrie {
  function toContracted (line 671) | func toContracted(cn *cNode, lev uint) *mainNode {
  function toCompressed (line 685) | func toCompressed(cn *cNode, lev uint) *mainNode {
  function entomb (line 704) | func entomb(m *sNode) *mainNode {
  function resurrect (line 708) | func resurrect(iNode *iNode, main *mainNode) branch {
  function clean (line 715) | func clean(i *iNode, lev uint, ctrie *Ctrie) bool {
  function cleanReadOnly (line 723) | func cleanReadOnly(tn *tNode, lev uint, p *iNode, ctrie *Ctrie, entry *E...
  function cleanParent (line 734) | func cleanParent(p, i *iNode, hc uint32, lev uint, ctrie *Ctrie, startGe...
  function flagPos (line 755) | func flagPos(hashcode uint32, lev uint, bmp uint32) (uint32, uint32) {
  function bitCount (line 763) | func bitCount(x uint32) uint32 {
  function gcas (line 776) | func gcas(in *iNode, old, n *mainNode, ct *Ctrie) bool {
  function gcasRead (line 789) | func gcasRead(in *iNode, ctrie *Ctrie) *mainNode {
  function gcasComplete (line 799) | func gcasComplete(i *iNode, m *mainNode, ctrie *Ctrie) *mainNode {
  type rdcssDescriptor (line 846) | type rdcssDescriptor struct

FILE: trie/ctrie/ctrie_test.go
  function TestCtrie (line 30) | func TestCtrie(t *testing.T) {
  type mockHash32 (line 83) | type mockHash32 struct
    method Sum32 (line 87) | func (m *mockHash32) Sum32() uint32 {
  function mockHashFactory (line 91) | func mockHashFactory() hash.Hash32 {
  function TestInsertLNode (line 95) | func TestInsertLNode(t *testing.T) {
  function TestInsertTNode (line 118) | func TestInsertTNode(t *testing.T) {
  function TestConcurrency (line 141) | func TestConcurrency(t *testing.T) {
  function TestConcurrency2 (line 172) | func TestConcurrency2(t *testing.T) {
  function TestSnapshot (line 213) | func TestSnapshot(t *testing.T) {
  function TestReadOnlySnapshot (line 289) | func TestReadOnlySnapshot(t *testing.T) {
  function TestIterator (line 344) | func TestIterator(t *testing.T) {
  function TestIteratorCoversTNodes (line 392) | func TestIteratorCoversTNodes(t *testing.T) {
  function TestSize (line 409) | func TestSize(t *testing.T) {
  function TestClear (line 417) | func TestClear(t *testing.T) {
  type fakehash (line 432) | type fakehash struct
    method Sum32 (line 434) | func (h *fakehash) Sum32() uint32 {
    method Sum (line 438) | func (h *fakehash) Sum(b []byte) []byte {
    method Size (line 442) | func (h *fakehash) Size() int {
    method BlockSize (line 446) | func (h *fakehash) BlockSize() int {
    method Reset (line 450) | func (h *fakehash) Reset() {
    method Write (line 454) | func (h *fakehash) Write(b []byte) (int, error) {
  function factory (line 458) | func factory() hash.Hash32 {
  function TestHashCollision (line 462) | func TestHashCollision(t *testing.T) {
  function BenchmarkInsert (line 477) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkLookup (line 485) | func BenchmarkLookup(b *testing.B) {
  function BenchmarkRemove (line 499) | func BenchmarkRemove(b *testing.B) {
  function BenchmarkSnapshot (line 513) | func BenchmarkSnapshot(b *testing.B) {
  function BenchmarkReadOnlySnapshot (line 526) | func BenchmarkReadOnlySnapshot(b *testing.B) {

FILE: trie/dtrie/dtrie.go
  type Dtrie (line 37) | type Dtrie struct
    method Size (line 73) | func (d *Dtrie) Size() (size int) {
    method Get (line 82) | func (d *Dtrie) Get(key interface{}) interface{} {
    method Insert (line 92) | func (d *Dtrie) Insert(key, value interface{}) *Dtrie {
    method Remove (line 99) | func (d *Dtrie) Remove(key interface{}) *Dtrie {
    method Iterator (line 108) | func (d *Dtrie) Iterator(stop <-chan struct{}) <-chan Entry {
  type entry (line 42) | type entry struct
    method KeyHash (line 48) | func (e *entry) KeyHash() uint32 {
    method Key (line 52) | func (e *entry) Key() interface{} {
    method Value (line 56) | func (e *entry) Value() interface{} {
  function New (line 62) | func New(hasher func(v interface{}) uint32) *Dtrie {

FILE: trie/dtrie/dtrie_test.go
  function TestDefaultHasher (line 35) | func TestDefaultHasher(t *testing.T) {
  function collisionHash (line 42) | func collisionHash(key interface{}) uint32 {
  function TestInsert (line 46) | func TestInsert(t *testing.T) {
  function insertTest (line 51) | func insertTest(t *testing.T, hashfunc func(interface{}) uint32, count i...
  function TestGet (line 59) | func TestGet(t *testing.T) {
  function getTest (line 64) | func getTest(t *testing.T, hashfunc func(interface{}) uint32, count int) {
  function TestRemove (line 72) | func TestRemove(t *testing.T) {
  function removeTest (line 77) | func removeTest(t *testing.T, hashfunc func(interface{}) uint32, count i...
  function TestUpdate (line 89) | func TestUpdate(t *testing.T) {
  function updateTest (line 94) | func updateTest(t *testing.T, hashfunc func(interface{}) uint32, count i...
  function TestIterate (line 101) | func TestIterate(t *testing.T) {
  function TestSize (line 131) | func TestSize(t *testing.T) {
  function BenchmarkInsert (line 137) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkGet (line 146) | func BenchmarkGet(b *testing.B) {
  function BenchmarkRemove (line 155) | func BenchmarkRemove(b *testing.B) {
  function BenchmarkUpdate (line 164) | func BenchmarkUpdate(b *testing.B) {

FILE: trie/dtrie/node.go
  type node (line 36) | type node struct
    method KeyHash (line 43) | func (n *node) KeyHash() uint32    { return 0 }
    method Key (line 44) | func (n *node) Key() interface{}   { return nil }
    method Value (line 45) | func (n *node) Value() interface{} { return nil }
    method String (line 47) | func (n *node) String() string {
  type collisionNode (line 51) | type collisionNode struct
    method KeyHash (line 55) | func (n *collisionNode) KeyHash() uint32    { return 0 }
    method Key (line 56) | func (n *collisionNode) Key() interface{}   { return nil }
    method Value (line 57) | func (n *collisionNode) Value() interface{} { return nil }
    method String (line 59) | func (n *collisionNode) String() string {
  type Entry (line 64) | type Entry interface
  function emptyNode (line 70) | func emptyNode(level uint8, capacity int) *node {
  function insert (line 74) | func insert(n *node, entry Entry) *node {
  function get (line 128) | func get(n *node, keyHash uint32, key interface{}) Entry {
  function remove (line 150) | func remove(n *node, keyHash uint32, key interface{}) *node {
  function iterate (line 195) | func iterate(n *node, stop <-chan struct{}) <-chan Entry {
  function pushEntries (line 204) | func pushEntries(n *node, stop <-chan struct{}, out chan Entry) {

FILE: trie/dtrie/util.go
  function mask (line 34) | func mask(hash uint32, level uint8) uint32 {
  function defaultHasher (line 38) | func defaultHasher(value interface{}) uint32 {

FILE: trie/xfast/iterator.go
  type Entries (line 20) | type Entries
  type Iterator (line 23) | type Iterator struct
    method Next (line 30) | func (iter *Iterator) Next() bool {
    method Value (line 43) | func (iter *Iterator) Value() Entry {
    method exhaust (line 53) | func (iter *Iterator) exhaust() Entries {

FILE: trie/xfast/iterator_test.go
  function TestIterator (line 25) | func TestIterator(t *testing.T) {

FILE: trie/xfast/mock_test.go
  type mockEntry (line 21) | type mockEntry struct
    method Key (line 25) | func (me *mockEntry) Key() uint64 {
  function newMockEntry (line 30) | func newMockEntry(key uint64) *mockEntry {

FILE: trie/xfast/xfast.go
  function isInternal (line 51) | func isInternal(n *node) bool {
  function hasInternal (line 60) | func hasInternal(n *node) bool {
  function isLeaf (line 66) | func isLeaf(n *node) bool {
  type Entry (line 75) | type Entry interface
  type node (line 113) | type node struct
  function newNode (line 131) | func newNode(parent *node, entry Entry) *node {
  function binarySearchHashMaps (line 144) | func binarySearchHashMaps(layers []map[uint64]*node, key uint64) (int, *...
  function whichSide (line 168) | func whichSide(n, parent *node) int {
  type XFastTrie (line 185) | type XFastTrie struct
    method init (line 216) | func (xft *XFastTrie) init(intType interface{}) {
    method Exists (line 244) | func (xft *XFastTrie) Exists(key uint64) bool {
    method Len (line 253) | func (xft *XFastTrie) Len() uint64 {
    method Max (line 259) | func (xft *XFastTrie) Max() Entry {
    method Min (line 269) | func (xft *XFastTrie) Min() Entry {
    method insert (line 279) | func (xft *XFastTrie) insert(entry Entry) {
    method walkUpSuccessor (line 383) | func (xft *XFastTrie) walkUpSuccessor(root, node, successor *node) {
    method walkUpPredecessor (line 398) | func (xft *XFastTrie) walkUpPredecessor(root, node, predecessor *node) {
    method walkUpNode (line 411) | func (xft *XFastTrie) walkUpNode(root, node, predecessor, successor *n...
    method Insert (line 427) | func (xft *XFastTrie) Insert(entries ...Entry) {
    method delete (line 433) | func (xft *XFastTrie) delete(key uint64) {
    method Delete (line 502) | func (xft *XFastTrie) Delete(keys ...uint64) {
    method predecessor (line 510) | func (xft *XFastTrie) predecessor(key uint64) *node {
    method successor (line 543) | func (xft *XFastTrie) successor(key uint64) *node {
    method Successor (line 577) | func (xft *XFastTrie) Successor(key uint64) Entry {
    method Predecessor (line 589) | func (xft *XFastTrie) Predecessor(key uint64) Entry {
    method Iter (line 601) | func (xft *XFastTrie) Iter(key uint64) *Iterator {
    method Get (line 611) | func (xft *XFastTrie) Get(key uint64) Entry {
  function New (line 627) | func New(ifc interface{}) *XFastTrie {

FILE: trie/xfast/xfast_test.go
  function checkTrie (line 29) | func checkTrie(t *testing.T, xft *XFastTrie) {
  function checkSuccessor (line 35) | func checkSuccessor(t *testing.T, xft *XFastTrie) {
  function checkPredecessor (line 68) | func checkPredecessor(t *testing.T, xft *XFastTrie) {
  function checkNodes (line 100) | func checkNodes(t *testing.T, xft *XFastTrie) {
  function checkNode (line 112) | func checkNode(t *testing.T, xft *XFastTrie, n *node) {
  function dumpNode (line 127) | func dumpNode(t *testing.T, n *node) {
  function checkPattern (line 134) | func checkPattern(t *testing.T, n *node, pattern []int) {
  function TestEmptyMinMax (line 150) | func TestEmptyMinMax(t *testing.T) {
  function TestMask (line 157) | func TestMask(t *testing.T) {
  function TestInsert (line 161) | func TestInsert(t *testing.T) {
  function TestGet (line 181) | func TestGet(t *testing.T) {
  function TestInsertOverwrite (line 190) | func TestInsertOverwrite(t *testing.T) {
  function TestInsertBetween (line 203) | func TestInsertBetween(t *testing.T) {
  function TestSuccessorDoesNotExist (line 246) | func TestSuccessorDoesNotExist(t *testing.T) {
  function TestSuccessorIsExactValue (line 255) | func TestSuccessorIsExactValue(t *testing.T) {
  function TestSuccessorGreaterThanKey (line 264) | func TestSuccessorGreaterThanKey(t *testing.T) {
  function TestSuccessorCloseToKey (line 273) | func TestSuccessorCloseToKey(t *testing.T) {
  function TestSuccessorBetweenTwoKeys (line 282) | func TestSuccessorBetweenTwoKeys(t *testing.T) {
  function TestPredecessorDoesNotExist (line 301) | func TestPredecessorDoesNotExist(t *testing.T) {
  function TestPredecessorIsExactValue (line 310) | func TestPredecessorIsExactValue(t *testing.T) {
  function TestPredecessorLessThanKey (line 319) | func TestPredecessorLessThanKey(t *testing.T) {
  function TestPredecessorCloseToKey (line 328) | func TestPredecessorCloseToKey(t *testing.T) {
  function TestPredecessorBetweenTwoKeys (line 337) | func TestPredecessorBetweenTwoKeys(t *testing.T) {
  function TestInsertPredecessor (line 356) | func TestInsertPredecessor(t *testing.T) {
  function TestDeleteOnlyBranch (line 381) | func TestDeleteOnlyBranch(t *testing.T) {
  function TestDeleteLargeBranch (line 403) | func TestDeleteLargeBranch(t *testing.T) {
  function TestDeleteLateBranching (line 428) | func TestDeleteLateBranching(t *testing.T) {
  function TestDeleteLateBranchingMin (line 451) | func TestDeleteLateBranchingMin(t *testing.T) {
  function TestDeleteMiddleBranch (line 477) | func TestDeleteMiddleBranch(t *testing.T) {
  function TestDeleteMiddleBranchOtherSide (line 495) | func TestDeleteMiddleBranchOtherSide(t *testing.T) {
  function TestDeleteNotFound (line 513) | func TestDeleteNotFound(t *testing.T) {
  function BenchmarkSuccessor (line 525) | func BenchmarkSuccessor(b *testing.B) {
  function BenchmarkDelete (line 540) | func BenchmarkDelete(b *testing.B) {
  function BenchmarkInsert (line 558) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkListInsert (line 567) | func BenchmarkListInsert(b *testing.B) {
  function BenchmarkListSearch (line 582) | func BenchmarkListSearch(b *testing.B) {

FILE: trie/yfast/entries.go
  type entriesWrapper (line 21) | type entriesWrapper struct
    method Key (line 29) | func (ew *entriesWrapper) Key() uint64 {
  type Entries (line 36) | type Entries
    method search (line 43) | func (entries Entries) search(key uint64) int {
    method insert (line 53) | func (entries *Entries) insert(entry Entry) Entry {
    method delete (line 76) | func (entries *Entries) delete(key uint64) Entry {
    method max (line 96) | func (entries Entries) max() (uint64, bool) {
    method get (line 107) | func (entries Entries) get(key uint64) Entry {
    method successor (line 124) | func (entries Entries) successor(key uint64) (Entry, int) {
    method predecessor (line 137) | func (entries Entries) predecessor(key uint64) (Entry, int) {

FILE: trie/yfast/entries_test.go
  function TestEntriesInsert (line 25) | func TestEntriesInsert(t *testing.T) {
  function TestEntriesDelete (line 42) | func TestEntriesDelete(t *testing.T) {
  function TestEntriesMax (line 57) | func TestEntriesMax(t *testing.T) {
  function TestEntriesGet (line 76) | func TestEntriesGet(t *testing.T) {
  function TestEntriesSuccessor (line 94) | func TestEntriesSuccessor(t *testing.T) {
  function TestEntriesPredecessor (line 123) | func TestEntriesPredecessor(t *testing.T) {

FILE: trie/yfast/interface.go
  type Entry (line 21) | type Entry interface

FILE: trie/yfast/iterator.go
  constant iteratorExhausted (line 23) | iteratorExhausted = -2
  function iterExhausted (line 27) | func iterExhausted(iter *Iterator) bool {
  type Iterator (line 32) | type Iterator struct
    method Next (line 40) | func (iter *Iterator) Next() bool {
    method Value (line 66) | func (iter *Iterator) Value() Entry {
    method exhaust (line 80) | func (iter *Iterator) exhaust() Entries {
  function nilIterator (line 91) | func nilIterator() *Iterator {

FILE: trie/yfast/mock_test.go
  type mockEntry (line 19) | type mockEntry struct
    method Key (line 24) | func (me *mockEntry) Key() uint64 {
  function newMockEntry (line 28) | func newMockEntry(key uint64) *mockEntry {

FILE: trie/yfast/yfast.go
  type YFastTrie (line 45) | type YFastTrie struct
    method init (line 51) | func (yfast *YFastTrie) init(intType interface{}) {
    method getBucketKey (line 71) | func (yfast *YFastTrie) getBucketKey(key uint64) uint64 {
    method insert (line 76) | func (yfast *YFastTrie) insert(entry Entry) Entry {
    method Insert (line 107) | func (yfast *YFastTrie) Insert(entries ...Entry) Entries {
    method delete (line 116) | func (yfast *YFastTrie) delete(key uint64) Entry {
    method Delete (line 141) | func (yfast *YFastTrie) Delete(keys ...uint64) Entries {
    method get (line 150) | func (yfast *YFastTrie) get(key uint64) Entry {
    method Get (line 168) | func (yfast *YFastTrie) Get(key uint64) Entry {
    method Len (line 178) | func (yfast *YFastTrie) Len() uint64 {
    method successor (line 182) | func (yfast *YFastTrie) successor(key uint64) Entry {
    method Successor (line 199) | func (yfast *YFastTrie) Successor(key uint64) Entry {
    method predecessor (line 208) | func (yfast *YFastTrie) predecessor(key uint64) Entry {
    method Predecessor (line 242) | func (yfast *YFastTrie) Predecessor(key uint64) Entry {
    method iter (line 251) | func (yfast *YFastTrie) iter(key uint64) *Iterator {
    method Iter (line 270) | func (yfast *YFastTrie) Iter(key uint64) *Iterator {
  function New (line 278) | func New(ifc interface{}) *YFastTrie {

FILE: trie/yfast/yfast_test.go
  function generateEntries (line 25) | func generateEntries(num int) Entries {
  function TestTrieSimpleInsert (line 34) | func TestTrieSimpleInsert(t *testing.T) {
  function TestTrieOverwriteInsert (line 58) | func TestTrieOverwriteInsert(t *testing.T) {
  function TestTrieDelete (line 70) | func TestTrieDelete(t *testing.T) {
  function TestTrieSuccessor (line 99) | func TestTrieSuccessor(t *testing.T) {
  function TestTriePredecessor (line 132) | func TestTriePredecessor(t *testing.T) {
  function TestTrieIterator (line 160) | func TestTrieIterator(t *testing.T) {
  function BenchmarkInsert (line 194) | func BenchmarkInsert(b *testing.B) {
  function BenchmarkGet (line 205) | func BenchmarkGet(b *testing.B) {
  function BenchmarkDelete (line 220) | func BenchmarkDelete(b *testing.B) {
  function BenchmarkSuccessor (line 232) | func BenchmarkSuccessor(b *testing.B) {
  function BenchmarkPredecessor (line 250) | func BenchmarkPredecessor(b *testing.B) {
  function BenchmarkIterator (line 268) | func BenchmarkIterator(b *testing.B) {

[
  {
    "path": ".github/CODEOWNERS",
    "chars": 17,
    "preview": "@Workiva/skreams\n"
  },
  {
    "path": ".github/workflows/tests.yaml",
    "chars": 1589,
    "preview": "name: \"Tests\"\n\non:\n  pull_request:\n  push:\n    branches:\n      - 'master'\n    tags:\n      - '*'\n\npermissions:\n  pull-req"
  },
  {
    "path": ".gitignore",
    "chars": 19,
    "preview": "*.out\n*.test\n.idea\n"
  },
  {
    "path": "Dockerfile",
    "chars": 434,
    "preview": "FROM golang:1.16-alpine3.13 AS build-go\n\nARG GIT_SSH_KEY\nARG KNOWN_HOSTS_CONTENT\nWORKDIR /go/src/github.com/Workiva/go-d"
  },
  {
    "path": "LICENSE",
    "chars": 11357,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "README.md",
    "chars": 10976,
    "preview": "go-datastructures\n=================\n\nGo-datastructures is a collection of useful, performant, and threadsafe Go\ndatastru"
  },
  {
    "path": "augmentedtree/atree.go",
    "chars": 9684,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/atree_test.go",
    "chars": 14899,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/interface.go",
    "chars": 3061,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/intervals.go",
    "chars": 987,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/intervals_test.go",
    "chars": 858,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/mock_test.go",
    "chars": 1680,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "augmentedtree/multidimensional_test.go",
    "chars": 10248,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "aviary.yaml",
    "chars": 159,
    "preview": "version: 1\n\nexclude:\n  - tests?/\n\nraven_monitored_classes: null\n\nraven_monitored_files: null\n\nraven_monitored_functions:"
  },
  {
    "path": "batcher/batcher.go",
    "chars": 7891,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "batcher/batcher_test.go",
    "chars": 3571,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/and.go",
    "chars": 3792,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/and_test.go",
    "chars": 4616,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/bitarray.go",
    "chars": 9150,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/bitarray_test.go",
    "chars": 10157,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/bitmap.go",
    "chars": 3161,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "bitarray/bitmap_test.go",
    "chars": 3117,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "bitarray/block.go",
    "chars": 2262,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/block_test.go",
    "chars": 1092,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/encoding.go",
    "chars": 6127,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/encoding_test.go",
    "chars": 3180,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/error.go",
    "chars": 893,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/interface.go",
    "chars": 3484,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/iterator.go",
    "chars": 1897,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/nand.go",
    "chars": 4456,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/nand_test.go",
    "chars": 6451,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/or.go",
    "chars": 3703,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/or_test.go",
    "chars": 5077,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/sparse_bitarray.go",
    "chars": 8047,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/sparse_bitarray_test.go",
    "chars": 7657,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "bitarray/util.go",
    "chars": 1275,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/interface.go",
    "chars": 915,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/key.go",
    "chars": 2104,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/mock_test.go",
    "chars": 741,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/node.go",
    "chars": 5617,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/node_test.go",
    "chars": 4069,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/tree.go",
    "chars": 3983,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/_link/tree_test.go",
    "chars": 6781,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/add.go",
    "chars": 7040,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/cacher.go",
    "chars": 3181,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/config.go",
    "chars": 1533,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/delete.go",
    "chars": 6450,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/error.go",
    "chars": 851,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/interface.go",
    "chars": 3603,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/item.go",
    "chars": 890,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/node.go",
    "chars": 12690,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/node_gen.go",
    "chars": 6206,
    "preview": "package btree\n\n// NOTE: THIS FILE WAS PRODUCED BY THE\n// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)\n// DO NOT E"
  },
  {
    "path": "btree/immutable/path.go",
    "chars": 1488,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/query.go",
    "chars": 4057,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/rt.go",
    "chars": 5037,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/immutable/rt_gen.go",
    "chars": 1663,
    "preview": "package btree\n\n// NOTE: THIS FILE WAS PRODUCED BY THE\n// MSGP CODE GENERATION TOOL (github.com/tinylib/msgp)\n// DO NOT E"
  },
  {
    "path": "btree/immutable/rt_test.go",
    "chars": 23770,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/action.go",
    "chars": 3960,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/interface.go",
    "chars": 2551,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/key.go",
    "chars": 1102,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/mock_test.go",
    "chars": 813,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/node.go",
    "chars": 5518,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/tree.go",
    "chars": 12634,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/palm/tree_test.go",
    "chars": 12376,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/btree.go",
    "chars": 3033,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/btree_test.go",
    "chars": 8515,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/interface.go",
    "chars": 1466,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/iterator.go",
    "chars": 1422,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/mock_test.go",
    "chars": 1055,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/node.go",
    "chars": 5637,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "btree/plus/node_test.go",
    "chars": 4764,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "cache/cache.go",
    "chars": 4871,
    "preview": "package cache\n\nimport (\n\t\"container/list\"\n\t\"sync\"\n)\n\n// Cache is a bounded-size in-memory cache of sized items with a co"
  },
  {
    "path": "cache/cache_test.go",
    "chars": 2944,
    "preview": "package cache\n\nimport (\n\t\"container/list\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestEvictionPolicy(t"
  },
  {
    "path": "common/interface.go",
    "chars": 946,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "datastructures.go",
    "chars": 1429,
    "preview": "/*\nPackage datastructures exists solely to aid consumers of the go-datastructures\nlibrary when using dependency managers"
  },
  {
    "path": "documentation.md",
    "chars": 7276,
    "preview": "# Introducing go-datastructures\n\nThe goal of the go-datastructures library is to port implementations of some common dat"
  },
  {
    "path": "fibheap/Test Generator/EnqDecrKey.py",
    "chars": 725,
    "preview": "l = [-2901939070.965906, 4539462982.372177, -6222008480.049856,\n    -1400427921.5968666, 9866088144.060883,\n    -2943107"
  },
  {
    "path": "fibheap/Test Generator/EnqDelete.py",
    "chars": 678,
    "preview": "l = [-2901939070.965906, 4539462982.372177, -6222008480.049856,\n        -1400427921.5968666, 9866088144.060883, -2943107"
  },
  {
    "path": "fibheap/Test Generator/EnqDeqMin.py",
    "chars": 137,
    "preview": "#!/usr/bin/python3\n\nimport random\n\nl = []\nfor i in range(20):\n    l.append(random.uniform(-1E10, 1E10))\n\nprint(l)\nl = so"
  },
  {
    "path": "fibheap/Test Generator/Merge.py",
    "chars": 1791,
    "preview": "import random\n\nl1 = []\nl2 = []\nfor i in range(20):\n        l1.append(random.uniform(-1E10, 1E10))\n        l2.append(rand"
  },
  {
    "path": "fibheap/Test Generator/README.md",
    "chars": 74,
    "preview": "These are some Python helper scripts to help generate sample test arrays.\n"
  },
  {
    "path": "fibheap/benchmarks.txt",
    "chars": 557,
    "preview": "BenchmarkFibHeap_Enqueue-4       \t10000000\t       280 ns/op\t      64 B/op\t       1 allocs/op\nBenchmarkFibHeap_DequeueMin"
  },
  {
    "path": "fibheap/fibheap.go",
    "chars": 11996,
    "preview": "/*\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with t"
  },
  {
    "path": "fibheap/fibheap_examples_test.go",
    "chars": 2948,
    "preview": "package fibheap\n\n// Tests for the Fibonacci heap with floating point number priorities\n\nimport (\n\t\"fmt\"\n)\n\nconst SomeNum"
  },
  {
    "path": "fibheap/fibheap_single_example_test.go",
    "chars": 2430,
    "preview": "package fibheap\n\n// Example usage of the Fibonacci heap\n\nimport (\n\t\"fmt\"\n)\n\nconst SomeNumberAround0 float64 = -0.001\ncon"
  },
  {
    "path": "fibheap/fibheap_test.go",
    "chars": 15833,
    "preview": "package fibheap\n\n// Tests for the Fibonacci heap with floating point number priorities\n\nimport (\n\t\"testing\"\n\n\t\"math/rand"
  },
  {
    "path": "futures/futures.go",
    "chars": 3060,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "futures/futures_test.go",
    "chars": 1959,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "futures/selectable.go",
    "chars": 2807,
    "preview": "/*\nCopyright 2016 Workiva, LLC\nCopyright 2016 Sokolov Yura aka funny_falcon\n\nLicensed under the Apache License, Version "
  },
  {
    "path": "futures/selectable_test.go",
    "chars": 1728,
    "preview": "/*\nCopyright 2016 Workiva, LLC\nCopyright 2016 Sokolov Yura aka funny_falcon\n\nLicensed under the Apache License, Version "
  },
  {
    "path": "go.mod",
    "chars": 134,
    "preview": "module github.com/Workiva/go-datastructures\n\ngo 1.15\n\nrequire (\n\tgithub.com/stretchr/testify v1.7.0\n\tgithub.com/tinylib/"
  },
  {
    "path": "go.sum",
    "chars": 3724,
    "preview": "github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=\ngithub.com/davecgh/go-spew v1.1.0/go.m"
  },
  {
    "path": "graph/simple.go",
    "chars": 3205,
    "preview": "/*\nCopyright 2017 Julian Griggs\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fi"
  },
  {
    "path": "graph/simple_test.go",
    "chars": 5023,
    "preview": "/*\nCopyright 2017 Julian Griggs\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fi"
  },
  {
    "path": "hashmap/fastinteger/hash.go",
    "chars": 339,
    "preview": "package fastinteger\n\n// hash will convert the uint64 key into a hash based on Murmur3's 64-bit\n// integer finalizer.\n// "
  },
  {
    "path": "hashmap/fastinteger/hash_test.go",
    "chars": 977,
    "preview": "package fastinteger\n\nimport (\n\t\"encoding/binary\"\n\t\"hash/fnv\"\n\t\"math/rand\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/stretchr/test"
  },
  {
    "path": "hashmap/fastinteger/hashmap.go",
    "chars": 4439,
    "preview": "// Package fastinteger is designed to provide a very primitive\n// implementation of a hash map for unsigned integer keys"
  },
  {
    "path": "hashmap/fastinteger/hashmap_test.go",
    "chars": 5099,
    "preview": "package fastinteger\n\nimport (\n\t\"math/rand\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc generateKey"
  },
  {
    "path": "list/persistent.go",
    "chars": 6888,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "list/persistent_test.go",
    "chars": 5338,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "mock/batcher.go",
    "chars": 1234,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "mock/rangetree.go",
    "chars": 1307,
    "preview": "package mock\n\nimport (\n\t\"github.com/stretchr/testify/mock\"\n\n\t\"github.com/Workiva/go-datastructures/rangetree\"\n)\n\ntype Ra"
  },
  {
    "path": "numerics/hilbert/hilbert.go",
    "chars": 2246,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "numerics/hilbert/hilbert_test.go",
    "chars": 1583,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "numerics/optimization/global.go",
    "chars": 4644,
    "preview": "package optimization\n\nimport (\n\t\"math\"\n\t\"sort\"\n)\n\ntype pbs []*vertexProbabilityBundle\n\ntype vertexProbabilityBundle stru"
  },
  {
    "path": "numerics/optimization/nelder_mead.go",
    "chars": 16910,
    "preview": "package optimization\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"math/rand\"\n\t\"sort\"\n\t\"time\"\n)\n\nconst (\n\talpha         = 1     // reflecti"
  },
  {
    "path": "numerics/optimization/nelder_mead_test.go",
    "chars": 4832,
    "preview": "package optimization\n\nimport (\n\t\"math\"\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestNelderMead(t *testi"
  },
  {
    "path": "queue/error.go",
    "chars": 1021,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/mock_test.go",
    "chars": 737,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/priority_queue.go",
    "chars": 5986,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/priority_queue_test.go",
    "chars": 4285,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/queue.go",
    "chars": 9430,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/queue_test.go",
    "chars": 10700,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/ring.go",
    "chars": 5556,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "queue/ring_test.go",
    "chars": 6467,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/entries.go",
    "chars": 1154,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/entries_test.go",
    "chars": 806,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/error.go",
    "chars": 1131,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/immutable.go",
    "chars": 6730,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/immutable_test.go",
    "chars": 15937,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/interface.go",
    "chars": 3717,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/mock_test.go",
    "chars": 1363,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/node.go",
    "chars": 900,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/ordered.go",
    "chars": 5452,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/ordered_test.go",
    "chars": 3700,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/orderedtree.go",
    "chars": 6343,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/orderedtree_test.go",
    "chars": 17359,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/skiplist/mock_test.go",
    "chars": 1160,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/skiplist/skiplist.go",
    "chars": 11662,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rangetree/skiplist/skiplist_test.go",
    "chars": 10808,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/action.go",
    "chars": 3319,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/hilbert.go",
    "chars": 2103,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/mock_test.go",
    "chars": 966,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/node.go",
    "chars": 7287,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/rectangle.go",
    "chars": 2008,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/tree.go",
    "chars": 10053,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/hilbert/tree_test.go",
    "chars": 11141,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "rtree/interface.go",
    "chars": 1479,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "set/dict.go",
    "chars": 3596,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "set/dict_test.go",
    "chars": 4251,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/int64.go",
    "chars": 2401,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/int64_test.go",
    "chars": 1227,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/interface.go",
    "chars": 1229,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/iterator.go",
    "chars": 1817,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/iterator_test.go",
    "chars": 1275,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/mock_test.go",
    "chars": 1285,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/node.go",
    "chars": 1440,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/skip.go",
    "chars": 13634,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "slice/skip/skip_test.go",
    "chars": 9721,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "sort/interface.go",
    "chars": 1042,
    "preview": "package merge\n\n// Comparators defines a typed list of type Comparator.\ntype Comparators []Comparator\n\n// Less returns a "
  },
  {
    "path": "sort/sort.go",
    "chars": 1813,
    "preview": "package merge\n\nimport (\n\t\"runtime\"\n\t\"sort\"\n\t\"sync\"\n)\n\nfunc sortBucket(comparators Comparators) {\n\tsort.Sort(comparators)"
  },
  {
    "path": "sort/sort_test.go",
    "chars": 933,
    "preview": "package merge\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\nfunc TestMultiThreadedSortEvenNumber(t *tes"
  },
  {
    "path": "sort/symmerge.go",
    "chars": 4656,
    "preview": "package merge\n\nimport (\n\t\"math\"\n\t\"sync\"\n)\n\n// symSearch is like symBinarySearch but operates\n// on two sorted lists inst"
  },
  {
    "path": "sort/symmerge_test.go",
    "chars": 5649,
    "preview": "package merge\n\nimport (\n\t\"testing\"\n\n\t\"github.com/stretchr/testify/assert\"\n)\n\ntype mockComparator int\n\nfunc (mc mockCompa"
  },
  {
    "path": "threadsafe/err/error.go",
    "chars": 1466,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "threadsafe/err/error_test.go",
    "chars": 786,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "tree/avl/avl.go",
    "chars": 9761,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "tree/avl/avl_test.go",
    "chars": 9984,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "tree/avl/interface.go",
    "chars": 1079,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "tree/avl/mock_test.go",
    "chars": 748,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "tree/avl/node.go",
    "chars": 1196,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/ctrie/ctrie.go",
    "chars": 27435,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/ctrie/ctrie_test.go",
    "chars": 11044,
    "preview": "/*\nCopyright 2015 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/dtrie/dtrie.go",
    "chars": 3740,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "trie/dtrie/dtrie_test.go",
    "chars": 4382,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "trie/dtrie/node.go",
    "chars": 6628,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "trie/dtrie/util.go",
    "chars": 2026,
    "preview": "/*\nCopyright (c) 2016, Theodore Butler\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or "
  },
  {
    "path": "trie/xfast/iterator.go",
    "chars": 1565,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/xfast/iterator_test.go",
    "chars": 1264,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/xfast/mock_test.go",
    "chars": 846,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/xfast/xfast.go",
    "chars": 18414,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/xfast/xfast_test.go",
    "chars": 12121,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/entries.go",
    "chars": 4050,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/entries_test.go",
    "chars": 2931,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/interface.go",
    "chars": 862,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/iterator.go",
    "chars": 2494,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/mock_test.go",
    "chars": 788,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/yfast.go",
    "chars": 6955,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  },
  {
    "path": "trie/yfast/yfast_test.go",
    "chars": 5581,
    "preview": "/*\nCopyright 2014 Workiva, LLC\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this fil"
  }
]

// ... and 1 more files (download for full content)