streaming

type AGMConfig struct {
	// NumLevels is the number of sampling levels (log n).
	NumLevels int

	// Width is the width of the sketch at each level.
	Width int

	// MaxVertices is the maximum number of vertices supported.
	MaxVertices int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type AGMEdge struct {
	From string
	To   string
}

type AGMInput struct {
	// Operation specifies what to do: "add", "delete", "query", or "merge".
	Operation string

	// Edges are the edges to add or delete.
	Edges []AGMEdge

	// Sketch is an existing AGM sketch.
	Sketch *AGMState

	// OtherSketch is another sketch to merge with.
	OtherSketch *AGMState

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type AGMOutput struct {
	// Sketch is the resulting AGM sketch state.
	Sketch *AGMState

	// Components is the estimated number of connected components.
	Components int

	// SpanningEdges are the recovered spanning forest edges.
	SpanningEdges []AGMEdge

	// EdgesProcessed is the number of edges processed.
	EdgesProcessed int
}

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

type AGMState struct {
	// Levels holds sketches at each sampling level.
	// levels[i] is sampled with probability 2^(-i).
	Levels [][]int64

	// VertexMap maps vertex IDs to internal indices.
	VertexMap map[string]int

	// NextVertex is the next available vertex index.
	NextVertex int

	// NumLevels is the number of levels.
	NumLevels int

	// Width is the width at each level.
	Width int

	// EdgeCount is the number of edges added.
	EdgeCount int64

	// Seeds for hash functions.
	Seeds []uint64
}

type AlgorithmError struct {
	Algorithm string
	Operation string
	Err       error
}

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

type CountMinConfig struct {
	// Width is the number of buckets per row.
	Width int

	// Depth is the number of hash functions (rows).
	Depth int

	// Epsilon is the error bound (affects width: w = ceil(e/epsilon)).
	Epsilon float64

	// Delta is the failure probability (affects depth: d = ceil(ln(1/delta))).
	Delta float64

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type CountMinInput struct {
	// Operation specifies what to do: "add", "query", or "merge".
	Operation string

	// Items are the elements to add (for "add" operation).
	Items []CountMinItem

	// Queries are the elements to query frequencies for (for "query" operation).
	Queries []string

	// Sketch is an existing sketch to merge (for "merge" operation).
	Sketch *CountMinSketch

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type CountMinItem struct {
	Key   string
	Count int64
}

type CountMinOutput struct {
	// Sketch is the resulting sketch state.
	Sketch *CountMinSketch

	// Frequencies maps queried keys to their estimated frequencies.
	Frequencies map[string]int64

	// ItemsProcessed is the number of items processed.
	ItemsProcessed int

	// TotalCount is the sum of all counts in the sketch.
	TotalCount int64
}

type CountMinSketch struct {
	// Table is the 2D count matrix [depth][width].
	Table [][]int64

	// Width is the number of columns.
	Width int

	// Depth is the number of rows (hash functions).
	Depth int

	// Seeds are the hash function seeds.
	Seeds []uint64

	// Total is the sum of all added counts.
	Total int64
}

type HLLState struct {
	// Registers hold the max leading zeros for each bucket.
	Registers []uint8

	// Precision is the number of bits for indexing.
	Precision int

	// Count is the number of items added.
	Count uint64
}

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

type HyperLogLogConfig struct {
	// Precision is the number of bits for register indexing (4-18).
	// Higher precision = more accuracy but more memory.
	// Memory usage = 2^precision bytes.
	Precision int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type HyperLogLogInput struct {
	// Operation specifies what to do: "add", "count", or "merge".
	Operation string

	// Items are the elements to add (for "add" operation).
	Items []string

	// HLL is an existing HyperLogLog state (for "count" or "merge").
	HLL *HLLState

	// OtherHLL is another HLL to merge with (for "merge").
	OtherHLL *HLLState

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type HyperLogLogOutput struct {
	// HLL is the resulting HyperLogLog state.
	HLL *HLLState

	// Cardinality is the estimated number of distinct elements.
	Cardinality uint64

	// ItemsProcessed is the number of items processed.
	ItemsProcessed int

	// StandardError is the estimated relative standard error.
	StandardError float64
}

type L0Config struct {
	// NumLevels is the number of sampling levels.
	NumLevels int

	// NumSamples is the number of samples to maintain.
	NumSamples int

	// MaxItems is the maximum number of distinct items.
	MaxItems int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type L0Input struct {
	// Operation specifies what to do: "update", "sample", or "merge".
	Operation string

	// Updates are the items to update (for "update" operation).
	Updates []L0Update

	// State is an existing L0 sampling state.
	State *L0State

	// OtherState is another state to merge with.
	OtherState *L0State

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type L0Level struct {
	// Samples holds the current samples at this level.
	Samples map[string]int64

	// Count is the number of items that hashed to this level.
	Count int64
}

type L0Output struct {
	// State is the resulting L0 sampling state.
	State *L0State

	// Samples are the sampled items.
	Samples []L0Sample

	// UpdatesProcessed is the number of updates processed.
	UpdatesProcessed int

	// NonZeroEstimate is the estimated number of non-zero entries.
	NonZeroEstimate int64
}

type L0Sample struct {
	Key   string
	Value int64
	Level int
}

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

type L0State struct {
	// Levels holds the sampling state at each level.
	// Each level samples with probability 2^(-level).
	Levels []L0Level

	// NumLevels is the number of levels.
	NumLevels int

	// NumSamples is the number of samples to maintain.
	NumSamples int

	// Seeds for hash functions.
	Seeds []uint64

	// TotalUpdates is the total number of updates applied.
	TotalUpdates int64
}

type L0Update struct {
	Key   string
	Delta int64 // Can be positive or negative
}

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

type LSHConfig struct {
	// NumBands is the number of bands to split the signature into.
	NumBands int

	// RowsPerBand is the number of rows per band.
	RowsPerBand int

	// SignatureSize is the total signature size (NumBands * RowsPerBand).
	SignatureSize int

	// Threshold is the similarity threshold for candidate pairs.
	Threshold float64

	// MaxCandidates limits the number of candidates returned.
	MaxCandidates int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type LSHIndex struct {
	// Buckets maps band hashes to item IDs.
	// buckets[bandIdx][bandHash] = []itemID
	Buckets []map[uint64][]string

	// Signatures stores the full signatures for similarity verification.
	Signatures map[string]*MinHashSignature

	// NumBands is the number of bands.
	NumBands int

	// RowsPerBand is the rows per band.
	RowsPerBand int

	// ItemCount is the number of indexed items.
	ItemCount int
}

type LSHInput struct {
	// Operation specifies what to do: "index", "query", or "candidates".
	Operation string

	// ID is the identifier for the item being indexed.
	ID string

	// Signature is the MinHash signature to index or query.
	Signature *MinHashSignature

	// Index is an existing LSH index (for "query" or "index" operations).
	Index *LSHIndex

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type LSHOutput struct {
	// Index is the resulting LSH index.
	Index *LSHIndex

	// Candidates are the IDs of potential similar items.
	Candidates []string

	// CandidateCount is the number of candidates found.
	CandidateCount int

	// BucketsUsed is the number of buckets with items.
	BucketsUsed int
}

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

type MinHashConfig struct {
	// NumHashes is the number of hash functions (signature size).
	NumHashes int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type MinHashInput struct {
	// Operation specifies what to do: "signature", "similarity", or "merge".
	Operation string

	// Set is the set elements to compute signature for (for "signature").
	Set []string

	// Signature is an existing signature (for "similarity" or "merge").
	Signature *MinHashSignature

	// OtherSignature is another signature to compare/merge with.
	OtherSignature *MinHashSignature

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type MinHashOutput struct {
	// Signature is the computed MinHash signature.
	Signature *MinHashSignature

	// Similarity is the estimated Jaccard similarity (for "similarity").
	Similarity float64

	// ItemsProcessed is the number of set elements processed.
	ItemsProcessed int
}

type MinHashSignature struct {
	// Values are the minimum hash values for each hash function.
	Values []uint64

	// NumHashes is the number of hash functions used.
	NumHashes int

	// Coefficients are the hash function parameters (a, b pairs).
	Coefficients []uint64

	// SetSize is the original set size.
	SetSize int
}

type WLConfig struct {
	// MaxIterations is the maximum number of refinement iterations.
	MaxIterations int

	// EarlyStop enables stopping when coloring stabilizes.
	EarlyStop bool

	// MaxNodes limits the number of nodes to process.
	MaxNodes int

	// Timeout is the maximum execution time.
	Timeout time.Duration

	// ProgressInterval is how often to report progress.
	ProgressInterval time.Duration
}

type WLGraph struct {
	// Nodes are the vertex IDs.
	Nodes []string

	// Edges maps each node to its neighbors.
	Edges map[string][]string

	// NodeLabels are optional vertex labels.
	NodeLabels map[string]string
}

type WLInput struct {
	// Operation specifies what to do: "color", "compare", or "fingerprint".
	Operation string

	// Graph is the graph to process.
	Graph *WLGraph

	// OtherGraph is another graph to compare with (for "compare").
	OtherGraph *WLGraph

	// InitialColors are optional initial vertex colors.
	InitialColors map[string]uint64

	// Source indicates where the request originated.
	Source crs.SignalSource
}

type WLOutput struct {
	// Colors maps each vertex to its final color.
	Colors map[string]uint64

	// ColorHistogram counts vertices per color.
	ColorHistogram map[uint64]int

	// Fingerprint is a canonical fingerprint for the graph.
	Fingerprint uint64

	// IsIsomorphic is whether two graphs could be isomorphic (for "compare").
	IsIsomorphic bool

	// IterationsUsed is the number of refinement iterations.
	IterationsUsed int

	// ColorClasses is the number of distinct colors.
	ColorClasses int

	// Stabilized is true if coloring stabilized before max iterations.
	Stabilized bool
}

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