core

type Algo struct {
	// contains filtered or unexported fields
}

type AndFinishing struct {
	Finishings []Finishing
}

type Buffer interface {
	Push(elemt Elemt, running bool) error
	Data() []Elemt
	Apply() error
}

type Clust []Elemt

type ClustStatus int64

type Conf interface {
	Verify() error
	Ctrl() *CtrlConf // get controller configuration
	SetDefaultValues()
}

type CtrlConf struct {
	Iter           int            // minimal number of iteration before sleeping. Default unlimited
	IterFreq       float64        // maximal number of iteration per seconds
	Timeout        time.Duration  // minimal number of nanoseconds before stopping the algorithm. 0 is infinite (default)
	DataPerIter    int            // minimal pushed data number before iterating
	IterPerData    int            // minimal iterations per `DataPerIter` data
	StatusNotifier StatusNotifier // algo execution notifier
	Finishing      Finishing      // algo convergence matcher
}

type DataBuffer struct {
	// contains filtered or unexported fields
}

type Elemt interface{}

type Finishing interface {
	IsFinished(OCModel) bool
}

type Impl interface {
	// initialize the algorithm
	Init(OCModel) (Clust, error)
	// process one algorithm iteration
	Iterate(OCModel) (Clust, RuntimeFigures, error)
	// push a data. The second argument is the model
	Push(Elemt, OCModel) error
	// Get a copy of  impl
	Copy(OCModel) (Impl, error)
}

type Initializer func(k int, elemts []Elemt, space Space, src *rand.Rand) (centroids Clust, err error)

type IterFinishing struct {
	Iter        int
	IterPerData int
}

type OCCtrl interface {
	Init() error                               // initialize algo centroids with impl strategy
	Play() error                               // play the algorithm
	Pause() error                              // pause the algorithm (idle)
	Wait(Finishing, time.Duration) error       // wait for finishing condition and maximal duration. By default, finishing is ready/idle/finished status, and duration is infinite
	Stop() error                               // stop the algorithm
	Push(Elemt) error                          // add element
	Predict(elemt Elemt) (Elemt, int, float64) // input elemt centroid/label with distance to closest centroid
	Batch() error                              // batch mode (stop, play, wait then stop)
	Copy(Conf, Space) (OnlineClust, error)     // make a copy of this algo with new configuration and space
}

type OCModel interface {
	Centroids() Clust               // clustering result
	Conf() Conf                     // algo conf
	Impl() Impl                     // algo impl
	Space() Space                   // data space
	Status() OCStatus               // algo status
	RuntimeFigures() RuntimeFigures // clustering figures
}

type OCStatus struct {
	Value ClustStatus
	Error error
}

type OnlineClust interface {
	OCCtrl
	OCModel
}

type OrFinishing struct {
	Finishings []Finishing
}

type PartitionProcess = func(start, end, rank int)

type RuntimeFigures map[string]float64

type SimpleOCModel struct {
	// contains filtered or unexported fields
}

type Space interface {
	Dist(elemt1, elemt2 Elemt) float64
	Combine(elemt1 Elemt, weight1 int, elemt2 Elemt, weight2 int) Elemt
	Copy(elemt Elemt) Elemt
	Dim(data []Elemt) int
}

type SpaceConf interface{}

type StatusFinishing struct {
	Status []ClustStatus // Specific status finish condition
	Error  bool          // if true and ocm failed, finish
}

type StatusNotifier = func(OnlineClust, OCStatus)

type Timeout interface {
	Disable()
	Enabled() bool
}