filter

README

go-estimate: State estimation and filtering algorithms in Go

This package offers a small suite of basic filtering algorithms written in Go. It currently provides the implementations of the following filters and estimators:

• Bootstrap Filter also known as SIR Particle filter
• Unscented Kalman Filter also known as Sigma-point filter
• Extended Kalman Filter also known as Non-linear Kalman Filter
  • Iterated Extended Kalman Filter
• Kalman Filter also known as Linear Kalman Filter

In addition it provides an implementation of Rauch–Tung–Striebel smoothing for Kalman filter, which is an optimal Gaussian smoothing algorithm. There are variants for both LKF (Linear Kalman Filter) and EKF (Extended Kalman Filter) implemented in the smooth package. UKF smoothing will be implemented in the future.

Get started

Get the package:

$ go get github.com/milosgajdos/go-estimate

Get dependencies:

$ make dep

Run unit tests:

$ make test

You can find various examples of usage in go-estimate-examples.

TODO

• Square Root filter
• Information Filter
• Smoothing
  • Rauch–Tung–Striebel for both KF and EKF has been implemented in smooth package

Contributing

YES PLEASE!

Documentation

Index

• type DiscreteModel
• type Estimate
• type Filter
• type InitCond
• type Model
• type Noise
• type Observer
• type Propagator
• type Smoother

Types

type DiscreteModel

type DiscreteModel interface {
	// Model is a model of a dynamical system
	Model
	// SystemMatrix returns state propagation matrix
	SystemMatrix() (A mat.Matrix)
	// ControlMatrix returns state propagation control matrix
	ControlMatrix() (B mat.Matrix)
	// OutputMatrix returns observation matrix
	OutputMatrix() (C mat.Matrix)
	// FeedForwardMatrix returns observation control matrix
	FeedForwardMatrix() (D mat.Matrix)
}

DiscreteModel is a dynamical system whose state is driven by static propagation and observation dynamics matrices

type Estimate

type Estimate interface {
	// Val returns estimate value
	Val() mat.Vector
	// Cov returns estimate covariance
	Cov() mat.Symmetric
}

Estimate is dynamical system filter estimate

type Filter

type Filter interface {
	// Predict returns a prediction of which will be
	// next internal state
	Predict(x, u mat.Vector) (Estimate, error)
	// Update returns estimated system state based on external measurement ym.
	Update(x, u, ym mat.Vector) (Estimate, error)
}

Filter is a dynamical system filter.

type InitCond

type InitCond interface {
	// State returns initial filter state
	State() mat.Vector
	// Cov returns initial state covariance
	Cov() mat.Symmetric
}

InitCond is initial state condition of the filter

type Model

type Model interface {
	// Propagator is system propagator
	Propagator
	// Observer is system observer
	Observer
	// SystemDims returns the dimension of state vector, input vector,
	// output (measurements, written as y) vector and disturbance vector (only dynamical systems).
	// Below are dimension of matrices as returned by SystemDims() (row,column)
	//  nx, nx = A.SystemDims()
	//  nx, nu = B.SystemDims()
	//  ny, nx = C.SystemDims()
	//  ny, nu = D.SystemDims()
	//  nx, nz = E.SystemDims()
	SystemDims() (nx, nu, ny, nz int)
}

Model is a model of a dynamical system

type Noise

type Noise interface {
	// Mean returns noise mean
	Mean() []float64
	// Cov returns covariance matrix of the noise
	Cov() mat.Symmetric
	// Sample returns a sample of the noise
	Sample() mat.Vector
	// Reset resets the noise
	Reset()
}

Noise is dynamical system noise

type Observer

type Observer interface {
	// Observe observes external state of the system.
	// Result for a linear system would be y=C*x+D*u+wn (last term is measurement noise)
	Observe(x, u, wn mat.Vector) (y mat.Vector, err error)
}

Observer observes external state (output) of the system

type Propagator

type Propagator interface {
	// Propagate propagates internal state of the system to the next step.
	// x is starting state, u is input vector, and z is disturbance input
	Propagate(x, u, z mat.Vector) (mat.Vector, error)
}

Propagator propagates internal state of the system to the next step

type Smoother

type Smoother interface {
	// Smooth implements filter smoothing and returns new estimates
	Smooth([]Estimate, []mat.Vector) ([]Estimate, error)
}

Smoother is a filter smoother