First of all: I am sorry about the last PR I did. I am quite embarrassed of the error I introduced.

I've changed interface names Model-> DModel, Propagator-> DPropagator to indicate they are discrete-time functions and that they are not compatible with sim.Continuous implementation. Let me know if any of the changes are too much.

I found a rather serious mistake in the implementation of Propagate().

The issue is that next state was calculated as X_{n+1} = A*X_{n} + B*U. The equation modern control theory supposes is dX/dt = A * X_{n} + B*U which means you have to integrate the result in time.

There was a mistake in sim package in that there was no distinction made between input vector length (u) and state vector length (x). Model dimension now is fully explicit returning length of x state vector, u input vector, y output vector, and z disturbance input vector. Do note that I have yet to implement the disturbance matrix E so for now the fourth parameter returned by Dims() should be equal to length of x (first parameter). I just thought it was a good idea to future-proof the API.

I've also added documentation to interfaces.

When I copy bf.go into my project and run it I get the following output: ../esp/go/pkg/mod/github.com/milosgajdos83/[email protected]/noise/gaussian.go:44:32: g.dist.CovarianceMatrix(nil) used as value But if I run it from the examples dir it works as expected.

myproject/vendor/github.com/milosgajdos/go-estimate/sim/plot.go:35:9: assignment mismatch: 2 variables but plot.New returns 1 values
myproject/vendor/github.com/milosgajdos/go-estimate/sim/plot.go:43:14: assignment mismatch: 2 variables but plot.NewLegend returns 1 values

Link to file https://github.com/milosgajdos/go-estimate/blob/master/sim/plot.go#L35

Running go mod tidy does not fix it. I'm on go version go1.16.3 linux/amd64.

It would be of great use if interfaces where arguments are ambiguous, for example Observer and Filter, named their arguments according to control theory typical nomenclature.

This is current interface definition

// Filter is a dynamical system filter.
type Filter interface {
	// Predict estimates the next internal state of the system
	Predict(mat.Vector, mat.Vector) (Estimate, error)
	// Update updates the system state based on external measurement
	Update(mat.Vector, mat.Vector, mat.Vector) (Estimate, error)
}

// Propagator propagates internal state of the system to the next step
type Propagator interface {
	// Propagate propagates internal state of the system to the next step
	Propagate(mat.Vector, mat.Vector, mat.Vector) (mat.Vector, error)
}

// Observer observes external state (output) of the system
type Observer interface {
	// Observe observes external state of the system
	Observe(mat.Vector, mat.Vector, mat.Vector) (mat.Vector, error)
}

Problems with this definition include:

• All arguments are mat.Vector. What convention is being used?
• Comments do not help either. Overall lackluster documentation

Other interfaces with this problem:

• filter.DiscreteModel. This one is fixed easy: StateMatrix() (A mat.Matrix). A,B,C and D matrices are standard nomenclature for these matrices

Possible solutions

Below is a mix of adding a little bit of documentation + naming the variables.

type Filter interface {
	// Predict estimates the next internal state of the system. x is state, u are inputs
	Predict(x,u mat.Vector) (filter.Estimate, error)
	// Update updates the system state based on external measurement. x is state, u are inputs, z is the measurement
	Update(x, u, z mat.Vector) (filter.Estimate, error) 
}

Hi,

We are looking for an UKF for motion modelling a drone path where degrees of freedom are very high. Just wanted to check this library is generic enough to incorporate any complex motion model.

The gonum plot error from #7 keeps popping up whenever running go mod tidy on some projects which use gonum and go-estimate. Figure it wouldn't hurt to upgrade dependencies since they seem rather outdated.

What I did:

1. Remove go.sum
2. Remove gonum dependencies in go.mod among others.
3. Run go clean -modcache
4. Run `go mod tidy

Hi, I was using kalman filter, where I need to call predict but at varying timesteps. I am referring to example where fixed delta t are used for state propagation. My measurement updates and predictions are async and can come at varying time intervals so first update can be called at 1s, next at 5s, and next at 6s... so on. from the source code it seems not doable as m ie. model is private and is fixed during initialization, now I can change A matrix(reflecting delta t multiplication) in model itself but this won't be reflected in kf object, as its pass by value, not pass by pointer. Can you please suggest, if there already exists something for this in library or a workaround.

Below are the changes to the API:

Interfaces

• Propagator -> DiscretePropagator
• Model -> DiscreteModel
• DiscreteModel -> DiscreteControlSystem (I think this change makes it much clearer about what this interface represents, as it has methods pertaining to control theory constructs while Model was just that, a model of a dynamical system)

sim package changes

• BaseModel struct -> Discrete struct
• Add Continuous struct and allow conversion of a continuous time system to discrete time via ToDiscrete. Will add ToContinous to allow for easy testing.

Overall the remaining changes were API updates.