manual/c_lfi0/c_lfi0.tex

%$Header: /home/dashley/cvsrep/uculib01/uculib01/doc/manual/c_lfi0/c_lfi0.tex,v 1.10 2010/02/24 19:37:49 dashley Exp $

\chapter{Linear Filter Functions}

\label{clfi0}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Introduction and Overview}
%Section tag:  iov0
\label{clfi0:siov0}

This chapter describes functions that approximate linear filters.
Here, \emph{linear} filter means a filter which satisfies
additive and homogeneity properties.

In order to satisfy the additive property, given two input signals $x_1(k)$ and $x_2(k)$, $\forall k>0$:

\begin{equation}
\label{eq:clfi0:siov0:01}
y(x_1(k) + x_2(k)) = y(x_1(k)) + y(x_2(k)).
\end{equation}

\noindent{}In order to satisfy the homogeneity property,

\begin{equation}
\label{eq:clfi0:siov0:02}
y(\alpha x_1(k)) = \alpha y(x_1(k)).
\end{equation}

\noindent{}A filter that does not satisfy both
(\ref{eq:clfi0:siov0:01}) and (\ref{eq:clfi0:siov0:02}) is by 
definition a non-linear filter (see Chapter
\ref{cnfi0}, p. \pageref{cnfi0}).

It is hard to find appropriate names for linear filters (especially if
filters differ from each other only in precision of arithmetic or the
size and range of input arguments), so for now the filters
are simply named using letters of the alphabet (\emph{Linear Filter A}, for 
example).


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Linear Filter A}
%Section tag:  lfa0
\label{clfi0:slfa0}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Design}
%Subsection tag:  dsn0
\label{clfi0:slfa0:dsn0}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{General Design}

\emph{Linear Filter A} approximates the
discrete time difference equation

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:01}
y_{k} = \frac{2^{16}-h}{2^{16}}x_k + \frac{h}{2^{16}}y_{k-1},
\end{equation}

\noindent{}where $x_k$ is the input and $y_k$ is the output
of the filter at discrete time $k$.
$h$ specifies the ``stiffness'' of the filter---a 
larger value of $h$ causes the filter to attenuate high frequencies more
aggressively.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{Design Equivalence}

In technical discussions, a filter of the design

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:01a}
y_{k} = y_{k-1} + \frac{x_k - y_{k-1}}{c}
\end{equation}

\noindent{}was discussed, where $c$ specifies the
stiffness of the filter.

(\ref{eq:clfi0:slfa0:dsn0:01a}) can be rearranged to

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:01b}
y_{k} = 
x_k \left( \frac{1}{c} \right)
+ y_{k-1} \left( {1-\frac{1}{c}} \right).
\end{equation}

\noindent{}It can be seen by comparing 
(\ref{eq:clfi0:slfa0:dsn0:01}) with 
(\ref{eq:clfi0:slfa0:dsn0:01b}) that the substitution 

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:01c}
c = \frac{1}{1-h/2^{16}}
\end{equation}

\noindent{}equates (\ref{eq:clfi0:slfa0:dsn0:01}) with 
(\ref{eq:clfi0:slfa0:dsn0:01b}), i.e. the filter described  by 
(\ref{eq:clfi0:slfa0:dsn0:01}) and the filter 
described by (\ref{eq:clfi0:slfa0:dsn0:01b}) are 
mathematically equivalent.

(\ref{eq:clfi0:slfa0:dsn0:01c}) can also be solved for $h$:

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:01d}
h = 2^{16}\left( 1 - \frac{1}{c} \right).
\end{equation}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{Time Constant}

The filter time constant $\tau$ can be expressed as

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:02}
\tau = \frac{h \Delta t}{2^{16} - h} ,
\end{equation}

\noindent{}where $\Delta t$ is the discrete time interval.%
\footnote{(\ref{eq:clfi0:slfa0:dsn0:02}) comes from the
\emph{Discrete-time realization} section of the Wikipedia 
entry on low-pass filters \cite{bibref:w:wikipedialowpassfilter}---at this
time I do not
know how it is derived.}

Alternatively, (\ref{eq:clfi0:slfa0:dsn0:02}) may be solved for $h$:

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:03}
h = \frac{2^{16} \tau}{\Delta t + \tau} .
\end{equation}

For example, at 100Hz ($\Delta t$=0.01 seconds) with a desired time constant
of 100ms ($\tau$=0.1 seconds), the required value of $h$ is:

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:04}
h = \frac{(65536) (0.1)}{0.01 + 0.1} =  59578 .
\end{equation}

\begin{table}
\caption{Values of $h$ for Common Choices of $\Delta t$ and $\tau$}
\label{tbl:clfi0:slfa0:dsn0:01}
\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
               & \small{$f$=100Hz}       & \small{$f$=400Hz}         & \small{$f$=1000Hz}             \\
\small{$\tau$} & \small{$\Delta t$=0.01} & \small{$\Delta t$=0.0025} & \small{$\Delta t$=0.001}       \\
\hline
\hline
\small{0.01}   & \small{32,768}          & \small{52,429}            & \small{59,578}                 \\
\hline
\small{0.05}   & \small{54,613}          & \small{62,415}            & \small{64,251}                 \\
\hline
\small{0.1}    & \small{59,578}          & \small{63,938}            & \small{64,887}                 \\
\hline
\small{0.2}    & \small{62,415}          & \small{64,727}            & \small{65,210}                 \\
\hline
\small{0.3}    & \small{63,422}          & \small{64,994}            & \small{65,318}                 \\
\hline
\small{0.4}    & \small{63,938}          & \small{65,129}            & \small{65,373}                 \\
\hline
\small{0.5}    & \small{64,251}          & \small{65,210}            & \small{65,405}                 \\
\hline
\small{1.0}    & \small{64,887}          & \small{65,373}            & \small{65,470}                 \\
\hline
\end{tabular}
\end{center}
\end{table}

Table \ref{tbl:clfi0:slfa0:dsn0:01} provides the correct values of $h$ for common
choices of $\Delta t$ and $\tau$.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{Numeric Implementation}

The software uses large integers to implement the filter.  The filter state
($y_k$) is implemented as a 48-bit fixed-point integer with the radix point after the first 
16 bits.  An upper-case ``y'' ($Y_k$ rather than $y_k$) is used to denote the 
48-bit integer corresponding to $y_k$.

The implementation of the filter can be described by the following steps:

\begin{enumerate}
\item $Y_k$ is calculated:
      \begin{equation}
      \label{eq:clfi0:slfa0:dsn0:05}
      Y_k = \left\lfloor \frac{2^{32}(2^{16}-h)x_k + h Y_{k-1}}{2^{16}} \right\rfloor .
      \end{equation}
\item $y_k$ is calculated from $Y_k$:
      \begin{equation}
      \label{eq:clfi0:slfa0:dsn0:06}
      y_k = \left\lfloor \frac{Y_k + 2^{31}}{2^{32}} \right\rfloor .
      \end{equation}
\end{enumerate}

The steps are implemented differently than directly suggested by
(\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}).  For example, 
the division by $2^{16}$ and the floor function
in (\ref{eq:clfi0:slfa0:dsn0:05}) are implemented by discarding the last two bytes of
an integer multiplication.  As a second example, the 
addition of $2^{31}$ and the floor function in (\ref{eq:clfi0:slfa0:dsn0:06}) are implemented
by testing bit 31 of $Y_k$ and conditionally incrementing $y_k$ rather than by adding.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{Overflow}

It needs to be verified that the filter cannot state $Y_k$ cannot overflow
(exceed $2^{48}-1$).
In order overflow to occur, the numerator of
(\ref{eq:clfi0:slfa0:dsn0:05}) would have to reach $2^{64}$\@.  Guaranteeing that the
filter cannot overflow is equivalent to guaranteeing that $\forall h$,
$\forall x_k$, $\forall Y_{k-1}$:

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:10}
2^{32}(2^{16}-h)x_k + h Y_{k-1} < 2^{64} .
\end{equation}

We can substitute the worst cases of $x_k = 2^{16}-1$ and $Y_{k-1} = 2^{48}-1$ into
(\ref{eq:clfi0:slfa0:dsn0:10}):

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:11}
2^{48}(2^{16}-1) + (2^{32}-1)h < 2^{64} .
\end{equation}

The worst case of $h=2^{16}-1$ can be substituted into
(\ref{eq:clfi0:slfa0:dsn0:11}) to yield:

\begin{equation}
\label{eq:clfi0:slfa0:dsn0:12}
2^{64} - 2^{32} - 2^{16} + 1 < 2^{64} .
\end{equation}

By inspection, (\ref{eq:clfi0:slfa0:dsn0:12}) is met, so filter overflow is not
possible.

In addition to the analysis above, as part of the unit test plan, 
the filter was tested extensively to be
sure it could not roll over beyond $Y_k = 2^{48}-1$\@.  

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\paragraph{Convergence}

By \emph{convergence} of the filter I mean that, given enough time with
a constant $x_k$, $y_k$ will reach the same value.

Convergence wasn't formally analyzed (it should be), but there are three
clues that the filter will probably always converge.

\begin{enumerate}
\item In unit testing with typical values of $h$, the filter always converged.
\item In unit testing, one test performed (not in the test plan) was to set
      the initial value of the filter to 65534, the input to $x_k=65535$, and 
      $h=65535$.  The filter output did reach 65535.  The fact that the filter
      will close a gap of $\Delta x_k = 1$ with $h=65535$ implies that the filter will probably
      always converge.
\item In unit testing, a second test performed (not in the test plan) was to
      set the initial value of the filter to 65000, $h=65535$,
      $x_k = 65535$ and to measure the number of discrete time
      quanta required to reach $65535 - (65535-65000)/e = 65338.18$ (i.e.
      to measure the time constant).

      The number of time quanta required can be predicted from
      (\ref{eq:clfi0:slfa0:dsn0:02}) by removing the $\Delta t$ term:

      \begin{equation}
      \label{eq:clfi0:slfa0:dsn0:20}
      n = \frac{h}{2^{16} - h} = \frac{65535}{65536-65535} = 65535.
      \end{equation}

      In testing, this was the exact number of quanta required.  This suggests
      that the precision of the filter (32 bits after the radix point) is
      adequate even with the largest valid $h$.
\end{enumerate}

Convergence should still be formally analyzed.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection[\emph{UcuLfU16FiltAInitRxn(\protect\mbox{\protect$\cdot$})}]
           {\emph{UcuLfU16FiltAInitRxn(\protect\mbox{\protect\boldmath $\cdot$})}}
%Section tag:  lcp0
\label{clfi0:slai0}

\index{UcuLfU16FiltAInitRxn()@\emph{UcuLfU16FiltAInitRxn($\cdot$)}}%

\noindent\textbf{PROTOTYPE}
\begin {list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item
\begin{verbatim}
void UcuLfU16FiltAInitRxn(UCU_UNION48 *in_fs,
                          UCU_UINT16   in_x_k_initial)
\end{verbatim}
\end{list}
\vspace{2.8ex}

\noindent\textbf{SYNOPSIS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item Initializes the state \texttt{in\_fs} of a Linear Filter A
      to the passed value \texttt{in\_x\_k\_initial}.  This consists of
      setting the most significant two bytes of the state to \texttt{in\_x\_k\_initial}
      and the least significant four bytes to zero.
\item This function is typically used to either:
      \begin{itemize}
      \item Set the filter state to be the same as the input value (for example,
            at software startup).
      \item Eliminate filtering lag on a one-time basis and cause the filter output to track a step jump
            in the filter input (for example, when the software makes a major mode change
            or wishes to produce a step jump in output).
      \end{itemize}
\end{list}
\vspace{2.8ex}

\noindent\textbf{INPUTS}
\begin{list}{}{\setlength{\leftmargin}{0.5in}\setlength{\itemindent}{-0.25in}\setlength{\topsep}{0.0in}\setlength{\partopsep}{0.0in}}
\item \emph{\textbf{in\_fs}}\\
      The filter state.
\item \emph{\textbf{in\_x\_k\_initial}}\\
      The value to initialize the filter state to.
\end{list}
\vspace{2.8ex}

\noindent\textbf{OUTPUTS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item None.
\end{list}
\vspace{2.8ex}

\noindent\textbf{INTERRUPT CONSIDERATIONS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item This function can be used from both ISR and non-ISR software.
\item This function does not ensure atomic access to \texttt{in\_fs}, so it is
      not thread-safe when processes in different threads use this function
      to access the \emph{same} filter state.
\end{list}
\vspace{2.8ex}

\noindent\textbf{EXECUTION TIME}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item TBD.
\end{list}
\vspace{2.8ex}

\noindent\textbf{FUNCTION NAME MNEMONIC}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item \emph{U16}:    the data type to be filtered is UCU\_UINT16.
      \emph{FiltA}:  Linear Filter A.
      \emph{Init}:   initialize.
\end{list}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection[\emph{UcuLfU16FiltAFiltRxn(\protect\mbox{\protect$\cdot$})}]
           {\emph{UcuLfU16FiltAFiltRxn(\protect\mbox{\protect\boldmath $\cdot$})}}
%Section tag:  lcp0
\label{clfi0:slaf0}

\index{UcuLfU16FiltAFiltRxn()@\emph{UcuLfU16FiltAFiltRxn($\cdot$)}}%

\noindent\textbf{PROTOTYPE}
\begin {list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item
\begin{verbatim}
UCU_UINT16 UcuLfU16FiltAFiltRxn(
                               UCU_UNION48 *in_fs, 
                               UCU_UINT16   in_x_k, 
                               UCU_UINT16   in_h
                               )
\end{verbatim}
\end{list}
\vspace{2.8ex}

\noindent\textbf{SYNOPSIS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item Filters the data input \texttt{in\_x\_k} using the specified
      time constant specifier \texttt{in\_h} and filter state
      \texttt{in\_fs}, and returns the filtered value.
      The filtering applied is defined by 
      (\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}).
\end{list}
\vspace{2.8ex}

\noindent\textbf{INPUTS}
\begin{list}{}{\setlength{\leftmargin}{0.5in}\setlength{\itemindent}{-0.25in}\setlength{\topsep}{0.0in}\setlength{\partopsep}{0.0in}}
\item \emph{\textbf{in\_fs}}\\
      The filter state.
\item \emph{\textbf{in\_x\_k}}\\
      The input value to be filtered (i.e. $x_k$).
\item \emph{\textbf{in\_h}}\\
      The time constant of the filter as defined by (\ref{eq:clfi0:slfa0:dsn0:03}).
\end{list}
\vspace{2.8ex}

\noindent\textbf{OUTPUTS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item The filtered value, as defined by 
      (\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}).
\end{list}
\vspace{2.8ex}

\noindent\textbf{USAGE NOTES}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item The filter state is a fixed-point number, and this function
      implements a simple difference equation.  It is safe to modify
      $h$ on the fly without unexpected effects (although this would be very 
      rare, as most applications would always apply the same time constant to
      a given filter state).  There is no state retained beyond the filter state block
      and no requirement
      that $h$ be the same value on every function call involving the same filter
      state block.
\end{list}
\vspace{2.8ex}

\noindent\textbf{INTERRUPT CONSIDERATIONS}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item This function can be used from both ISR and non-ISR software.
\item This function does not ensure atomic access to \texttt{in\_fs}, so it is
      not thread-safe when processes in different threads use this function
      to access the \emph{same} filter state.
\end{list}
\vspace{2.8ex}

\noindent\textbf{EXECUTION TIME}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item TBD.
\end{list}
\vspace{2.8ex}

\noindent\textbf{FUNCTION NAME MNEMONIC}
\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
\item \emph{U16}:    the data type to be filtered is UCU\_UINT16.
      \emph{FiltA}:  Linear Filter A.
      \emph{Filt}:   filter.
\end{list}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\noindent\begin{figure}[!b]
\noindent\rule[-0.25in]{\textwidth}{1pt}
\begin{tiny}
\begin{verbatim}
$RCSfile: c_lfi0.tex,v $
$Source: /home/dashley/cvsrep/uculib01/uculib01/doc/manual/c_lfi0/c_lfi0.tex,v $
$Revision: 1.10 $
$Author: dashley $
$Date: 2010/02/24 19:37:49 $
\end{verbatim}
\end{tiny}
\noindent\rule[0.25in]{\textwidth}{1pt}
\end{figure}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%$Log: c_lfi0.tex,v $
%Revision 1.10  2010/02/24 19:37:49  dashley
%Linear Filter A documentation corrected and enhanced.
%
%Revision 1.9  2010/01/28 21:18:32  dashley
%a)Chapter start quotes removed.
%b)Aesthetic comment line added at the bottom of most files.
%
%Revision 1.8  2010/01/28 02:45:46  dashley
%Information about Linear Filter A completed.
%
%Revision 1.7  2010/01/27 16:08:53  dashley
%Formatting difficulties corrected.
%
%Revision 1.6  2010/01/27 16:04:16  dashley
%Formatting difficulty corrections.
%
%Revision 1.5  2010/01/27 00:26:33  dashley
%Name change of Linear Filter A functions.
%
%Revision 1.4  2010/01/26 21:49:44  dashley
%Edits.
%
%Revision 1.3  2010/01/26 21:10:26  dashley
%Linear Filter A design section completed.
%
%Revision 1.2  2010/01/24 05:40:22  dashley
%Minor title changes.
%
%Revision 1.1  2010/01/24 05:38:26  dashley
%Initial checkin.
%End of $RCSfile: c_lfi0.tex,v $.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

1	%$Header: /home/dashley/cvsrep/uculib01/uculib01/doc/manual/c_lfi0/c_lfi0.tex,v 1.10 2010/02/24 19:37:49 dashley Exp $
2
3	\chapter{Linear Filter Functions}
4
5	\label{clfi0}
6
7	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10	\section{Introduction and Overview}
11	%Section tag: iov0
12	\label{clfi0:siov0}
13
14	This chapter describes functions that approximate linear filters.
15	Here, \emph{linear} filter means a filter which satisfies
16	additive and homogeneity properties.
17
18	In order to satisfy the additive property, given two input signals $x_1(k)$ and $x_2(k)$, $\forall k>0$:
19
20	\begin{equation}
21	\label{eq:clfi0:siov0:01}
22	y(x_1(k) + x_2(k)) = y(x_1(k)) + y(x_2(k)).
23	\end{equation}
24
25	\noindent{}In order to satisfy the homogeneity property,
26
27	\begin{equation}
28	\label{eq:clfi0:siov0:02}
29	y(\alpha x_1(k)) = \alpha y(x_1(k)).
30	\end{equation}
31
32	\noindent{}A filter that does not satisfy both
33	(\ref{eq:clfi0:siov0:01}) and (\ref{eq:clfi0:siov0:02}) is by
34	definition a non-linear filter (see Chapter
35	\ref{cnfi0}, p. \pageref{cnfi0}).
36
37	It is hard to find appropriate names for linear filters (especially if
38	filters differ from each other only in precision of arithmetic or the
39	size and range of input arguments), so for now the filters
40	are simply named using letters of the alphabet (\emph{Linear Filter A}, for
41	example).
42
43
44	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
45	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
46	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
47	\section{Linear Filter A}
48	%Section tag: lfa0
49	\label{clfi0:slfa0}
50
51
52	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
53	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
54	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
55	\subsection{Design}
56	%Subsection tag: dsn0
57	\label{clfi0:slfa0:dsn0}
58
59	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
60
61	\paragraph{General Design}
62
63	\emph{Linear Filter A} approximates the
64	discrete time difference equation
65
66	\begin{equation}
67	\label{eq:clfi0:slfa0:dsn0:01}
68	y_{k} = \frac{2^{16}-h}{2^{16}}x_k + \frac{h}{2^{16}}y_{k-1},
69	\end{equation}
70
71	\noindent{}where $x_k$ is the input and $y_k$ is the output
72	of the filter at discrete time $k$.
73	$h$ specifies the ``stiffness'' of the filter---a
74	larger value of $h$ causes the filter to attenuate high frequencies more
75	aggressively.
76
77	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
78
79	\paragraph{Design Equivalence}
80
81	In technical discussions, a filter of the design
82
83	\begin{equation}
84	\label{eq:clfi0:slfa0:dsn0:01a}
85	y_{k} = y_{k-1} + \frac{x_k - y_{k-1}}{c}
86	\end{equation}
87
88	\noindent{}was discussed, where $c$ specifies the
89	stiffness of the filter.
90
91	(\ref{eq:clfi0:slfa0:dsn0:01a}) can be rearranged to
92
93	\begin{equation}
94	\label{eq:clfi0:slfa0:dsn0:01b}
95	y_{k} =
96	x_k \left( \frac{1}{c} \right)
97	+ y_{k-1} \left( {1-\frac{1}{c}} \right).
98	\end{equation}
99
100	\noindent{}It can be seen by comparing
101	(\ref{eq:clfi0:slfa0:dsn0:01}) with
102	(\ref{eq:clfi0:slfa0:dsn0:01b}) that the substitution
103
104	\begin{equation}
105	\label{eq:clfi0:slfa0:dsn0:01c}
106	c = \frac{1}{1-h/2^{16}}
107	\end{equation}
108
109	\noindent{}equates (\ref{eq:clfi0:slfa0:dsn0:01}) with
110	(\ref{eq:clfi0:slfa0:dsn0:01b}), i.e. the filter described by
111	(\ref{eq:clfi0:slfa0:dsn0:01}) and the filter
112	described by (\ref{eq:clfi0:slfa0:dsn0:01b}) are
113	mathematically equivalent.
114
115	(\ref{eq:clfi0:slfa0:dsn0:01c}) can also be solved for $h$:
116
117	\begin{equation}
118	\label{eq:clfi0:slfa0:dsn0:01d}
119	h = 2^{16}\left( 1 - \frac{1}{c} \right).
120	\end{equation}
121
122	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
123
124	\paragraph{Time Constant}
125
126	The filter time constant $\tau$ can be expressed as
127
128	\begin{equation}
129	\label{eq:clfi0:slfa0:dsn0:02}
130	\tau = \frac{h \Delta t}{2^{16} - h} ,
131	\end{equation}
132
133	\noindent{}where $\Delta t$ is the discrete time interval.%
134	\footnote{(\ref{eq:clfi0:slfa0:dsn0:02}) comes from the
135	\emph{Discrete-time realization} section of the Wikipedia
136	entry on low-pass filters \cite{bibref:w:wikipedialowpassfilter}---at this
137	time I do not
138	know how it is derived.}
139
140	Alternatively, (\ref{eq:clfi0:slfa0:dsn0:02}) may be solved for $h$:
141
142	\begin{equation}
143	\label{eq:clfi0:slfa0:dsn0:03}
144	h = \frac{2^{16} \tau}{\Delta t + \tau} .
145	\end{equation}
146
147	For example, at 100Hz ($\Delta t$=0.01 seconds) with a desired time constant
148	of 100ms ($\tau$=0.1 seconds), the required value of $h$ is:
149
150	\begin{equation}
151	\label{eq:clfi0:slfa0:dsn0:04}
152	h = \frac{(65536) (0.1)}{0.01 + 0.1} = 59578 .
153	\end{equation}
154
155	\begin{table}
156	\caption{Values of $h$ for Common Choices of $\Delta t$ and $\tau$}
157	\label{tbl:clfi0:slfa0:dsn0:01}
158	\begin{center}
159	\begin{tabular}{\|c\|c\|c\|c\|}
160	\hline
161	& \small{$f$=100Hz} & \small{$f$=400Hz} & \small{$f$=1000Hz} \\
162	\small{$\tau$} & \small{$\Delta t$=0.01} & \small{$\Delta t$=0.0025} & \small{$\Delta t$=0.001} \\
163	\hline
164	\hline
165	\small{0.01} & \small{32,768} & \small{52,429} & \small{59,578} \\
166	\hline
167	\small{0.05} & \small{54,613} & \small{62,415} & \small{64,251} \\
168	\hline
169	\small{0.1} & \small{59,578} & \small{63,938} & \small{64,887} \\
170	\hline
171	\small{0.2} & \small{62,415} & \small{64,727} & \small{65,210} \\
172	\hline
173	\small{0.3} & \small{63,422} & \small{64,994} & \small{65,318} \\
174	\hline
175	\small{0.4} & \small{63,938} & \small{65,129} & \small{65,373} \\
176	\hline
177	\small{0.5} & \small{64,251} & \small{65,210} & \small{65,405} \\
178	\hline
179	\small{1.0} & \small{64,887} & \small{65,373} & \small{65,470} \\
180	\hline
181	\end{tabular}
182	\end{center}
183	\end{table}
184
185	Table \ref{tbl:clfi0:slfa0:dsn0:01} provides the correct values of $h$ for common
186	choices of $\Delta t$ and $\tau$.
187
188	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
189
190	\paragraph{Numeric Implementation}
191
192	The software uses large integers to implement the filter. The filter state
193	($y_k$) is implemented as a 48-bit fixed-point integer with the radix point after the first
194	16 bits. An upper-case ``y'' ($Y_k$ rather than $y_k$) is used to denote the
195	48-bit integer corresponding to $y_k$.
196
197	The implementation of the filter can be described by the following steps:
198
199	\begin{enumerate}
200	\item $Y_k$ is calculated:
201	\begin{equation}
202	\label{eq:clfi0:slfa0:dsn0:05}
203	Y_k = \left\lfloor \frac{2^{32}(2^{16}-h)x_k + h Y_{k-1}}{2^{16}} \right\rfloor .
204	\end{equation}
205	\item $y_k$ is calculated from $Y_k$:
206	\begin{equation}
207	\label{eq:clfi0:slfa0:dsn0:06}
208	y_k = \left\lfloor \frac{Y_k + 2^{31}}{2^{32}} \right\rfloor .
209	\end{equation}
210	\end{enumerate}
211
212	The steps are implemented differently than directly suggested by
213	(\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}). For example,
214	the division by $2^{16}$ and the floor function
215	in (\ref{eq:clfi0:slfa0:dsn0:05}) are implemented by discarding the last two bytes of
216	an integer multiplication. As a second example, the
217	addition of $2^{31}$ and the floor function in (\ref{eq:clfi0:slfa0:dsn0:06}) are implemented
218	by testing bit 31 of $Y_k$ and conditionally incrementing $y_k$ rather than by adding.
219
220	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
221
222	\paragraph{Overflow}
223
224	It needs to be verified that the filter cannot state $Y_k$ cannot overflow
225	(exceed $2^{48}-1$).
226	In order overflow to occur, the numerator of
227	(\ref{eq:clfi0:slfa0:dsn0:05}) would have to reach $2^{64}$\@. Guaranteeing that the
228	filter cannot overflow is equivalent to guaranteeing that $\forall h$,
229	$\forall x_k$, $\forall Y_{k-1}$:
230
231	\begin{equation}
232	\label{eq:clfi0:slfa0:dsn0:10}
233	2^{32}(2^{16}-h)x_k + h Y_{k-1} < 2^{64} .
234	\end{equation}
235
236	We can substitute the worst cases of $x_k = 2^{16}-1$ and $Y_{k-1} = 2^{48}-1$ into
237	(\ref{eq:clfi0:slfa0:dsn0:10}):
238
239	\begin{equation}
240	\label{eq:clfi0:slfa0:dsn0:11}
241	2^{48}(2^{16}-1) + (2^{32}-1)h < 2^{64} .
242	\end{equation}
243
244	The worst case of $h=2^{16}-1$ can be substituted into
245	(\ref{eq:clfi0:slfa0:dsn0:11}) to yield:
246
247	\begin{equation}
248	\label{eq:clfi0:slfa0:dsn0:12}
249	2^{64} - 2^{32} - 2^{16} + 1 < 2^{64} .
250	\end{equation}
251
252	By inspection, (\ref{eq:clfi0:slfa0:dsn0:12}) is met, so filter overflow is not
253	possible.
254
255	In addition to the analysis above, as part of the unit test plan,
256	the filter was tested extensively to be
257	sure it could not roll over beyond $Y_k = 2^{48}-1$\@.
258
259	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
260
261	\paragraph{Convergence}
262
263	By \emph{convergence} of the filter I mean that, given enough time with
264	a constant $x_k$, $y_k$ will reach the same value.
265
266	Convergence wasn't formally analyzed (it should be), but there are three
267	clues that the filter will probably always converge.
268
269	\begin{enumerate}
270	\item In unit testing with typical values of $h$, the filter always converged.
271	\item In unit testing, one test performed (not in the test plan) was to set
272	the initial value of the filter to 65534, the input to $x_k=65535$, and
273	$h=65535$. The filter output did reach 65535. The fact that the filter
274	will close a gap of $\Delta x_k = 1$ with $h=65535$ implies that the filter will probably
275	always converge.
276	\item In unit testing, a second test performed (not in the test plan) was to
277	set the initial value of the filter to 65000, $h=65535$,
278	$x_k = 65535$ and to measure the number of discrete time
279	quanta required to reach $65535 - (65535-65000)/e = 65338.18$ (i.e.
280	to measure the time constant).
281
282	The number of time quanta required can be predicted from
283	(\ref{eq:clfi0:slfa0:dsn0:02}) by removing the $\Delta t$ term:
284
285	\begin{equation}
286	\label{eq:clfi0:slfa0:dsn0:20}
287	n = \frac{h}{2^{16} - h} = \frac{65535}{65536-65535} = 65535.
288	\end{equation}
289
290	In testing, this was the exact number of quanta required. This suggests
291	that the precision of the filter (32 bits after the radix point) is
292	adequate even with the largest valid $h$.
293	\end{enumerate}
294
295	Convergence should still be formally analyzed.
296
297
298	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
299	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
300	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
301	\subsection[\emph{UcuLfU16FiltAInitRxn(\protect\mbox{\protect$\cdot$})}]
302	{\emph{UcuLfU16FiltAInitRxn(\protect\mbox{\protect\boldmath $\cdot$})}}
303	%Section tag: lcp0
304	\label{clfi0:slai0}
305
306	\index{UcuLfU16FiltAInitRxn()@\emph{UcuLfU16FiltAInitRxn($\cdot$)}}%
307
308	\noindent\textbf{PROTOTYPE}
309	\begin {list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
310	\item
311	\begin{verbatim}
312	void UcuLfU16FiltAInitRxn(UCU_UNION48 *in_fs,
313	UCU_UINT16 in_x_k_initial)
314	\end{verbatim}
315	\end{list}
316	\vspace{2.8ex}
317
318	\noindent\textbf{SYNOPSIS}
319	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
320	\item Initializes the state \texttt{in\_fs} of a Linear Filter A
321	to the passed value \texttt{in\_x\_k\_initial}. This consists of
322	setting the most significant two bytes of the state to \texttt{in\_x\_k\_initial}
323	and the least significant four bytes to zero.
324	\item This function is typically used to either:
325	\begin{itemize}
326	\item Set the filter state to be the same as the input value (for example,
327	at software startup).
328	\item Eliminate filtering lag on a one-time basis and cause the filter output to track a step jump
329	in the filter input (for example, when the software makes a major mode change
330	or wishes to produce a step jump in output).
331	\end{itemize}
332	\end{list}
333	\vspace{2.8ex}
334
335	\noindent\textbf{INPUTS}
336	\begin{list}{}{\setlength{\leftmargin}{0.5in}\setlength{\itemindent}{-0.25in}\setlength{\topsep}{0.0in}\setlength{\partopsep}{0.0in}}
337	\item \emph{\textbf{in\_fs}}\\
338	The filter state.
339	\item \emph{\textbf{in\_x\_k\_initial}}\\
340	The value to initialize the filter state to.
341	\end{list}
342	\vspace{2.8ex}
343
344	\noindent\textbf{OUTPUTS}
345	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
346	\item None.
347	\end{list}
348	\vspace{2.8ex}
349
350	\noindent\textbf{INTERRUPT CONSIDERATIONS}
351	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
352	\item This function can be used from both ISR and non-ISR software.
353	\item This function does not ensure atomic access to \texttt{in\_fs}, so it is
354	not thread-safe when processes in different threads use this function
355	to access the \emph{same} filter state.
356	\end{list}
357	\vspace{2.8ex}
358
359	\noindent\textbf{EXECUTION TIME}
360	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
361	\item TBD.
362	\end{list}
363	\vspace{2.8ex}
364
365	\noindent\textbf{FUNCTION NAME MNEMONIC}
366	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
367	\item \emph{U16}: the data type to be filtered is UCU\_UINT16.
368	\emph{FiltA}: Linear Filter A.
369	\emph{Init}: initialize.
370	\end{list}
371
372	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
373	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
374	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
375	\subsection[\emph{UcuLfU16FiltAFiltRxn(\protect\mbox{\protect$\cdot$})}]
376	{\emph{UcuLfU16FiltAFiltRxn(\protect\mbox{\protect\boldmath $\cdot$})}}
377	%Section tag: lcp0
378	\label{clfi0:slaf0}
379
380	\index{UcuLfU16FiltAFiltRxn()@\emph{UcuLfU16FiltAFiltRxn($\cdot$)}}%
381
382	\noindent\textbf{PROTOTYPE}
383	\begin {list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
384	\item
385	\begin{verbatim}
386	UCU_UINT16 UcuLfU16FiltAFiltRxn(
387	UCU_UNION48 *in_fs,
388	UCU_UINT16 in_x_k,
389	UCU_UINT16 in_h
390	)
391	\end{verbatim}
392	\end{list}
393	\vspace{2.8ex}
394
395	\noindent\textbf{SYNOPSIS}
396	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
397	\item Filters the data input \texttt{in\_x\_k} using the specified
398	time constant specifier \texttt{in\_h} and filter state
399	\texttt{in\_fs}, and returns the filtered value.
400	The filtering applied is defined by
401	(\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}).
402	\end{list}
403	\vspace{2.8ex}
404
405	\noindent\textbf{INPUTS}
406	\begin{list}{}{\setlength{\leftmargin}{0.5in}\setlength{\itemindent}{-0.25in}\setlength{\topsep}{0.0in}\setlength{\partopsep}{0.0in}}
407	\item \emph{\textbf{in\_fs}}\\
408	The filter state.
409	\item \emph{\textbf{in\_x\_k}}\\
410	The input value to be filtered (i.e. $x_k$).
411	\item \emph{\textbf{in\_h}}\\
412	The time constant of the filter as defined by (\ref{eq:clfi0:slfa0:dsn0:03}).
413	\end{list}
414	\vspace{2.8ex}
415
416	\noindent\textbf{OUTPUTS}
417	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
418	\item The filtered value, as defined by
419	(\ref{eq:clfi0:slfa0:dsn0:05}) and (\ref{eq:clfi0:slfa0:dsn0:06}).
420	\end{list}
421	\vspace{2.8ex}
422
423	\noindent\textbf{USAGE NOTES}
424	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
425	\item The filter state is a fixed-point number, and this function
426	implements a simple difference equation. It is safe to modify
427	$h$ on the fly without unexpected effects (although this would be very
428	rare, as most applications would always apply the same time constant to
429	a given filter state). There is no state retained beyond the filter state block
430	and no requirement
431	that $h$ be the same value on every function call involving the same filter
432	state block.
433	\end{list}
434	\vspace{2.8ex}
435
436	\noindent\textbf{INTERRUPT CONSIDERATIONS}
437	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
438	\item This function can be used from both ISR and non-ISR software.
439	\item This function does not ensure atomic access to \texttt{in\_fs}, so it is
440	not thread-safe when processes in different threads use this function
441	to access the \emph{same} filter state.
442	\end{list}
443	\vspace{2.8ex}
444
445	\noindent\textbf{EXECUTION TIME}
446	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
447	\item TBD.
448	\end{list}
449	\vspace{2.8ex}
450
451	\noindent\textbf{FUNCTION NAME MNEMONIC}
452	\begin{list}{}{\setlength{\leftmargin}{0.25in}\setlength{\topsep}{0.0in}}
453	\item \emph{U16}: the data type to be filtered is UCU\_UINT16.
454	\emph{FiltA}: Linear Filter A.
455	\emph{Filt}: filter.
456	\end{list}
457
458
459	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
460	\noindent\begin{figure}[!b]
461	\noindent\rule[-0.25in]{\textwidth}{1pt}
462	\begin{tiny}
463	\begin{verbatim}
464	$RCSfile: c_lfi0.tex,v $
465	$Source: /home/dashley/cvsrep/uculib01/uculib01/doc/manual/c_lfi0/c_lfi0.tex,v $
466	$Revision: 1.10 $
467	$Author: dashley $
468	$Date: 2010/02/24 19:37:49 $
469	\end{verbatim}
470	\end{tiny}
471	\noindent\rule[0.25in]{\textwidth}{1pt}
472	\end{figure}
473
474	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
475	%$Log: c_lfi0.tex,v $
476	%Revision 1.10 2010/02/24 19:37:49 dashley
477	%Linear Filter A documentation corrected and enhanced.
478	%
479	%Revision 1.9 2010/01/28 21:18:32 dashley
480	%a)Chapter start quotes removed.
481	%b)Aesthetic comment line added at the bottom of most files.
482	%
483	%Revision 1.8 2010/01/28 02:45:46 dashley
484	%Information about Linear Filter A completed.
485	%
486	%Revision 1.7 2010/01/27 16:08:53 dashley
487	%Formatting difficulties corrected.
488	%
489	%Revision 1.6 2010/01/27 16:04:16 dashley
490	%Formatting difficulty corrections.
491	%
492	%Revision 1.5 2010/01/27 00:26:33 dashley
493	%Name change of Linear Filter A functions.
494	%
495	%Revision 1.4 2010/01/26 21:49:44 dashley
496	%Edits.
497	%
498	%Revision 1.3 2010/01/26 21:10:26 dashley
499	%Linear Filter A design section completed.
500	%
501	%Revision 1.2 2010/01/24 05:40:22 dashley
502	%Minor title changes.
503	%
504	%Revision 1.1 2010/01/24 05:38:26 dashley
505	%Initial checkin.
506	%End of $RCSfile: c_lfi0.tex,v $.
507	%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
508