math

type AngleBasedSort struct {
	Reference Point
	Points    []Point
}

type BatchAggregateFunc func(aggregated bitflow.Value, newValue bitflow.Value) bitflow.Value

type BatchAggregator struct {
	Aggregator  BatchAggregateFunc
	Description string
}

type BatchFeatureStatsAggregator struct {
	Aggregate   GetFeatureFunc
	Description string
}

type BatchFft struct {
	// By default, the upper half of the FFT results is cut off, because the FFT results are symmetric.
	// Set LeaveSymmetricPart to true to include preserve all result values.
	LeaveSymmetricPart bool

	// By default, the FFT results are normalized. Set SkipNormalization to true to avoid this.
	// Normalization helps comparing the results of FFTs with different numbers of input values.
	// Normalization is done by dividing every FFT result value by the total number of input values to the FFT.
	// If FillZeros=true, this is the closest power of two above the number of actual input samples. If FillZeros=false, this is the closest power of two beneath that.
	SkipNormalization bool

	// If the number of input samples is not exactly a power of two, the input batch must either be cut short or filled up with zeros.
	// The default is to cut the input to a power of two. set FillZeros to true, to instead fill the input with zeros to reach the next higher power of two.
	FillZeros bool

	// If FrequencyMetricIndex >= 0, the frequency for every FFT result value will be added as a new metric at the given index.
	// If the index is higher than the total number of input metrics, it will be appended as the last metric.
	// The name of that new metric will be FftFreqMetricName ("freq").
	FrequencyMetricIndex int

	// If SamplingFrequency > 0, it will be used as the total sampling frequency when computing the frequency metric.
	// If this is <= 0, the sampling frequency will be computed automatically from the timestamps of the first and last input sample, and the total number of samples.
	SamplingFrequency float64

	// FatalErrors can be set to true to return errors that occur when processing a batch.
	// Otherwise, the error will be printed as a warning and an empty result batch will be produced.
	FatalErrors bool
}

type BatchRms struct {
}

type ConvexHull []Point

type FeatureAggregator struct {
	bitflow.NoopProcessor
	WindowSize     int           // Applied if >0
	WindowDuration time.Duration // Applied if >0
	UseCurrentTime bool          // If true, use time.Now() as reference for WindowTime. Otherwise, use the timestamp of the latest Sample.
	// contains filtered or unexported fields
}

type FeatureAggregatorOperation func(stats *FeatureWindowStats) bitflow.Value

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

type GetFeatureFunc func(stats steps.FeatureStats) float64

type MinMaxScaling struct {
	Min float64
	Max float64
}

type PCAModel struct {
	Vectors            *mat.Dense
	RawVariances       []float64
	ContainedVariances []float64
}

type PCAProjection struct {
	Model      *PCAModel
	Vectors    mat.Matrix
	Components int
}

type Point struct {
	X, Y float64
}

type SpherePoints struct {
	bitflow.NoopProcessor
	RandomSeed int64
	NumPoints  int

	RadiusMetric int // If >= 0, use to get radius. Otherwise, use Radius field.
	Radius       float64
	// contains filtered or unexported fields
}

type StandardizationScaling struct {
}