# common¶

A collection of functions used throughout FilterPy, and/or functions that you will find useful when you build your filters.

Copyright 2015 Roger R Labbe Jr.

FilterPy library. http://github.com/rlabbe/filterpy

Supporting book at: https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python

filterpy.common.Q_discrete_white_noise(dim, dt=1.0, var=1.0)[source]

Returns the Q matrix for the Discrete Constant White Noise Model. dim may be either 2 or 3, dt is the time step, and sigma is the variance in the noise.

Q is computed as the G * G^T * variance, where G is the process noise per time step. In other words, G = [[.5dt^2][dt]]^T for the constant velocity model.

Parameters: dim : int (2 or 3) dimension for Q, where the final dimension is (dim x dim) dt : float, default=1.0 time step in whatever units your filter is using for time. i.e. the amount of time between innovations var : float, default=1.0 variance in the noise

filterpy.common.Q_continuous_white_noise(dim, dt=1.0, spectral_density=1.0)[source]

Returns the Q matrix for the Discretized Continuous White Noise Model. dim may be either 2 or 3, dt is the time step, and sigma is the variance in the noise.

Parameters: dim : int (2 or 3) dimension for Q, where the final dimension is (dim x dim) dt : float, default=1.0 time step in whatever units your filter is using for time. i.e. the amount of time between innovations spectral_density : float, default=1.0 spectral density for the continuous process

filterpy.common.van_loan_discretization(F, G, dt)[source]

Discretizes a linear differential equation which includes white noise according to the method of C. F. van Loan [1]. Given the continuous model

x’ = Fx + Gu

where u is the unity white noise, we compute and return the sigma and Q_k that discretizes that equation.

References

[1] C. F. van Loan. “Computing Integrals Involving the Matrix Exponential.”
IEEE Trans. Automomatic Control, AC-23 (3): 395-404 (June 1978)
[2] Robert Grover Brown. “Introduction to Random Signals and Applied
Kalman Filtering.” Forth edition. John Wiley & Sons. p. 126-7. (2012)

Examples

Given y’’ + y = 2u(t), we create the continuous state model of

x’ = [ 0 1] * x + [0]*u(t)
[-1 0] [2]

and a time step of 0.1:

>>> F = np.array([[0,1],[-1,0]], dtype=float)
>>> G = np.array([[0.],[2.]])
>>> phi, Q = van_loan_discretization(F, G, 0.1)

>>> phi
array([[ 0.99500417,  0.09983342],
[-0.09983342,  0.99500417]])

>>> Q
array([[ 0.00133067,  0.01993342],
[ 0.01993342,  0.39866933]])


(example taken from Brown[2])

filterpy.common.linear_ode_discretation(F, L=None, Q=None, dt=1)[source]

filterpy.common.runge_kutta4(y, x, dx, f)[source]

computes 4th order Runge-Kutta for dy/dx.

Parameters: y : scalar Initial/current value for y x : scalar Initial/current value for x dx : scalar difference in x (e.g. the time step) f : ufunc(y,x) Callable function (y, x) that you supply to compute dy/dx for the specified values.

filterpy.common.dot3(A, B, C)[source]

Returns the matrix multiplication of A*B*C

filterpy.common.dot4(A, B, C, D)[source]

Returns the matrix multiplication of A*B*C*D

filterpy.common.dotn(*args)[source]

Returns the matrix multiplication of 2 or more matrices