math

Documentation

Index

• Variables
• func AbsDiff[T constraints.Unsigned](a, b T) T
• func Add64(a, b uint64) (uint64, error)
• func Mul64(a, b uint64) (uint64, error)
• func Sub[T constraints.Unsigned](a, b T) (T, error)
• type Averager
  • func NewAverager(initialPrediction float64, halflife time.Duration, currentTime time.Time) Averager
  • func NewSyncAverager(averager Averager) Averager
  • func NewUninitializedAverager(halfLife time.Duration) Averager
• type AveragerHeap
  • func NewMaxAveragerHeap() AveragerHeap

Variables

var (
	ErrOverflow  = errors.New("overflow")
	ErrUnderflow = errors.New("underflow")
)

Functions

func AbsDiff

func AbsDiff[T constraints.Unsigned](a, b T) T

func Add64

func Add64(a, b uint64) (uint64, error)

Add64 returns: 1) a + b 2) If there is overflow, an error

Note that we don't have a generic Add function because checking for an overflow requires knowing the max size of a given type, which we don't know if we're adding generic types.

func Mul64

func Mul64(a, b uint64) (uint64, error)

Mul64 returns: 1) a * b 2) If there is overflow, an error

Note that we don't have a generic Mul function because checking for an overflow requires knowing the max size of a given type, which we don't know if we're adding generic types.

func Sub

func Sub[T constraints.Unsigned](a, b T) (T, error)

Sub returns: 1) a - b 2) If there is underflow, an error

Types

type Averager

type Averager interface {
	// Observe the value at the given time
	Observe(value float64, currentTime time.Time)

	// Read returns the average of the provided values.
	Read() float64
}

Averager tracks a continuous time exponential moving average of the provided values.

func NewAverager

func NewAverager(
	initialPrediction float64,
	halflife time.Duration,
	currentTime time.Time,
) Averager

func NewSyncAverager

func NewSyncAverager(averager Averager) Averager

func NewUninitializedAverager

func NewUninitializedAverager(halfLife time.Duration) Averager

NewUninitializedAverager creates a new averager with the given halflife. If [Read] is called before [Observe], the zero value will be returned. When [Observe] is called the first time, the averager will be initialized with [value] at that time.

type AveragerHeap

type AveragerHeap interface {
	// Add the average to the heap. If [nodeID] is already in the heap, the
	// average will be replaced and the old average will be returned. If there
	// was not an old average, false will be returned.
	Add(nodeID ids.NodeID, averager Averager) (Averager, bool)
	// Remove attempts to remove the average that was added with the provided
	// [nodeID], if none is contained in the heap, [false] will be returned.
	Remove(nodeID ids.NodeID) (Averager, bool)
	// Pop attempts to remove the node with either the largest or smallest
	// average, depending on if this is a max heap or a min heap, respectively.
	Pop() (ids.NodeID, Averager, bool)
	// Peek attempts to return the node with either the largest or smallest
	// average, depending on if this is a max heap or a min heap, respectively.
	Peek() (ids.NodeID, Averager, bool)
	// Len returns the number of nodes that are currently in the heap.
	Len() int
}

TODO replace this interface with utils/heap AveragerHeap maintains a heap of the averagers.

func NewMaxAveragerHeap

func NewMaxAveragerHeap() AveragerHeap

NewMaxAveragerHeap returns a new empty max heap. The returned heap is not thread safe.