Class LinearFilter
public class LinearFilter extends Object
Filters are of the form: y[n] = (b0 x[n] + b1 x[n1] + ... + bP x[nP])  (a0 y[n1] + a2 y[n2] + ... + aQ y[nQ])
Where: y[n] is the output at time "n" x[n] is the input at time "n" y[n1] is the output from the LAST time step ("n1") x[n1] is the input from the LAST time step ("n1") b0...bP are the "feedforward" (FIR) gains a0...aQ are the "feedback" (IIR) gains IMPORTANT! Note the "" sign in front of the feedback term! This is a common convention in signal processing.
What can linear filters do? Basically, they can filter, or diminish, the effects of undesirable input frequencies. High frequencies, or rapid changes, can be indicative of sensor noise or be otherwise undesirable. A "low pass" filter smooths out the signal, reducing the impact of these high frequency components. Likewise, a "high pass" filter gets rid of slowmoving signal components, letting you detect large changes more easily.
Example FRC applications of filters:  Getting rid of noise from an analog sensor input (note: the roboRIO's FPGA can do this faster in hardware)  Smoothing out joystick input to prevent the wheels from slipping or the robot from tipping  Smoothing motor commands so that unnecessary strain isn't put on electrical or mechanical components  If you use clever gains, you can make a PID controller out of this class!
For more on filters, we highly recommend the following articles:
https://en.wikipedia.org/wiki/Linear_filter
https://en.wikipedia.org/wiki/Iir_filter
https://en.wikipedia.org/wiki/Fir_filter
Note 1: calculate() should be called by the user on a known, regular period. You can use a Notifier for this or do it "inline" with code in a periodic function.
Note 2: For ALL filters, gains are necessarily a function of frequency. If you make a filter that works well for you at, say, 100Hz, you will most definitely need to adjust the gains if you then want to run it at 200Hz! Combining this with Note 1  the impetus is on YOU as a developer to make sure calculate() gets called at the desired, constant frequency!

Constructor Summary
Constructors Constructor Description LinearFilter(double[] ffGains, double[] fbGains)
Create a linear FIR or IIR filter. 
Method Summary
Modifier and Type Method Description static LinearFilter
backwardFiniteDifference(int derivative, int samples, double period)
Creates a backward finite difference filter that computes the nth derivative of the input given the specified number of samples.double
calculate(double input)
Calculates the next value of the filter.static LinearFilter
finiteDifference(int derivative, int[] stencil, double period)
Creates a finite difference filter that computes the nth derivative of the input given the specified stencil points.static LinearFilter
highPass(double timeConstant, double period)
Creates a firstorder highpass filter of the form: y[n] = gain x[n] + (gain) x[n1] + gain y[n1] where gain = e^{dt / T}, T is the time constant in seconds.static LinearFilter
movingAverage(int taps)
Creates a Ktap FIR moving average filter of the form: y[n] = 1/k (x[k] + x[k1] + ...void
reset()
Reset the filter state.static LinearFilter
singlePoleIIR(double timeConstant, double period)
Creates a onepole IIR lowpass filter of the form: y[n] = (1gain) x[n] + gain y[n1] where gain = e^{dt / T}, T is the time constant in seconds.

Constructor Details

LinearFilter
Create a linear FIR or IIR filter. Parameters:
ffGains
 The "feedforward" or FIR gains.fbGains
 The "feedback" or IIR gains.


Method Details

singlePoleIIR
Creates a onepole IIR lowpass filter of the form: y[n] = (1gain) x[n] + gain y[n1] where gain = e^{dt / T}, T is the time constant in seconds.Note: T = 1 / (2 pi f) where f is the cutoff frequency in Hz, the frequency above which the input starts to attenuate.
This filter is stable for time constants greater than zero.
 Parameters:
timeConstant
 The discretetime time constant in seconds.period
 The period in seconds between samples taken by the user. Returns:
 Linear filter.

highPass
Creates a firstorder highpass filter of the form: y[n] = gain x[n] + (gain) x[n1] + gain y[n1] where gain = e^{dt / T}, T is the time constant in seconds.Note: T = 1 / (2 pi f) where f is the cutoff frequency in Hz, the frequency below which the input starts to attenuate.
This filter is stable for time constants greater than zero.
 Parameters:
timeConstant
 The discretetime time constant in seconds.period
 The period in seconds between samples taken by the user. Returns:
 Linear filter.

movingAverage
Creates a Ktap FIR moving average filter of the form: y[n] = 1/k (x[k] + x[k1] + ... + x[0]).This filter is always stable.
 Parameters:
taps
 The number of samples to average over. Higher = smoother but slower. Returns:
 Linear filter.
 Throws:
IllegalArgumentException
 if number of taps is less than 1.

finiteDifference
Creates a finite difference filter that computes the nth derivative of the input given the specified stencil points.Stencil points are the indices of the samples to use in the finite difference. 0 is the current sample, 1 is the previous sample, 2 is the sample before that, etc. Don't use positive stencil points (samples from the future) if the LinearFilter will be used for streambased online filtering (e.g., taking derivative of encoder samples in realtime).
 Parameters:
derivative
 The order of the derivative to compute.stencil
 List of stencil points. Its length is the number of samples to use to compute the given derivative. This must be one more than the order of the derivative or higher.period
 The period in seconds between samples taken by the user. Returns:
 Linear filter.
 Throws:
IllegalArgumentException
 if derivative < 1, samples <= 0, or derivative >= samples.

backwardFiniteDifference
Creates a backward finite difference filter that computes the nth derivative of the input given the specified number of samples.For example, a first derivative filter that uses two samples and a sample period of 20 ms would be
LinearFilter.backwardFiniteDifference(1, 2, 0.02);
 Parameters:
derivative
 The order of the derivative to compute.samples
 The number of samples to use to compute the given derivative. This must be one more than the order of derivative or higher.period
 The period in seconds between samples taken by the user. Returns:
 Linear filter.

reset
Reset the filter state. 
calculate
Calculates the next value of the filter. Parameters:
input
 Current input value. Returns:
 The filtered value at this step
