Highly concurrent drop-in replacement for `bufio.Writer`

# concurrent-writer [![Build Status](https://travis-ci.org/free/concurrent-writer.svg)](https://travis-ci.org/free/concurrent-writer) [![Go Report Card](https://goreportcard.com/badge/github.com/free/concurrent-writer)](https://goreportcard.com/report/github.com/free/concurrent-writer) [![Coverage](https://gocover.io/_badge/github.com/free/concurrent-writer/concurrent)](https://gocover.io/github.com/free/concurrent-writer/concurrent) [![GoDoc](https://godoc.org/github.com/free/concurrent-writer/concurrent?status.svg)](https://godoc.org/github.com/free/concurrent-writer/concurrent)
Highly concurrent drop-in replacement for `bufio.Writer`.

`concurrent.Writer` implements highly concurrent buffering for an `io.Writer` object.
In particular, writes will not block while a `Flush()` call is in progress as
long as enough buffer space is available.

Note however that writes will still block in a number of cases, e.g. when
another write larger than the buffer size is in progress. Also, concurrent
flushes (whether explicit or triggered by the buffer filling up) will block
one another.


concurrent-writer

# fsm [![PkgGoDev](https://pkg.go.dev/badge/github.com/cocoonspace/fsm)](https://pkg.go.dev/github.com/cocoonspace/fsm) [![Build Status](https://app.travis-ci.com/cocoonspace/fsm.svg?branch=master)](https://app.travis-ci.com/cocoonspace/fsm) [![Coverage Status](https://coveralls.io/repos/github/cocoonspace/fsm/badge.svg?branch=master)](https://coveralls.io/github/cocoonspace/fsm?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/cocoonspace/fsm)](https://goreportcard.com/report/github.com/cocoonspace/fsm)

Package fsm allows you to add [finite-state machines](https://en.wikipedia.org/wiki/Finite-state_machine) to your Go code.

States and Events are defined as int consts:

```go
const (
    StateFoo fsm.State = iota
    StateBar
)

const (
    EventFoo fsm.Event = iota
    EventBar
)

f := fsm.New(StateFoo)
f.Transition(
    fsm.On(EventFoo), fsm.Src(StateFoo),
    fsm.Dst(StateBar),
)
```

You can have custom checks or actions:

```go
f.Transition(
    fsm.Src(StateFoo), fsm.Check(func () bool {
        // check something
    }),
    fsm.Call(func () {
        // do something
    }),
)
```

Transitions can be triggered the second time an event occurs:

```go
f.Transition(
    fsm.On(EventFoo), fsm.Src(StateFoo), fsm.Times(2),
    fsm.Dst(StateBar),
)
```

Functions can be called when entering or leaving a state:

```go
f.EnterState(StateFoo, func() {
    // do something	
})
f.Enter(func(state fsm.State) {
    // do something	
})
f.ExitState(StateFoo, func() {
    // do something	
})
f.Exit(func(state fsm.State) {
    // do something	
})
```

## Performance

This package is much faster and does a lot less allocations than github.com/looplab/fsm:

```
BenchmarkCocoonSpaceFSM-12    	29371851	        40.32 ns/op	       0 B/op	       0 allocs/op
BenchmarkLooplabFSM-12        	 2438946	       487.8 ns/op	     320 B/op	       4 allocs/op
```

(benchmark data is for two executed transitions)

Benchmark information on https://github.com/cocoonspace/fsm-bench

## Installation

go get github.com/cocoonspace/fsm

## Contribution guidelines

Contributions are welcome, as long as:

* unit tests & comments are included,
* no external package is used.

## License

MIT - See LICENSE


Go 1.18+ generics package inspired by Kotlin's Sequence and Map

genfuncs

Generic slice, map, set, iterator, and goroutine utilities

# Go-generics - Generic slice, map, set, iterator, and goroutine utilities for Go

[![Go Reference](https://pkg.go.dev/badge/github.com/bobg/go-generics/v4.svg)](https://pkg.go.dev/github.com/bobg/go-generics/v4)
[![Go Report Card](https://goreportcard.com/badge/github.com/bobg/go-generics/v4)](https://goreportcard.com/report/github.com/bobg/go-generics/v4)
[![Tests](https://github.com/bobg/go-generics/actions/workflows/go.yml/badge.svg)](https://github.com/bobg/go-generics/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/bobg/go-generics/badge.svg?branch=master)](https://coveralls.io/github/bobg/go-generics?branch=master)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

This is go-generics,
a collection of typesafe generic utilities
for slices, sets, and goroutine patterns in Go.

# Compatibility note

This is version 4 of this library,
for the release of Go 1.23.

Earlier versions of this library included a package,
`iter`,
that defined an iterator type over several types of containers,
and functions for operating with iterators.
However, Go 1.23 defines its own, better iterator mechanism
via the new “range over function” language feature,
plus [a new standard-library package](https://pkg.go.dev/iter) also called `iter`.
This version of the go-generics library therefore does away with its `iter` package.
The handy functions that `iter` contained for working with iterators
(`Filter`, `Map`, `FirstN`, and many more)
can now be found in the [github.com/bobg/seqs](https://pkg.go.dev/github.com/bobg/seqs) library,
adapted for Go 1.23 iterators.

(This version of go-generics might have kept `iter` as a drop-in replacement for the standard-library package,
but was unable because the standard library defines two types,
`iter.Seq[K]` and `iter.Seq2[K, V]`,
that go-generics would have had to reference using type aliases;
but Go type aliases [do not yet permit type parameters](https://github.com/golang/go/issues/46477#issuecomment-2101270785).)

Earlier versions of this library included combinatorial operations in the `slices` package.
Those have now been moved to their own library,
[github.com/bobg/combo](https://pkg.go.dev/github.com/bobg/combo).

Earlier versions of this library included a `maps` package,
which was a drop-in replacement for the stdlib `maps`
(added in Go 1.21)
plus a few convenience functions.
With the advent of Go 1.23 iterators,
those few convenience functions are mostly redundant
(and a couple of them − `Keys` and `Values` − conflict with new functions in the standard library),
so `maps` has been removed.

Earlier versions of this library included a `Find` method on the `set.Of[T]` type,
for finding some element in the set that satisfies a given predicate.
This method has been removed in favor of composing operations with functions from [github.com/bobg/seqs](https://pkg.go.dev/github.com/bobg/seqs).
For example, `s.Find(pred)` can now be written as `seqs.First(seqs.Filter(s.All(), pred))`.

# Slices

The `slices` package is useful in three ways:

- It encapsulates hard-to-remember Go idioms for inserting and removing elements to and from the middle of a slice;
- It adds the ability to index from the right end of a slice using negative integers
  (for example, Get(s, -1) is the same as s[len(s)-1]); and
- It includes `Map`, `Filter`, and a few other such functions
  for processing slice elements with callbacks.

The `slices` package is a drop-in replacement
for the `slices` package
added to the Go stdlib
in [Go 1.21](https://go.dev/doc/go1.21#slices).
There is one difference:
this version of `slices`
allows the index value passed to `Insert`, `Delete`, and `Replace`
to be negative for counting backward from the end of the slice.

# Set

The `set` package implements the usual collection of functions for sets:
`Intersect`, `Union`, `Diff`, etc.,
as well as member functions for adding and removing items,
checking for the presence of items,
and iterating over items.

# Parallel

The `parallel` package contains functions for coordinating parallel workers:

- `Consumers` manages a set of N workers consuming a stream of values produced by the caller.
- `Producers` manages a set of N workers producing a stream of values consumed by the caller.
- `Values` concurrently produces a set of N values.
- `Pool` manages access to a pool of concurrent workers.
- `Protect` manages concurrent access to a protected data value.


go-generics

Region quadtrees with efficient point location and neighbour finding

# Region quadtrees in Go
[![Build Status](https://travis-ci.org/arl/go-rquad.svg?branch=master)](https://travis-ci.org/arl/go-rquad) [![Coverage Status](https://coveralls.io/repos/github/arl/go-rquad/badge.svg?branch=master)](https://coveralls.io/github/arl/go-rquad?branch=master)
[![Go Report Card](https://goreportcard.com/badge/github.com/arl/go-rquad)](https://goreportcard.com/report/github.com/arl/go-rquad)
[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/arl/go-rquad) 

**Region quadtrees and efficient neighbour finding techniques in Go**

**Go-rquad** proposes various implementations of **region quadtrees**.

A region quadtree is a special kind of quadtree that recursively
subdivides a 2 dimensional space into 4 smaller and generally equal
rectangular regions, until the wanted quadtree resolution has been reached,
or no further subdivisions can be performed.

Region quadtrees can be used for image processing; in this case a leaf node
represents a rectangular region of an image in which all colors are equal or
the color difference is under a given threshold.

Region quadtrees may also be used to represent data fields with variable 
resolution. For example, the temperatures in an area may be stored as a
quadtree where each leaf node stores the average temperature over the
subregion it represents.

In this package, quadtrees implement the [`imgscan.Scanner`](https://github.com/arl/imgtools/tree/master/imgscan) interface,
this provides a way to scan (i.e extract) the pixels in order to perform the subdivisions.

## API Overview

### `Node` interface
```go
type Node interface {
        Parent() Node
        Child(Quadrant) Node
        Bounds() image.Rectangle
        Color() Color
        Location() Quadrant
}
```

### `Quadtree` interface

A `Quadtree` represents a hierarchical collection of `Node`s, its API is
simple: access to the root Node and a way to iterate over all the leaves.

```go
type Quadtree interface {
        ForEachLeaf(Color, func(Node))
        Root() Node
}
```

### Functions

`Locate` returns the leaf node of `q` that contains `pt`, or nil if `q` doesn't contain `pt`.
```go
func Locate(q Quadtree, pt image.Point) Node
```

`ForEachNeighbour` calls `fn` for each neighbour of `n`.
```go
func ForEachNeighbour(n Node, fn func(Node))
```

### Basic implementation: `BasicTree` and `basicNode`

`BasicTree` is in many ways the standard implementation of `Quadtree`, it just does the job.

### State of the art implementation: `CNTree` and `CNNode`

`CNTree` or **Cardinal Neighbour Quadtree** implements state of the art techniques:
 - from any given leaf node, its neighbours (of any size) are accessed in constant time *0(1)*  as they implement the  *Cardinal Neighbour Quadtree* technique (cf Safwan Qasem 2015). The time complexity reduction is obtained through the addition of only four pointers per leaf node in the quadtree.
 - fast point location queries (locating which leaf node contains a specific point), thanks to the *binary branching method* (cf Frisken Perry 2002). This simple and efficient method is nonrecursive, table free, and reduces the number of comparisons with
poor predictive behavior, that are otherwise required with the standard method.

## Benchmarks

![Quadtree creation benchmark](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/Creation.png)

![Neighbour finding benchmark](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/Neighbours.png)

![Point location benchmark](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/PointLocation.png)

## Research papers

 - Bottom-up neighour finding technique. cf Hanan Samet 1981,  
*Neighbor Finding Techniques for Images Represented by Quadtrees*, [paper](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/papers/a090240.pdf)

 - Cardinal Neighbor Quadtree. cf Safwan Qasem 2015,  
*Cardinal Neighbor Quadtree: a New Quadtree-based Structure for Constant-Time Neighbor Finding*, [paper](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/papers/qasem-2015-ijca-907501.pdf)

 - Fast point location using binary branching method. cf Frisken, Perry 2002  
 *Simple and Efficient Traversal Methods for Quadtrees and Octrees*, [paper](https://raw.githubusercontent.com/arl/go-rquad/readme-docs/papers/Simple.and.Efficient.Traversal.Methods.for.Quadtrees.TR2002-41.pdf)


## License

go-rquad is open source software distributed in accordance with the MIT
License, which says:

Copyright (c) 2016 Aurélien Rainone

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.




go-rquad

Generic tuple implementation for Go 1.18+

# go-tuple: Generic tuples for Go 1.18+.

[![Go](https://github.com/barweiss/go-tuple/actions/workflows/go.yml/badge.svg)](https://github.com/barweiss/go-tuple/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/barweiss/go-tuple/badge.svg)](https://coveralls.io/github/barweiss/go-tuple)
[![Go Report Card](https://goreportcard.com/badge/github.com/barweiss/go-tuple)](https://goreportcard.com/report/github.com/barweiss/go-tuple)
[![Go Reference](https://pkg.go.dev/badge/github.com/barweiss/go-tuple.svg)](https://pkg.go.dev/github.com/barweiss/go-tuple)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

Go 1.18+ tuple implementation.

Use tuples to store 1 or more values without needing to write a custom struct.

```go
tup := tuple.New2(5, "hi!")
fmt.Println(tup.V1) // Outputs 5.
fmt.Println(tup.V2) // Outputs "hi!".
```

Tuples come in various sizes, from 1 to 9 elements.

```go
longerTuple := tuple.New5("this", "is", "one", "long", "tuple")
```

Tuples can be used as slice or array items, map keys or values, and as channel payloads:

```go
// Map holding tuples.
tupInMap := make(map[tuple.T2[string, string]]Person)
tupInMap[tuple.New2("John", "Doe")] = Person{
	FirstName: "John",
	LastName: "Doe",
	// ...
}

// Channel holding tuples.
tupInChan := make(chan tuple.T2[string, error])
go func() {
	defer close(tupInChan)
	tupInChan <- tuple.New2(os.Getwd())
}()
fmt.Print(<-tupInChan)
```

# Features

## Create tuples from function calls

```go
func vals() (int, string) {
    return 5, "hi!"
}

func main() {
    tup := tuple.New2(vals())
    fmt.Println(tup.V1)
    fmt.Println(tup.V2)
}
```

## Forward tuples as function arguments

```go
func main() {
    tup := tuple.New2(5, "hi!")
    printValues(tup.Values())
}

func printValues(a int, b string) {
    fmt.Println(a)
    fmt.Println(b)
}
```

## Access tuple values

```go
tup := tuple.New2(5, "hi!")
a, b := tup.Values()
```

## JSON Marshalling

Tuples are marshalled and unmarshalled as JSON arrays.

```go
type User struct {
	Name string `json:"name"`
	Age  int    `json:"age,omitempty"`
}

type MyJSON struct {
	Users []tuple.T2[string, User] `json:"users"`
}

func main() {
	data := MyJSON{
		Users: []tuple.T2[string, User]{
			tuple.New2("foo", User{Name: "foo", Age: 42}),
			tuple.New2("bar", User{Name: "bar", Age: 21}),
			tuple.New2("baz", User{Name: "baz"}),
		},
	}

	marshalled, _ := json.Marshal(data)
	fmt.Printf("%s\n", string(marshalled))
	// Outputs: {"users":[["foo",{"name":"foo","age":42}],["bar",{"name":"bar","age":21}],["baz",{"name":"baz"}]]}
}
```

## Comparison

Tuples are compared from the first element to the last.
For example, the tuple `[1 2 3]` is greater than `[1 2 4]` but less than `[2 2 2]`.

```go
fmt.Println(tuple.Equal3(tuple.New3(1, 2, 3), tuple.New3(3, 3, 3))) // false.
fmt.Println(tuple.LessThan3(tuple.New3(1, 2, 3), tuple.New3(3, 2, 1))) // true.

tups := []tuple.T3{
    tuple.New3("foo", 2, -23),
    tuple.New3("foo", 72, 15),
    tuple.New3("bar", -4, 43),
}
sort.Slice(tups, func (i, j int) {
    return tuple.LessThan3(tups[i], tups[j])
})

fmt.Println(tups) // [["bar", -4, 43], ["foo", 2, -23], ["foo", 72, 15]].
```

---

**NOTE**

In order to compare tuples, all tuple elements must match `constraints.Ordered`.

See [Custom comparison](#custom-comparison) in order to see how to compare tuples
with arbitrary element values.

---

### Comparison result

```go
// Compare* functions return an OrderedComparisonResult value.
result := tuple.Compare3(tuple.New3(1, 2, 3), tuple.New3(3, 2, 1))

// OrderedComparisonResult values are wrapped integers.
fmt.Println(result) // -1

// OrderedComparisonResult expose various method to see the result
// in a more readable way.
fmt.Println(result.GreaterThan()) // false
```

### Custom comparison

The package provides the `CompareC` comparison functions varation in order to compare tuples of complex
comparable types.

For a type to be comparable, it must match the `Comparable` or `Equalable` constraints.

```go
type Comparable[T any] interface {
	CompareTo(guest T) OrderedComparisonResult
}

type Equalable[T any] interface {
	Equal(guest T) bool
}
```

```go
type person struct {
	name string
	age  int
}

func (p person) CompareTo(guest person) tuple.OrderedComparisonResult {
	if p.name < guest.name {
		return -1
	}
	if p.name > guest.name {
		return 1
	}
	return 0
}

func main() {
	tup1 := tuple.New2(person{name: "foo", age: 20}, person{name: "bar", age: 24})
	tup2 := tuple.New2(person{name: "bar", age: 20}, person{name: "baz", age: 24})

	fmt.Println(tuple.LessThan2C(tup1, tup2)) // true.
}
```

In order to call the complex types variation of the comparable functions, **all** tuple types must match the `Comparable` constraint.

While this is not ideal, this a known inconvenience given the current type parameters capabilities in Go.
Some solutions have been porposed for this issue ([lesser](https://github.com/lelysses/lesser), for example, beatifully articulates the issue),
but they still demand features that are not yet implemented by the language.

Once the language will introduce more convenient ways for generic comparisons, this package will adopt it.

## Formatting

Tuples implement the `Stringer` and `GoStringer` interfaces.

```go
fmt.Printf("%s\n", tuple.New2("hello", "world"))
// Output:
// ["hello" "world"]

fmt.Printf("%#v\n", tuple.New2("hello", "world"))
// Output:
// tuple.T2[string, string]{V1: "hello", V2: "world"}
```

# Notes

The tuple code and test code are generated by the `scripts/gen/main.go` script.

Generation works by reading `tuple.tpl` and `tuple_test.tpl` using Go's `text/template` engine.
`tuple.tpl` and `tuple_test.tpl` contain the templated content of a generic tuple class, with variable number of elements.

# Contributing

Please feel free to contribute to this project by opening issues or creating pull-requests.
However, keep in mind that generic type features for Go are still in their early stages, so there might
not be support from the language to your requested feature.

Also keep in mind when contributing to keep the compilation time and performance of this package fast.

Feel free to contact me at [barw.code@gmail.com](mailto:barw.code@gmail.com) for questions or suggestions!


go-tuple

Go Data Structures using Go 1.18 generics

go18ds

Implementation of dataframes, series, and data wrangling methods for Go

Gota: DataFrames, Series and Data Wrangling for Go
==================================================

Meet us on Slack: Slack: [gophers.slack.com](https://gophers.slack.com) #go-gota ([invite](https://gophersinvite.herokuapp.com/))

This is an implementation of DataFrames, Series and data wrangling
methods for the Go programming language. The API is still in flux so
*use at your own risk*.

DataFrame
---------

The term DataFrame typically refers to a tabular dataset that can be
viewed as a two dimensional table. Often the columns of this dataset
refers to a list of features, while the rows represent a number of
measurements. As the data on the real world is not perfect, DataFrame
supports non measurements or NaN elements.

Common examples of DataFrames can be found on Excel sheets, CSV files
or SQL database tables, but this data can come on a variety of other
formats, like a collection of JSON objects or XML files.

The utility of DataFrames resides on the ability to subset them, merge
them, summarize the data for individual features or apply functions to
entire rows or columns, all while keeping column type integrity.

### Usage
#### Loading data

DataFrames can be constructed passing Series to the dataframe.New constructor
function:

```go
df := dataframe.New(
	series.New([]string{"b", "a"}, series.String, "COL.1"),
	series.New([]int{1, 2}, series.Int, "COL.2"),
	series.New([]float64{3.0, 4.0}, series.Float, "COL.3"),
)
```

You can also load the data directly from other formats. 
The base loading function takes some records in the
form `[][]string` and returns a new DataFrame from there:

```go
df := dataframe.LoadRecords(
    [][]string{
        []string{"A", "B", "C", "D"},
        []string{"a", "4", "5.1", "true"},
        []string{"k", "5", "7.0", "true"},
        []string{"k", "4", "6.0", "true"},
        []string{"a", "2", "7.1", "false"},
    },
)
```

Now you can also create DataFrames by loading an slice of arbitrary structs:

```go
type User struct {
	Name     string
	Age      int
	Accuracy float64
    ignored  bool // ignored since unexported
}
users := []User{
	{"Aram", 17, 0.2, true},
	{"Juan", 18, 0.8, true},
	{"Ana", 22, 0.5, true},
}
df := dataframe.LoadStructs(users)
```

By default, the column types will be auto detected but this can be
configured. For example, if we wish the default type to be `Float` but
columns `A` and `D` are `String` and `Bool` respectively:

```go
df := dataframe.LoadRecords(
    [][]string{
        []string{"A", "B", "C", "D"},
        []string{"a", "4", "5.1", "true"},
        []string{"k", "5", "7.0", "true"},
        []string{"k", "4", "6.0", "true"},
        []string{"a", "2", "7.1", "false"},
    },
    dataframe.DetectTypes(false),
    dataframe.DefaultType(series.Float),
    dataframe.WithTypes(map[string]series.Type{
        "A": series.String,
        "D": series.Bool,
    }),
)
```

Similarly, you can load the data stored on a `[]map[string]interface{}`:

```go
df := dataframe.LoadMaps(
    []map[string]interface{}{
        map[string]interface{}{
            "A": "a",
            "B": 1,
            "C": true,
            "D": 0,
        },
        map[string]interface{}{
            "A": "b",
            "B": 2,
            "C": true,
            "D": 0.5,
        },
    },
)
```

You can also pass an `io.Reader` to the functions `ReadCSV`/`ReadJSON`
and it will work as expected given that the data is correct:

```go
csvStr := `
Country,Date,Age,Amount,Id
"United States",2012-02-01,50,112.1,01234
"United States",2012-02-01,32,321.31,54320
"United Kingdom",2012-02-01,17,18.2,12345
"United States",2012-02-01,32,321.31,54320
"United Kingdom",2012-02-01,NA,18.2,12345
"United States",2012-02-01,32,321.31,54320
"United States",2012-02-01,32,321.31,54320
Spain,2012-02-01,66,555.42,00241
`
df := dataframe.ReadCSV(strings.NewReader(csvStr))
```

```go
jsonStr := `[{"COL.2":1,"COL.3":3},{"COL.1":5,"COL.2":2,"COL.3":2},{"COL.1":6,"COL.2":3,"COL.3":1}]`
df := dataframe.ReadJSON(strings.NewReader(jsonStr))
```

#### Subsetting

We can subset our DataFrames with the Subset method. For example if we
want the first and third rows we can do the following:

```go
sub := df.Subset([]int{0, 2})
```

#### Column selection

If instead of subsetting the rows we want to select specific columns,
by an index or column name:

```go
sel1 := df.Select([]int{0, 2})
sel2 := df.Select([]string{"A", "C"})
```

#### Updating values

In order to update the values of a DataFrame we can use the Set
method:

```go
df2 := df.Set(
    []int{0, 2},
    dataframe.LoadRecords(
        [][]string{
            []string{"A", "B", "C", "D"},
            []string{"b", "4", "6.0", "true"},
            []string{"c", "3", "6.0", "false"},
        },
    ),
)
```

#### Filtering

For more complex row subsetting we can use the Filter method. For
example, if we want the rows where the column "A" is equal to "a" or
column "B" is greater than 4:

```go
fil := df.Filter(
    dataframe.F{"A", series.Eq, "a"},
    dataframe.F{"B", series.Greater, 4},
)

filAlt := df.FilterAggregation(
    dataframe.Or,
    dataframe.F{"A", series.Eq, "a"},
    dataframe.F{"B", series.Greater, 4},
) 
```

Filters inside Filter are combined as OR operations, alternatively we can use `df.FilterAggragation` with `dataframe.Or`.

If we want to combine filters with AND operations, we can use `df.FilterAggregation` with `dataframe.And`.

```go
fil := df.FilterAggregation(
    dataframe.And, 
    dataframe.F{"A", series.Eq, "a"},
    dataframe.F{"D", series.Eq, true},
)
```

To combine AND and OR operations, we can use chaining of filters.

```go
// combine filters with OR
fil := df.Filter(
    dataframe.F{"A", series.Eq, "a"},
    dataframe.F{"B", series.Greater, 4},
)
// apply AND for fil and fil2
fil2 := fil.Filter(
    dataframe.F{"D", series.Eq, true},
)
```

Filtering is based on predefined comparison operators: 
* `series.Eq`
* `series.Neq`
* `series.Greater`
* `series.GreaterEq`
* `series.Less`
* `series.LessEq`
* `series.In`

However, if these filter operations are not sufficient, we can use user-defined comparators.
We use `series.CompFunc` and a user-defined function with the signature `func(series.Element) bool` to provide user-defined filters to `df.Filter` and `df.FilterAggregation`.

```go
hasPrefix := func(prefix string) func(el series.Element) bool {
        return func (el series.Element) bool {
            if el.Type() == String {
                if val, ok := el.Val().(string); ok {
                    return strings.HasPrefix(val, prefix)
                }
            }
            return false
        }
    }

fil := df.Filter(
    dataframe.F{"A", series.CompFunc, hasPrefix("aa")},
)
```

This example filters rows based on whether they have a cell value starting with `"aa"` in column `"A"`.

#### GroupBy && Aggregation

GroupBy && Aggregation

```go
groups := df.GroupBy("key1", "key2") // Group by column "key1", and column "key2" 
aggre := groups.Aggregation([]AggregationType{Aggregation_MAX, Aggregation_MIN}, []string{"values", "values2"}) // Maximum value in column "values",  Minimum value in column "values2"
```

#### Arrange

With Arrange a DataFrame can be sorted by the given column names:

```go
sorted := df.Arrange(
    dataframe.Sort("A"),    // Sort in ascending order
    dataframe.RevSort("B"), // Sort in descending order
)
```

#### Mutate

If we want to modify a column or add one based on a given Series at
the end we can use the Mutate method:

```go
// Change column C with a new one
mut := df.Mutate(
    series.New([]string{"a", "b", "c", "d"}, series.String, "C"),
)
// Add a new column E
mut2 := df.Mutate(
    series.New([]string{"a", "b", "c", "d"}, series.String, "E"),
)
```

#### Joins

Different Join operations are supported (`InnerJoin`, `LeftJoin`,
`RightJoin`, `CrossJoin`). In order to use these methods you have to
specify which are the keys to be used for joining the DataFrames:

```go
df := dataframe.LoadRecords(
    [][]string{
        []string{"A", "B", "C", "D"},
        []string{"a", "4", "5.1", "true"},
        []string{"k", "5", "7.0", "true"},
        []string{"k", "4", "6.0", "true"},
        []string{"a", "2", "7.1", "false"},
    },
)
df2 := dataframe.LoadRecords(
    [][]string{
        []string{"A", "F", "D"},
        []string{"1", "1", "true"},
        []string{"4", "2", "false"},
        []string{"2", "8", "false"},
        []string{"5", "9", "false"},
    },
)
join := df.InnerJoin(df2, "D")
```

#### Function application

Functions can be applied to the rows or columns of a DataFrame,
casting the types as necessary:

```go
mean := func(s series.Series) series.Series {
    floats := s.Float()
    sum := 0.0
    for _, f := range floats {
        sum += f
    }
    return series.Floats(sum / float64(len(floats)))
}
df.Capply(mean)
df.Rapply(mean)
```

#### Chaining operations

DataFrames support a number of methods for wrangling the data,
filtering, subsetting, selecting columns, adding new columns or
modifying existing ones. All these methods can be chained one after
another and at the end of the procedure check if there has been any
errors by the DataFrame Err field. If any of the methods in the chain
returns an error, the remaining operations on the chain will become
a no-op.

```go
a = a.Rename("Origin", "Country").
    Filter(dataframe.F{"Age", "<", 50}).
    Filter(dataframe.F{"Origin", "==", "United States"}).
    Select("Id", "Origin", "Date").
    Subset([]int{1, 3})
if a.Err != nil {
    log.Fatal("Oh noes!")
}
```

#### Print to console

```go
fmt.Println(flights)

> [336776x20] DataFrame
> 
>     X0    year  month day   dep_time sched_dep_time dep_delay arr_time ...
>  0: 1     2013  1     1     517      515            2         830      ...
>  1: 2     2013  1     1     533      529            4         850      ...
>  2: 3     2013  1     1     542      540            2         923      ...
>  3: 4     2013  1     1     544      545            -1        1004     ...
>  4: 5     2013  1     1     554      600            -6        812      ...
>  5: 6     2013  1     1     554      558            -4        740      ...
>  6: 7     2013  1     1     555      600            -5        913      ...
>  7: 8     2013  1     1     557      600            -3        709      ...
>  8: 9     2013  1     1     557      600            -3        838      ...
>  9: 10    2013  1     1     558      600            -2        753      ...
>     ...   ...   ...   ...   ...      ...            ...       ...      ...
>     <int> <int> <int> <int> <int>    <int>          <int>     <int>    ...
> 
> Not Showing: sched_arr_time <int>, arr_delay <int>, carrier <string>, flight <int>,
> tailnum <string>, origin <string>, dest <string>, air_time <int>, distance <int>, hour <int>,
> minute <int>, time_hour <string>
```

#### Interfacing with gonum

A `gonum/mat.Matrix` or any object that implements the `dataframe.Matrix`
interface can be loaded as a `DataFrame` by using the `LoadMatrix()` method. If
one wants to convert a `DataFrame` to a `mat.Matrix` it is necessary to create
the necessary structs and method implementations. Since a `DataFrame` already
implements the `Dims() (r, c int)` method, only implementations for the `At` and
`T` methods are necessary:

```go
type matrix struct {
	dataframe.DataFrame
}

func (m matrix) At(i, j int) float64 {
	return m.Elem(i, j).Float()
}

func (m matrix) T() mat.Matrix {
	return mat.Transpose{m}
}
```

Series
------

Series are essentially vectors of elements of the same type with
support for missing values. Series are the building blocks for
DataFrame columns.

Four types are currently supported:

```go
Int
Float
String
Bool
```

For more information about the API, make sure to check:

- [dataframe godoc][3]
- [series godoc][4]

License
-------
Copyright 2016 Alejandro Sanchez Brotons

Licensed under the Apache License, Version 2.0 (the "License"); you
may not use this file except in compliance with the License.  You may
obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied. See the License for the specific language governing
permissions and limitations under the License.

[1]: https://github.com/gonum
[2]: https://github.com/go-gota/gota
[3]: https://godoc.org/github.com/go-gota/gota/dataframe
[4]: https://godoc.org/github.com/go-gota/gota/series


gota

HyperLogLog implementation with Sparse, LogLog-Beta bias correction and TailCut space reduction

# HyperLogLog - an algorithm for approximating the number of distinct elements

[![GoDoc](https://godoc.org/github.com/axiomhq/hyperloglog?status.svg)](https://godoc.org/github.com/axiomhq/hyperloglog) [![Go Report Card](https://goreportcard.com/badge/github.com/axiomhq/hyperloglog)](https://goreportcard.com/report/github.com/axiomhq/hyperloglog) [![CircleCI](https://circleci.com/gh/axiomhq/hyperloglog/tree/master.svg?style=svg)](https://circleci.com/gh/axiomhq/hyperloglog/tree/master)

An improved version of [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) for the count-distinct problem, approximating the number of distinct elements in a multiset. This implementation offers enhanced performance, flexibility, and simplicity while maintaining accuracy.

## Note on Implementation History

The initial version of this work (tagged as v0.1.0) was based on ["Better with fewer bits: Improving the performance of cardinality estimation of large data streams - Qingjun Xiao, You Zhou, Shigang Chen"](https://www.cise.ufl.edu/~sgchen/Publications/XZC17.pdf). However, the current implementation has evolved significantly from this original basis, notably moving away from the tailcut method.

## Current Implementation

The current implementation is based on the LogLog-Beta algorithm, as described in:

["LogLog-Beta and More: A New Algorithm for Cardinality Estimation Based on LogLog Counting"](https://arxiv.org/pdf/1612.02284) by Jason Qin, Denys Kim, and Yumei Tung (2016).

Key features of the current implementation:
* **Metro hash** used instead of xxhash
* **Sparse representation** for lower cardinalities (like HyperLogLog++)
* **LogLog-Beta** for dynamic bias correction across all cardinalities
* **8-bit registers** for convenience and simplified implementation
* **Order-independent insertions and merging** for consistent results regardless of data input order
* **Removal of tailcut method** for a more straightforward approach
* **Flexible precision** allowing for 2^4 to 2^18 registers

This implementation is now more straightforward, efficient, and flexible, while remaining backwards compatible with previous versions. It provides a balance between precision, memory usage, speed, and ease of use.

## Precision and Memory Usage

This implementation allows for creating HyperLogLog sketches with arbitrary precision between 2^4 and 2^18 registers. The memory usage scales with the number of registers:

* Minimum (2^4 registers): 16 bytes
* Default (2^14 registers): 16 KB
* Maximum (2^18 registers): 256 KB

Users can choose the precision that best fits their use case, balancing memory usage against estimation accuracy.

## Note
A big thank you to Prof. Shigang Chen and his team at the University of Florida who are actively conducting research around "Big Network Data".

## Contributing

Kindly check our [contributing guide](https://github.com/axiomhq/hyperloglog/blob/main/Contributing.md) on how to propose bugfixes and improvements, and submitting pull requests to the project

## License

&copy; Axiom, Inc., 2024

Distributed under MIT License (`The MIT License`).

See [LICENSE](LICENSE) for more information.


hyperloglog

Combinatorial operations including permutations, combinations, and combinations-with-replacement

# Combo - combinatorial operations for Go

[![Go Reference](https://pkg.go.dev/badge/github.com/bobg/combo.svg)](https://pkg.go.dev/github.com/bobg/combo)
[![Go Report Card](https://goreportcard.com/badge/github.com/bobg/combo)](https://goreportcard.com/report/github.com/bobg/combo)
[![Tests](https://github.com/bobg/combo/actions/workflows/go.yml/badge.svg)](https://github.com/bobg/combo/actions/workflows/go.yml)
[![Coverage Status](https://coveralls.io/repos/github/bobg/combo/badge.svg?branch=main)](https://coveralls.io/github/bobg/combo?branch=main)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

This is combo,
a library of combinatorial operations for Go.
Given a slice,
it can compute its permutations,
its n-element combinations,
and its n-element combinations-with-replacement.

There is also a command-line tool for invoking these operations on a list of strings.

## Installation and usage

For library usage,
please see the documentation at [pkg.go.dev](https://pkg.go.dev/github.com/bobg/combo).

Installing the command-line tool:

```sh
go install github.com/bobg/combo/cmd/combo@latest
```

Usage:

```sh
combo perm [ARG ARG ...]
combo comb N [ARG ARG ...]
combo rcomb N [ARG ARG ...]
```

The first argument is the operation to run:
`perm` for permutations;
`comb` for combinations;
and `rcomb` for combinations-with-replacement.

The `comb` and `rcomb` subcommands require a numeric argument, `N`,
the number of strings to choose in each combination.

The input is specified as additional arguments on the command line.
If no such arguments are supplied,
then the input is read from standard input,
one line per string.

Examples:

```sh
$ combo perm 1 2 3
1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
3 2 1
```

```sh
$ combo comb 2 a b c
a b
a c
b c
```

```sh
$ combo rcomb 2 a b c
a a
a b
a c
b b
b c
c c
```


combo

# Geo Index

Geo Index library

## Overview

Splits the earth surface in a grid. At each cell we can store data, such as list of points, count of points, etc. It can do KNearest and Range queries. For more detailed description check https://sudo.hailoapp.com/services/2015/02/18/geoindex/ .

### Demo

http://go-geoindex.appspot.com/static/nearest.html - Click to select the nearest points.

http://go-geoindex.appspot.com/static/cluster.html - A map with 100K points around the world. Zoom in and out to cluster. 

### API

```go
    type Driver struct {
        lat float64
        lon float64
        id string
        canAcceptJobs bool
    }

    // Implement Point interface
    func (d *Driver) Lat() float64 { return d.lat }
    func (d *Driver) Lon() float64 { return d.lon }
    func (d *Driver) Id() string { return d.id }

    // create points index with resolution (cell size) 0.5 km
    index := NewPointsIndex(Km(0.5))

    // Adds a point in the index, if a point with the same id exists it's removed and the new one is added
    index.Add(&Driver{"id1", lat, lng, true})
    index.Add(&Driver{"id2", lat, lng, false})

    // Removes a point from the index by id
    index.Remove("id1")

    // get the k-nearest points to a point, within some distance
    points := index.KNearest(&GeoPoint{id, lat, lng}, 5, Km(5), func(p Point) bool {
        return p.(* Driver).canAcceptJobs
    })

    // get the points within a range on the map
    points := index.Range(topLeftPoint, bottomRightPoint)
```

### Index types

There are several index types

```go
    NewPointsIndex(Km(0.5)) // Creates index that maintains points
    NewExpiringPointsIndex(Km(0.5), Minutes(5)) // Creates index that expires the points after some interval
    NewCountIndex(Km(0.5)) // Creates index that maintains counts of the points in each cell
    NewExpiringCountIndex(Km(0.5), Minutes(15)) // Creates index that maintains expiring count
    NewClusteringIndex() // index that clusters the points at different zoom levels, so we can create maps
    NewExpiringClusteringIndex(Minutes(15)) // index that clusters and expires the points at different zoom levels
                                            // so we can create real time maps of customer request, etc in the driver app
```

### Performance Benchmarks

    BenchmarkClusterIndexAdd                    500000          5395 ns/op
    BenchmarkClusterIndexStreetRange            100000         22207 ns/op
    BenchmarkClusterIndexCityRange              100000         16389 ns/op
    BenchmarkClusterIndexEuropeRange            50000          36559 ns/op

    BenchmarkExpiringClusterIndexAdd            300000          7124 ns/op
    BenchmarkExpiringClusterIndexStreetRange    50000          27030 ns/op
    BenchmarkExpiringClusterIndexCityRange      100000         22185 ns/op
    BenchmarkExpiringClusterIndexEuropeRange    30000          52080 ns/op

    BenchmarkCountIndexAdd                      1000000         1670 ns/op
    BenchmarkCountIndexCityRange                100000         20325 ns/op

    BenchmarkExpiringCountIndexAdd              500000          2808 ns/op
    BenchmarkExpiringCountIndexRange            50000          35791 ns/op

    BenchmarkPointIndexRange                    100000         15945 ns/op
    BenchmarkPointIndexAdd                      1000000         2416 ns/op
    BenchmarkPointIndexKNearest                 100000         13788 ns/op

    BenchmarkExpiringPointIndexAdd              500000          4324 ns/op
    BenchmarkExpiringPointIndexKNearest         100000         15638 ns/op
    BenchmarkExpiringPointIndexRange            100000         20386 ns/op


go-geoindex

Determine how intervals relate to each other

# go-rampart

[![Go Reference](https://pkg.go.dev/badge/github.com/francesconi/go-rampart.svg)](https://pkg.go.dev/github.com/francesconi/go-rampart)
![github.com/francesconi/go-rampart](https://github.com/francesconi/go-rampart/workflows/test/badge.svg)
[![Codecov](https://codecov.io/gh/francesconi/go-rampart/branch/main/graph/badge.svg?token=Y1G145SZB2)](https://codecov.io/gh/francesconi/go-rampart)
[![Go Report Card](https://goreportcard.com/badge/github.com/francesconi/go-rampart)](https://goreportcard.com/report/github.com/francesconi/go-rampart)

Go port of the [Haskell Rampart library](https://github.com/tfausak/rampart) by [Taylor Fausak](https://taylor.fausak.me/2020/03/13/relate-intervals-with-rampart).

This package provides types and functions for defining intervals and determining how they relate to each other. This can be useful to determine if an event happened during a certain time frame, or if two time frames overlap (and if so, how exactly they overlap).

## Install

```sh
go get github.com/francesconi/go-rampart
```

## Examples

### Ordered types

Any type that supports the operators `<` `<=` `>=` `>`.

```go
a := rampart.NewInterval(2, 3)
b := rampart.NewInterval(3, 7)
rel := a.Relate(b)
// rel: RelationMeets
```

### Any other type

`NewIntervalFunc` accepts any type as long as a comparison function is provided. The comparison function should return values as follows:

```go
cmp(t1, t2) < 0 if t1 < t2
cmp(t1, t2) > 0 if t1 > t2
cmp(t1, t2) == 0 if t1 == t2
```

#### time.Time

```go
func compareTimes(t1, t2 time.Time) int {
    return int(t1.Sub(t2))
}

a := rampart.NewIntervalFunc(
    time.Date(2022, time.April, 1, 0, 0, 0, 0, time.UTC),
    time.Date(2022, time.April, 8, 0, 0, 0, 0, time.UTC),
    compareTimes,
)
b := rampart.NewIntervalFunc(
    time.Date(2022, time.April, 6, 0, 0, 0, 0, time.UTC),
    time.Date(2022, time.April, 15, 0, 0, 0, 0, time.UTC),
    compareTimes,
)
rel := a.Relate(b)
// rel: RelationOverlaps
```

![][interval relations]

[interval relations]: ./docs/interval-relations.svg


go-rampart

A comprehensive, reusable and efficient concurrent-safe generics utility functions and data structures library

gogu

ID type with marshalling to/from hash to prevent sending IDs to clients

# Hide IDs

[![Go Reference](https://pkg.go.dev/badge/github.com/emvi/hide?status.svg)](https://pkg.go.dev/github.com/emvi/hide?status)
[![Go Report Card](https://goreportcard.com/badge/github.com/emvi/hide)](https://goreportcard.com/report/github.com/emvi/hide)
<a href="https://discord.gg/fAYm4Cz"><img src="https://img.shields.io/discord/739184135649886288?logo=discord" alt="Chat on Discord"></a>

Hide is a simple package to provide an ID type that is marshaled to/from a hash string.
This prevents sending technical IDs to clients and converts them on the API layer.
Hide uses [hashids](https://github.com/speps/go-hashids) as its default hash function.
But you can provide your own by implementing the `Hash` interface and configuring it using `hide.UseHash`.

[Read our full article on Medium.](https://medium.com/emvi/golang-transforming-ids-to-a-userfriendly-representation-in-web-applications-85bf2f7d71c5)

## Installation

```
go get github.com/emvi/hide/v2
```

## Example

Consider the following struct:

```
type User struct {
    Id       int64  `json:"id"`
    Username string `json:"username"`
}
```

When marshaling this struct to JSON, the ID will be represented by a number:

```
{
    "id": 123,
    "username": "foobar"
}
```

In this case, you expose the technical user ID to your clients. By changing the type of the ID, you get a better result:

```
type User struct {
    Id       hide.ID `json:"id"`
    Username string  `json:"username"`
}
```

Notice that the `int64` ID got replaced by the `hide.ID`, which internally is represented as an `int64` as well, but implements the marshal interface.
This allows you to cast between them and use `hide.ID` as a replacement. The resulting JSON changes to the following:

```
{
  "id": "beJarVNaQM",
  "username": "foobar"
}
```

If you send the new ID (which is a string now) back to the server and unmarshal it into the `hide.ID` type, you'll get the original technical ID back.
It's also worth mentioning that a value of 0 is translated to `null` when an ID is marshaled to JSON or stored in a database.

[View the full demo](https://github.com/emvi/hide-example)

## Contribute

[See CONTRIBUTING.md](CONTRIBUTING.md)

## License

MIT

<p align="center">
    <img src="hidegopher.png" width="300px" />
</p>


hide

Generic, zero-alloc, 100%-test covered quadtree

[![PkgGoDev](https://pkg.go.dev/badge/github.com/s0rg/quadtree)](https://pkg.go.dev/github.com/s0rg/quadtree)
[![License](https://img.shields.io/badge/license-MIT%20License-blue.svg)](https://github.com/s0rg/quadtree/blob/master/LICENSE)
[![Go Version](https://img.shields.io/github/go-mod/go-version/s0rg/quadtree)](go.mod)
[![Tag](https://img.shields.io/github/v/tag/s0rg/quadtree?sort=semver)](https://github.com/s0rg/quadtree/tags)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

[![CI](https://github.com/s0rg/quadtree/workflows/ci/badge.svg)](https://github.com/s0rg/quadtree/actions?query=workflow%3Aci)
[![Go Report Card](https://goreportcard.com/badge/github.com/s0rg/quadtree)](https://goreportcard.com/report/github.com/s0rg/quadtree)
[![Maintainability](https://qlty.sh/badges/ae1e81be-3dc3-4cf6-ae43-cd4b1344e765/maintainability.svg)](https://qlty.sh/gh/s0rg/projects/quadtree)
[![Code Coverage](https://qlty.sh/badges/ae1e81be-3dc3-4cf6-ae43-cd4b1344e765/test_coverage.svg)](https://qlty.sh/gh/s0rg/projects/quadtree)
![Issues](https://img.shields.io/github/issues/s0rg/quadtree)

# quadtree

[Quadtree](https://en.wikipedia.org/wiki/Quadtree) for golang.

# features

- generic
- heavy optimized
- zero-alloc
- 100% test coverage

# example
```go
import (
    "log"

    "github.com/s0rg/quadtree"
)

func main() {
    // width, height and max depth for new tree
    tree := quadtree.New[int](100.0, 100.0, 4)

    // add some points
    tree.Add(10.0, 10.0, 5.0, 5.0, 1)
    tree.Add(15.0, 20.0, 10.0, 10.0, 2)
    tree.Add(40.0, 10.0, 4.0, 4.0, 3)
    tree.Add(90.0, 90.0, 5.0, 8.0, 4)

    val, ok := tree.Get(9.0, 9.0, 11.0, 11.0)
    if !ok {
        log.Fatal("not found")
    }

    log.Println(val) // should print 1

    const (
        distance = 20.0
        count = 2
    )

    tree.KNearest(80.0, 80.0, distance, count, func(x, y, w, h float64, val int) {
        log.Printf("(%f, %f, %f, %f) = %d", x, y, w, h, val)
    })

    // output: (90.000000, 90.000000, 5.000000, 8.000000) = 4
}
```

# benchmark

```
goos: linux
goarch: amd64
pkg: github.com/s0rg/quadtree
cpu: AMD Ryzen 5 5500U with Radeon Graphics
BenchmarkNode/Insert-12             14974236      71.07 ns/op       249 B/op          0 allocs/op
BenchmarkNode/Del-12                6415672       188.3 ns/op         0 B/op          0 allocs/op
BenchmarkNode/Search-12             21702474      51.83 ns/op         0 B/op          0 allocs/op
BenchmarkTree/Add-12                18840514      67.83 ns/op       241 B/op          0 allocs/op
BenchmarkTree/Get-12                21204722      55.46 ns/op         0 B/op          0 allocs/op
BenchmarkTree/Move-12               8061322       147.5 ns/op         0 B/op          0 allocs/op
BenchmarkTree/ForEach-12            18723290      58.60 ns/op         0 B/op          0 allocs/op
BenchmarkTree/KNearest-12           3595956       324.7 ns/op         0 B/op          0 allocs/op
BenchmarkTree/Del-12                6234123       193.1 ns/op         0 B/op          0 allocs/op
PASS
ok      github.com/s0rg/quadtree    12.666s
```


quadtree

# Slices
Pure functions for slices. Slices are never operated on "in place". Instead, new ones are returned.

![](https://github.com/twharmon/slices/workflows/Test/badge.svg) [![](https://goreportcard.com/badge/github.com/twharmon/slices)](https://goreportcard.com/report/github.com/twharmon/slices) [![codecov](https://codecov.io/gh/twharmon/slices/branch/main/graph/badge.svg?token=K0P59TPRAL)](https://codecov.io/gh/twharmon/slices)

## Documentation
For full documentation see [pkg.go.dev](https://pkg.go.dev/github.com/twharmon/slices).

## Install
`go get github.com/twharmon/slices`

## Usage
```go
package main

import (
	"fmt"

	"github.com/twharmon/slices"
)

func main() {
	// use plain go slices
	s := []string{"foo", "ba"}

	// append new item to end of slice
	s = slices.Append(s, "b")
	fmt.Println(s) // [foo ba b]
	
	// sort by string length, ascending
	sorted := slices.SortFunc(s, func(a, b string) bool {
		return len(a) < len(b)
	})
	// original slice is not chaged
	fmt.Println(s, sorted) // [foo ba b] [b ba foo]

	// sum the lengths of all the strings    
	totalLen := slices.Reduce(s, func(cnt int, i string) int {
		return cnt + len(i)
	})
	fmt.Println(totalLen) // 6

	// find the first item with length 2
	str := slices.Find(s, func(item string) bool { return len(item) == 2 })    
	fmt.Println(str) // ba

	// map slice to new slice of different type
	ints := slices.Map(s, func(item string) int { return len(s) })    
	fmt.Println(ints) // [3 2 1]
}
```

## Benchmarks
```
goos: darwin
goarch: arm64
pkg: github.com/twharmon/slices

BenchmarkSortFunc/std_lib-10         	  116497	      9424 ns/op	    4152 B/op	       3 allocs/op
BenchmarkSortFunc/slices-10          	  101791	     11479 ns/op	    4096 B/op	       1 allocs/op
BenchmarkSort/std_lib-10             	  125790	      9441 ns/op	    4120 B/op	       2 allocs/op
BenchmarkSort/slices-10              	  113931	     10162 ns/op	    4096 B/op	       1 allocs/op

BenchmarkReverse-10                  	 1631348	       749.4 ns/op	    4096 B/op	       1 allocs/op
BenchmarkConcat-10                   	  275463	      4259 ns/op	   40960 B/op	       1 allocs/op
BenchmarkFilter-10                   	 1000000	      1018 ns/op	    4096 B/op	       1 allocs/op

BenchmarkUnion/2x20-10               	 3258876	       361.2 ns/op	      32 B/op	       1 allocs/op
BenchmarkUnion/20x2-10               	  502176	      2329 ns/op	    1592 B/op	       3 allocs/op
BenchmarkUnion/20x2000-10            	    1140	   1054108 ns/op	    1590 B/op	       3 allocs/op
BenchmarkUnion/2000x20-10            	     714	   1697117 ns/op	  142481 B/op	      39 allocs/op

BenchmarkIntersection/2x20-10        	 2380771	       498.0 ns/op	      48 B/op	       1 allocs/op
BenchmarkIntersection/20x2-10        	  821226	      1427 ns/op	    1196 B/op	       3 allocs/op
BenchmarkIntersection/20x2000-10     	    1178	   1020620 ns/op	    1282 B/op	       3 allocs/op
BenchmarkIntersection/2000x20-10     	     938	   1276258 ns/op	  203294 B/op	      58 allocs/op
```

## Contribute
Make a pull request.


slices

<img width="2898" height="3401" alt="image" src="https://github.com/user-attachments/assets/90e4aba6-fff3-41b5-b0d6-0676c92339ab" />

# FSM for Go

A generic, concurrent-safe, and easy-to-use finite state machine (FSM) library for Go.

This library provides a simple yet powerful API for defining states and transitions, handling callbacks, and managing stateful logic in your applications. It is built with types and utilities from the `github.com/enetx/g` library.

[![Go Reference](https://pkg.go.dev/badge/github.com/enetx/fsm.svg)](https://pkg.go.dev/github.com/enetx/fsm)
[![Go Report Card](https://goreportcard.com/badge/github.com/enetx/fsm)](https://goreportcard.com/report/github.com/enetx/fsm)
[![Coverage Status](https://coveralls.io/repos/github/enetx/fsm/badge.svg?branch=main&service=github)](https://coveralls.io/github/enetx/fsm?branch=main)
[![Go](https://github.com/enetx/fsm/actions/workflows/go.yml/badge.svg)](https://github.com/enetx/fsm/actions/workflows/go.yml)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/enetx/fsm)

## Features

-   **Simple & Fluent API**: Define your state machine with clear, chainable methods.
-   **Fast by Default**: The base FSM is non-blocking for maximum performance in single-threaded use cases.
-   **Drop-in Concurrency**: Get a fully thread-safe FSM by calling a single `Sync()` method.
-   **State Callbacks**: Execute code on entering (`OnEnter`) or exiting (`OnExit`) a state.
-   **Global Transition Hooks**: `OnTransition` allows you to monitor and log all state changes globally.
-   **Guarded Transitions**: Control transitions with `TransitionWhen` based on custom logic.
-   **JSON Serialization**: Easily save and restore the FSM's state with built-in `json.Marshaler` and `json.Unmarshaler` support.
-   **Graphviz Visualization**: Generate DOT-format graphs to visualize your FSM.
-   **Zero Dependencies** (besides `github.com/enetx/g`).

## Installation

```sh
go get github.com/enetx/fsm
```

## Quick Start

Here's a simple example of a traffic light state machine:

```go
package main

import (
	"fmt"
	"time"

	"github.com/enetx/fsm"
)

func main() {
	// 1. Define states and the event
	const (
		StateGreen  = "Green"
		StateYellow = "Yellow"
		StateRed    = "Red"
		EventTimer  = "timer_expires"
	)

	// 2. Configure the FSM
	lightFSM := fsm.New(StateRed).
		Transition(StateGreen, EventTimer, StateYellow).
		Transition(StateYellow, EventTimer, StateRed).
		Transition(StateRed, EventTimer, StateGreen)

	// 3. Define callbacks for entering states
	lightFSM.OnEnter(StateGreen, func(ctx *fsm.Context) error {
		fmt.Println("LIGHT: Green -> Go!")
		return nil
	})
	lightFSM.OnEnter(StateYellow, func(ctx *fsm.Context) error {
		fmt.Println("LIGHT: Yellow -> Prepare to stop")
		return nil
	})
	lightFSM.OnEnter(StateRed, func(ctx *fsm.Context) error {
		fmt.Println("LIGHT: Red -> Stop!")
		return nil
	})

	// 4. Run the FSM loop
	fmt.Printf("Initial state: %s\n", lightFSM.Current())
	lightFSM.CallEnter(StateRed) // Manually trigger the first prompt

	for range 4  {
		time.Sleep(1 * time.Second)
		fmt.Println("\n...timer expires...")
		lightFSM.Trigger(EventTimer)
	}
}
```

### Output

```text
Initial state: Red
LIGHT: Red -> Stop!

...timer expires...
LIGHT: Green -> Go!

...timer expires...
LIGHT: Yellow -> Prepare to stop

...timer expires...
LIGHT: Red -> Stop!

...timer expires...
LIGHT: Green -> Go!
```

## API Overview

### Creating an FSM

```go
// Create a new FSM instance (not thread-safe)
fsmachine := fsm.New("initial_state")

// Get a thread-safe wrapper for concurrent use
safeFSM := fsmachine.Sync()
```

### Defining Transitions

-   **`Transition(from, event, to)`**: A direct, unconditional transition.
-   **`TransitionWhen(from, event, to, guard)`**: A transition that only occurs if the `guard` function returns `true`.

```go
fsmachine.Transition("idle", "start", "running")

fsmachine.TransitionWhen("running", "stop", "stopped", func(ctx *fsm.Context) bool {
    // Only allow stopping if a specific condition is met
    return ctx.Data.Get("can_stop").UnwrapOr(false).(bool)
})
```

### Callbacks and Hooks

-   **`OnEnter(state, callback)`**: Called when the FSM enters `state`.
-   **`OnExit(state, callback)`**: Called before the FSM exits `state`.
-   **`OnTransition(hook)`**: Called on *every* successful transition, after `OnExit` and before `OnEnter`.

```go
fsmachine.OnEnter("running", func(ctx *fsm.Context) error {
    fmt.Println("Job started!")
    return nil
})

fsmachine.OnExit("running", func(ctx *fsm.Context) error {
    fmt.Println("Cleaning up job...")
    return nil
})

fsmachine.OnTransition(func(from, to fsm.State, event fsm.Event, ctx *fsm.Context) error {
    log.Printf("STATE CHANGE: %s -> %s (on event %s)", from, to, event)
    return nil
})
```

### Triggering Events

The `Trigger` method drives the state machine.

```go
// Simple trigger
err := fsmachine.Trigger("start")

// Trigger with data payload
// The data will be available in the context as `ctx.Input`.
err := fsmachine.Trigger("process", someDataObject)
```
Any error returned from a callback will halt the transition and be returned by `Trigger`.

### Context

The `Context` is passed to every callback and guard. It's the primary way to manage data associated with an FSM instance.

-   `ctx.Input`: Holds the data passed with the current `Trigger` call. It's ephemeral and lasts for one transition only.
-   `ctx.Data`: A concurrent-safe map (`g.MapSafe`) for persistent data that is serialized with the FSM (e.g., user details).
-   `ctx.Meta`: A concurrent-safe map (`g.MapSafe`) for ephemeral metadata that is also serialized (e.g., temporary counters).

### Concurrency

The library is designed with performance and safety in mind, offering two distinct operating modes:

1.  **`fsm.FSM` (Default)**: The base state machine is **not** thread-safe. It is optimized for performance in single-threaded scenarios by avoiding the overhead of mutexes.

2.  **`fsm.SyncFSM` (Synchronized)**: This is a thread-safe wrapper around the base `FSM`. It protects all operations (like `Trigger`, `Current`, `Reset`) with a mutex, ensuring that all transitions are atomic and safe to use across multiple goroutines.

You should complete all configuration (`Transition`, `OnEnter`, etc.) on the base `FSM` before using it. The configuration process itself is **not** thread-safe.

#### Activating Thread-Safety

To get a thread-safe instance, simply call the `Sync()` method after you have configured your FSM:

```go
// 1. Configure the non-thread-safe FSM template
fsmTemplate := fsm.New("idle").
    Transition("idle", "start", "running").
    Transition("running", "stop", "stopped")

// 2. Get a thread-safe, synchronized instance
safeFSM := fsmTemplate.Sync()

// 3. Now you can safely use safeFSM across multiple goroutines
go func() {
    err := safeFSM.Trigger("start")
    // ...
}()

go func() {
    currentState := safeFSM.Current()
    // ...
}()
```

### Serialization

You can easily save and restore the FSM's state using `encoding/json`, as `FSM` implements the `json.Marshaler` and `json.Unmarshaler` interfaces.

**Saving State:**
```go
// Assume `fsmachine` is in some state.
jsonData, err := json.Marshal(fsmachine)
if err != nil {
    // handle error
}
// Now you can save `jsonData` to a database, file, etc.
```

**Restoring State:**
```go
// 1. Create a new FSM with the same configuration as the original.
restoredFSM := fsm.New("initial_state").
    Transition(...) // ...add all transitions and callbacks

// 2. Unmarshal the JSON data into the new instance.
err := json.Unmarshal(jsonData, restoredFSM)
if err != nil {
    // handle error
}

// `restoredFSM` is now in the same state as the original was.
fmt.Println(restoredFSM.Current())
```
**Note**: Serialization only saves the FSM's state (`current`, `history`, `Data`, `Meta`). It does not save the transition rules or callbacks. You must configure the FSM template before unmarshaling. If you need a thread-safe FSM after restoring, call `.Sync()` *after* `json.Unmarshal`.

### Visual Generator (Web UI)

An in-browser FSM editor and Go code generator for this library.

[Open the Online Generator →](https://enetx.github.io/fsm/visual_generator/)

- 100% client-side (no data sent anywhere).
- Draw states and transitions, set callbacks and guards, then generate ready-to-use Go code for github.com/enetx/fsm.

#### Controls
- Double-click empty canvas — add a state.
- Double-click state/transition — rename state / edit event name.
- Shift + drag from one state to another — create a transition (self-loops supported).
- Right-click state — context menu (Set as Initial / Delete).
- Drag on empty canvas — rectangular multi-select; then use Align X, Align Y, Stack.
- Esc — cancel linking / clear selection.

#### Properties & Panels
- State properties: name, color, OnEnter, OnExit, “Final state”, and “Set as Initial”.
- Transition properties: event name and optional guard function.
- Events panel: shows incoming/outgoing events for the selected state (guards are italicized).

#### Generate Go Code
Click “Generate Go Code” to get a self-contained example:
- Declares const States and Events.
- Builds an FSM via fsm.New(initial) with .Transition(...) / .TransitionWhen(..., guard).
- Attaches callbacks with .OnEnter(...) / .OnExit(...).
- Emits function stubs for every referenced callback/guard (once per unique name).

Note: You must set an initial state before generating code. Callback/guard names you type in the UI become function names in the output.

#### Import / Export
- Export JSON — downloads fsm.json with positions, colors, callbacks, guards, transitions, and initial state.
- Import JSON — loads a saved model. If positions are missing, the tool auto-lays out nodes.

#### Validation & Hints
- State names must be unique (enforced by the editor).
- Warns about unreachable states.
- Guarded transitions are rendered with dashed lines and a diamond arrowhead.

### Visualization

The library includes a `ToDOT()` method to generate a graph of your state machine in the [DOT language](https://graphviz.org/doc/info/lang.html). This is extremely useful for debugging, documentation, and sharing your FSM's logic with your team.

You can render the output into an image using various tools:

*   **Online Editors (Recommended for quick use):**
    *   [**Graphviz Online**](https://dreampuf.github.io/GraphvizOnline/) - A simple and effective web-based viewer.
    *   [**Edotor**](https://edotor.net/) - Another powerful online editor with different layout engines.
    *   Simply paste the output of `ToDOT()` into one of these sites to see your diagram instantly.

*   **Local Installation:**
    *   For more advanced use or integration into build scripts, you can install [**Graphviz**](https://graphviz.org/download/) locally.

**Example:**

```go
func main() {
    fsmachine := fsm.New("Idle").
        Transition("Idle", "start", "Running").
        TransitionWhen("Running", "suspend", "Suspended", func(ctx *fsm.Context) bool {
            return true
        }).
        Transition("Suspended", "resume", "Running").
        Transition("Running", "finish", "Done")

    // Generate the DOT string
    fsmachine.ToDOT().Println() // Copy this output
}
```
<img width="941" height="360" alt="graphviz" src="https://github.com/user-attachments/assets/2516c2c4-582f-4c08-81e6-4b8c36a1920c" />

## Contributing

Contributions are welcome! Please feel free to submit a pull request or open an issue for bugs, feature requests, or questions.

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.


Go implementation Count-Min-Log sketch: Approximately counting with approximate counters (Like Count-Min sketch but using less memory)

# Count-Min-Log
[![GoDoc](https://godoc.org/github.com/seiflotfy/count-min-log?status.svg)](https://godoc.org/github.com/seiflotfy/count-min-log)

[Count-Min-Log sketch: Approximately counting with approximate counters - Guillaume Pitel & Geoffroy Fouquier](http://iswag-symposium.org/2015/pdfs/shortpaper1.pdf)

<b>TL;DR:</b> Count-Min-Log Sketch for improved Average Relative Error on low frequency events

Count-Min Sketch is a widely adopted algorithm for approximate event counting in large scale processing. However, the original version of the Count-Min-Sketch (CMS) suffers of some deficiences, especially if one is interested in the low-frequency items, such as in text- mining related tasks. Several variants of CMS have been proposed to compensate for the high relative error for low-frequency events, but the proposed solutions tend to correct the errors instead of preventing them. In this paper, we propose the Count-Min-Log sketch, which uses logarithm-based, approximate counters instead of linear counters to improve the average relative error of CMS at constant memory footprint.


## Example Usage

```go
import cml

...
sk, err := cml.NewDefaultSketch()
sk.IncreaseCount([]byte("scott pilgrim"))
...

sk.Frequency([]byte("scott pilgrim")) // ==> 1

```


count-min-log

[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

# gofal

[中文文档](README_zh_cn.md)

- Fractional Operational Correlation API base on golang
- Supporting Precision Operations
- Supporting addition, subtraction, multiplication and division
- Support chain expression
- Support result output(flat64)

### Example


1、 Add 

```go
	tmp := fractional.Model(7, 12)
	tmp1 := fractional.Model(1, 12)
	fmt.Println(tmp.Add(tmp1))
```

- out
```sh
2/3
```

2、 Subtraction 

```go
	tmp = fractional.Model(1, 4)
	tmp1 = fractional.Model(1, 3)
	fmt.Println(tmp.Sub(tmp1))
```

- out
```sh
-1/12
```

3、Multiplication

```go
	tmp = fractional.Model(3, 4)
	tmp1 = fractional.Model(2, 3)
	fmt.Println(tmp.Mul(tmp1))
```

- out
```sh
1/2
```

4、 Division

```go
	tmp = fractional.Model(3, 4)
	tmp1 = fractional.Model(2, 3)
	fmt.Println(tmp.Div(tmp1))
```

- out
```sh
9/8
```

5、 out put (flat64) 

```go
    tmp = fractional.Model(1, 3)
	fmt.Println(tmp.Verdict())
```

- out
```sh
0.3333333333333333
```

6、Chain expression

```go
	tmp := fractional.Model(1, 3)
	tmp.Add(fractional.Model(1)).Mul(tmp)
	fmt.Println(tmp)
```

- out
```sh
16/9
```
- All functions can support chain expressions


The Best Go Libraries For Data Structures and Algorithms - Miscellaneous Data Structures and Algorithms (19)