REAL-TIME DIGITAL SYSTEMS
Improve your root-mean
calculations
By Brian Neunaber
Digital Systems Architect of
Software and Firmware
QSC Audio Products
Real-time digital systems of-
ten require the calculation of a
root-mean, such as a root-mean
square (RMS) level or average
magnitude of a complex signal.
While averaging can be effi-
ciently implemented by most
microprocessors, the square root
may not be--especially with low-
cost hardware. If the processor
doesn’t implement a fast square
root function, it must be imple-
mented in software; although
this yields accurate results, it may
not be efficient.
One common method for com-
puting the square root is Newton’s
method, which iteratively con-
verges on a solution using an initial
estimate. Since we’re computing
the square root of a slowly vary-
ing average value, the previous
root-mean value makes a good
estimate. Furthermore, we can
combine the iterative Newton’s
method with a first-order recursive
averager, resulting in a super-ef-
ficient method for computing the
root-mean of a signal.
In this article, I’ll develop and
present three efficient recur-
sive algorithms for comput-
ing the root-mean, illustrating
each method with signal flow
diagrams and example code.
To some degree, each of these
methods trades hardware com-
plexity for error. I’ll compare the
computational performance and
error of each method and sug-
gest suitable hardware for each
implementation.
Root-Mean
The root-mean is computed as
the square root of the average
over time of its input. This aver-
age may be recursive or non-re-
cursive, and I’ll briefly review the
general case for both.
 eetindia.com | February 2006 | EE Times-India
Non-recursive average
The non-recursive average, or
moving average, is the weighted
sum of N inputs: the current input
and N-1 previous inputs. In digital
filtering terminology, this is called
a finite impulse response, or FIR
filter (Equation 1):
The most common use of the
moving average typically sets
the weights such that an=1/N.
If we were to plot these weights
versus time, we would see the
“window” of the input signal that
is averaged at a given point in
time. This 1/N window is called a
rectangular window because its
shape is an N-by-1/N rectangle.
There is a trick for computing
the 1/N average so that all N
samples need not be weighted
and summed with each output
calculation. Since the weights
don’t change, you can simply
add the newest weighted input
and subtract the Nth weighted
input from the previous sum
(Equation 2):
While this technique is com-
putationally efficient, it requires
storage and circular-buffer man-
agement of N samples.
Of course, many other win-
dow shapes are commonly used.
Typically, these window shapes
resemble, or are a variation of, a
raised cosine between –π/2 and
π/2. These windows weight the
samples in the centre more than
the samples near the edges. Gen-
erally speaking, you should only
use one of these windows when
there is a specific need to, such
as applying a specific filter to the
signal. The disadvantage of these
windows is that computational
complexity and storage require-
ments increase with N.
Recursive average
The recursive average is the
weighted sum of the input, N
previous inputs, and M previous
outputs (Equation 3):
The simplest of these in
terms of computational com-
plexity and storage (while still
being useful) is the first-order
recursive average. In this case,
the average is computed as the
weighted sum of the current
input and the previous output.
The first-order recursive average
also lends itself to an optimisa-
tion when combined with the
computation of the square root,
which we’ll discuss shortly.
In contrast to the non-re-
cursive average, the first-order
recursive average’s window is a
decaying exponential (Figure 1).
Technically, the recursive average
has an infinite window, since it
never decays all the way to zero.
In digital filtering terminology,
this is known as an infinite im-
pulse response, or IIR filter.
From Figure 1, we see that
earlier samples are weighted
more than later samples, allowing
us to somewhat arbitrarily define
an averaging time for the recur-
sive average. For the first-order
case, we define the averaging
time as the time at which the
impulse response has decayed to
a factor of 1/e, or approximately
37%, of its initial value. An equiva-
lent definition is the time at
which the step response reaches
1–(1/e), or approximately 63%, of
its final value. Other definitions
are possible but will not be cov-
ered here. The weighting of the
sum determines this averaging
time; to ensure unity gain, the
sum of the weights must equal
one. As a consequence, only one
coefficient needs to be specified
to describe the averaging time.
 Therefore, for first-order recur-
sive averaging, we compute the
mean level as (Equation 4):
where x(n) is the input, m(n)
is the mean value, and a is the
averaging coefficient. The aver-
aging coefficient is defined as
(Equation 5):
where t is the averaging time,
and fS is the sampling frequency.
The root-mean may then be
calculated by taking the square
root of Equation 4 (Equation 6,
where y(n) is the root-mean):
Equation 6
Efficient computation methods
Googling “fast square root” will
get you a plethora of informa-
tion and code snippets on im-
plementing fast square-root al-
gorithms. While these methods
may work just fine, they don’t
take into account the applica-
tion in which the square root
is required. Oftentimes, you
may not need exact precision
to the last bit, or the algorithm
itself can be manipulated to
optimise the computation of
the square root. I present a few
basic approaches here.
Only calculate it
when you need it
Probably the simplest optimisa-
tion is to only calculate the square
root when you absolutely need it.
Although this may seem obvious,
it can be easily overlooked when
computing the root-mean on ev-
ery input sample. When you don’t
need an output value for every in-
put sample, it makes more sense
to compute the square root only
when you read the output value.
One example of an application
 eetindia.com | February 2006 | EE Times-India
when this technique can be used
is RMS metering of a signal. A
meter value that is displayed visu-
ally may only require an update
every 50 to 100ms, which may
be far less often than the input
signal is sampled. Keep in mind,
however, that recursive averag-
ing should still be computed at
the Nyquist rate.
Logarithms
Recall that (Equation 7):
If you’ll be computing the
logarithm of a square root, it’s
far less computationally expen-
sive to simply halve the result
instead. A common example of
this optimisation is the calcula-
tion of an RMS level in dB, which
may be simplified as follows
(Equation 8):
Newton’s Method
Newton’s Method (also called
the Newton-Rapson Method) is a
well known iterative method for
estimating the root of an equa-
tion.1 Newton’s Method can be
quite efficient when you have a
reasonable estimate of the result.
Furthermore, if accuracy to the
last bit is not required, the num-
ber of iterations can be fixed to
keep the algorithm deterministic.
We may approximate the root
of f(x) by iteratively calculating
(Equation 9):
If we wish to find ,
then we need to find
the root to the equation f(y)=y2-
m. Substituting f(y) into Equa-
tion 9, we get (Equation 10):
Rearranging Equation 9, we
get (Equation 11):
where y(n) is the approxima-
tion of the square root of m(n).
Equation 11 requires a divide
operation, which may be incon-
venient for some processors. As
an alternative, we can calculate
and multiply the
result by m to get
. Again using Newton’s
Method, we find that we may
iteratively calculate the reciprocal
square root as (Equation 12):
and calculate the square root
as (Equation 13):
Although Newton’s Method
for the reciprocal square root
eliminates the divide operation,
it can be problematic for fixed-
point processors. Assuming
that m(n) is a positive integer
greater than 1, yr(n) will be a
positive number less than one-
-beyond the range of repre-
sentation for integer numbers.
Implementation must be ac-
complished using floating-point
or mixed integer/fractional
number representation.
Root-mean using
Newton’s Method
A subtle difference between
Equations 10 and 11 is that m be-
comes m(n), meaning that we’re
attempting to find the square
root of a moving target. However,
since m(n) is a mean value, or
slowly varying, it can be viewed
as nearly constant between itera-
tions. Since y(n) will also be slowly
varying, y(n-1) will be a good ap-
proximation to y(n) and require
fewer iterations--one, we hope--
to achieve a good estimate.
To calculate the root-mean, one
may simply apply Newton’s Meth-
od for calculating the square root
to the mean value. As long as the
averaging time is long compared
to the sample period (t &62;&62;
1/fS), one iteration of the square
root calculation should suffice for
reasonable accuracy. This seems
simple enough, but we can actu-
ally improve the computational
efficiency, which will be discussed
in one of the following sections.
Using reciprocal square root
Unlike the iterative square-root
method, however, the iterative
reciprocal square-root requires
no divide. This implementation
is best suited for floating-point
processing, which can efficiently
handle numbers both greater
and less than one. We present this
implementation as a signal flow
diagram in Figure 2. The averaging
coefficient, a, is defined by Equa-
tion 5, and z–1 represents a unit
sample delay.
 A code listing for a C++ class
that implements the computa-
tion in Figure 2 is presented in
Listing 1. In this example class,
initialisation is performed in the
class constructor, and each call
to CalcRootMean() performs one
iteration of averaging and square-
root computation.
Listing 1. C++ class that
computes the root-mean using
Newton’s Method for the recipro-
cal square root
static const double Fs =
48000.0; // sample rate
static double AvgTime = 0.1;
// averaging time
class RecipRootMean
{ ficient is required. Note that x(n)
public:
double Mean;
double RecipRootMean;
double AvgCoeff;
RecipRootMean()
{ formed in the class constructor,
AvgCoeff = 1.0 - exp( -1.0
/ (Fs * AvgTime) );
Mean = 0.0;
RecipRootMean =
1.0e-10; // 1 > initial
RecipRootMean > 0
} static const double Fs =
~RecipRootMean() {}
double
CalcRootMean(double x)
{ class NewtonRootMean
Mean += AvgCoeff * (x
- Mean);
RecipRootMean *= 0.5 *
( 3.0 - (RecipRootMean *
RecipRootMean * Mean)
);
return RecipRootMean *
Mean;
} RootMean = 1.0;
};
Using direct square root
Let’s go back and take a closer
look at Equation 11. Newton’s
method converges on the solu-
tion as quickly as possible with-
out oscillating around it, but if we
slow this rate of convergence, the
iterative equation will converge
on the square root of the aver-
age of its inputs. Adding the av-
eraging coefficient results in the
 eetindia.com | February 2006 | EE Times-India
following root-mean equation
(Equation 14):
where a is defined by Equa-
tion 5. Now y(n) converges to
the square root of the average
of x(n). An equivalent signal-flow
representation of Equation 14 is
presented in Figure 3. Here, an
additional y(n–1) term is summed
so that only one averaging coef-
and y(n–1) must be greater than
zero.
A code listing for a C++ class
that implements the computation
shown in Figure 3 is presented
in Listing 2. As in the previous
example, initialisation is per-
and each call to CalcRootMean()
performs one iteration of averag-
ing/square-root computation.
Listing 2. C++ class that
implements the floating-point
version of Figure 3
48000.0; // sample rate
static double AvgTime = 0.1;
// averaging time
{ static const unsigned int
public:
double RootMean;
double AvgCoeff;
NewtonRootMean()
{ eFactor = pow(2.0, (dou
// > 0 or divide will fail
AvgCoeff = 0.5 * ( 1.0
- exp( -1.0 / (Fs * Avg-
Time) ) );
} }
~NewtonRootMean() {}
double
CalcRootMean(double x)
{ unsigned int nRootMean;
RootMean += AvgCoeff *
( ( x / RootMean ) - Root-
Mean );
return RootMean;
}
};
With some care, Figure 3 may
also be implemented in fixed-
point arithmetic as shown in
Listing 3. In this example, scaling
is implemented to ensure valid
results. When sufficient word size
is present, x is scaled by nAvgCo-
eff prior to division to maximise
the precision of the result.
Listing 3. C++ class that
implements the fixed-point ver-
sion of Figure 3
static const double Fs =
48000.0; //
sample rate
static double AvgTime =
0.1; // aver-
aging time
sknNumIntBits = 32; // #
bits in int
static const unsigned int
sknPrecisionBits = sknNu-
mIntBits / 2;
static const double skScal-
ble)sknPrecisionBits);
static const unsigned int
sknRoundOffset =
(unsigned int)floor( 0.5 *
skScaleFactor );
class IntNewtonRootMean
{ nRootMean = ( nScaled-
public:
unsigned int nScaledRoot-
Mean;
unsigned int nAvgCoeff;
unsigned int nMaxVal;
IntNewtonRootMean()
{
nRootMean = 1; // >0
or divide will fail
nScaledRootMean = 0;
double AvgCoeff = 0.5
* ( 1.0 - exp( -1.0 / (Fs *
AvgTime) ) );
nAvgCoeff = (unsigned
int)floor( ( skScaleFactor
* AvgCoeff ) + 0.5 );
nMaxVal = (unsigned
int)floor( ( skScaleFactor
/ AvgCoeff ) + 0.5 );
}
~IntNewtonRootMean() {}
unsigned int
CalcRootMean(unsigned
int x)
{
if ( x < nMaxVal )
{
nScaledRootMean += (
( nAvgCoeff * x ) / nRoot-
Mean ) - ( nAvgCoeff *
nRootMean );
}
else
{
nScaledRootMean +=
nAvgCoeff * ( ( x / nRoot-
Mean ) - nRootMean );
RootMean + sknRound-
Offset ) >> sknPrecision-
Bits;
return nRootMean;
}
};
Divide-free RMS using
normalisation
Now we’ll look at the special
case of computing an RMS
value on fixed-point hardware
that does not have a fast divide
operation, which is typical for
low-cost embedded processors.
Although many of these proces-
sors can perform division, they
do so one bit at a time, requiring
at least one cycle for each bit of
word length. Furthermore, care
must be taken to insure that the
RMS calculation is implemented
with sufficient numerical preci-
sion. With fixed-point hardware,
the square of a value requires
twice the number of bits to retain
the original data’s precision.
With this in mind, we ma-
nipulate Equation 14 into the
following (Equation 15):
Although the expression
x(n)2–y(n–1)2 must be calcu-
lated with double precision, this
implementation lends itself to
a significant optimisation. Note
that a/2y(n–1) acts like a level-
dependent averaging coefficient.
If a slight time-dependent vari-
ance in the averaging time can
be tolerated--which is often the
case--1/y(n–1) can be grossly ap-
proximated. On a floating-point
processor, shifting the averaging
coefficient to the left by the nega-
tive of the exponent approxi-
mates the divide operation. This
process is commonly referred
to as normalisation. Some fixed-
point DSPs can perform normali-
sation by counting the leading
bits of the accumulator and
shifting the accumulator by that
number of bits.2 In both cases,
the averaging coefficient will be
truncated to the nearest power
of two, so the coefficient must
be multiplied by 3/2 to round
the result. This implementation
is shown in Equation 16.
Figure 4 is the signal-flow dia-
gram that represents Equation
16. Just as in Figure 3, x(n) and
 eetindia.com | February 2006 | EE Times-India
y(n–1) must be greater than zero.
A sample code listing that
implements Figure 4 is shown
in Listing 4. This assembly-lan-
guage implementation is for the
Freescale (formerly Motorola)
DSP563xx 24-bit fixed-point
processor.
Listing 4. Freescale DSP563xx
assembly implementation of
divide-free RMS using normali-
sation
RMS
; r4: address of output bits
24-47 [y_msw(n)]
; r4+1: address of output bits
0-23 [y_lsw(n)]
; x0: input [x(n)]
FS equ 48000.0
;sampling rate in Hz
AVG_TIME equ 0.1
;averaging time in
seconds
AVG_COEFF equ @XPN(-
1.0/(FS*AVG_TIME)) ;cal-
culate avg_coeff
move #>AVG_COE
FF,x1 ;load
avg_coeff
move y:(r4)+,a
;get y_msw(n-1)
move y:(r4),a0
;get y_lsw(n-1)
clb a,b
;b=number of leading
bits in y(n-1)
mpy x0,x0,a a,x0
;a=x(n)^2
;x0=y_msw(n-1)
mac -x0,x0,a x0,y1
;a=x(n)^2-y_msw(n-1)^2
;y1=y_msw(n-1)
normf b1,a
;normalize
x(n)^2-y_msw(n-1)^2 by
y_msw(n-1)
move a,x0
;x0=[x(n)^2-
y_msw(n-1)^2]norm(y_
msw(n-1))
mpy x1,x0,a y:(r4),y0
;a= AVG_COEFF
;*[x(n)^2-y_msw(n-
1)^2]norm(y_msw(n-1)),
;y0=y_lsw(n-1)
add y,a
;a=y(n-1)+avg_coeff
;*[x(n)^2-y_msw(n-
1)^2]norm(y_msw(n-1))}
move a0,y:(r4)-
;save y_lsw(n)
move a,y:(r4)
;save y_msw(n)
rts
Of course, this method can be
implemented even without fast
normalisation. You can imple-
ment a loop to shift x(n)2–y(n–1)2
to the left for each leading bit in
y(n–1). This will be slower but can
be implemented with even the
simplest of processors.
Higher Order Averaging
Higher order recursive averag-
ing may be accomplished by
inserting additional averaging
filters before the iterative square
root. These filters may simply be
one or more cascaded first-order
recursive sections. First-order
sections have the advantage of
producing no overshoot in the
step response. In addition, there
is only one coefficient to adjust
and quantisation effects (primar-
ily of concern for fixed-point
implementation) are far less than
that of higher-order filters.
The implementer should be
aware that cascading first-order
sections changes the definition
of averaging time. A simple but
gross approximation that main-
tains the earlier definition of step
response is to simply divide the
averaging time of each first-or-
der section by the total number
of sections. However, it is the
implementer’s responsibility to
verify that this approximation is
suitable for the application.
Second-order sections may
also be used, if you want (for ex-
ample) a Bessel-Thomson filter re-
sponse. If second-order sections
are used, it’s best to choose an
odd-order composite response
since the averaging square-
root filter approximates the final
first-order filter with Q=0.5. Care
must be taken to minimise the
overshoot of this averaging filter.
Adjusting the averaging time of
this filter in real time will prove
more difficult, since there are a
number of coefficients that must
be adjusted in unison to ensure
stability.
Results
Three methods of calculating
the RMS level are compared in
Figure 5. The averaging time is
set to 100ms, and the input is one
second of 1/f noise with a 48kHz
sampling frequency. The first trace
is the true RMS value calculated
using Equation 6. The second
trace is the RMS calculation using
Equation 14. The third trace is the
no-divide calculation of Equation
16. The fourth trace is the RMS
value using the reciprocal square-
root method of Equation 13.
For the most part, the four
traces line up nicely. All four ap-
proximations appear to converge
at the same rate as the true RMS
value. As expected, the largest
deviation from the true RMS value
is the approximation of Equation
16. This approximation will have
the greatest error during large
changes in the level of the input
signal, although this error is tem-
porary: the optimised approxima-
tion will converge upon the true
RMS value when the level of the
input signal is constant.
The errors between the three
approximations and the true
RMS value are shown in Figure 6.
The error of the RMS approxima-
tion using Equation 14 slowly
decreases until it is below 1E–7,
which is sufficient for 24-bit ac-
curacy. The optimised approxi-
mation of Equation 16 is sub-
stantially worse, at about 1E–4,
but still good enough for many
applications. The approximation
that uses the reciprocal square
root is “in the noise”--less than
1E–9. For highly critical floating-
point applications, this is the
efficient method of choice.
As you would expect, the errors
discussed above will be worse with
shorter averaging times and bet-
ter with longer averaging times. aging with Newton’s meth- trades off hardware capabilities Kent, Boston, pp. 170-176,
Table 1 summarises the approxi- od for calculating the square for error, most of you should 1988.
mate error versus averaging time root, you’ll gain a very efficient find one of these methods suit- 2. Motorola. DSP56300 Family
of these three methods, along method for computing the able for your application. Manual, Rev. 3, Motorola Litera-
with suitable hardware architec- root-mean. Although the three ture Distribution, Denver, 2000.
ture requirements. methods I presented here are Endnotes:
Suitable for average reader developed for different hard- 1. D. G. Zill. Calculus with Ana-
By combining recursive aver- ware and each, to some degree, lytic Geometry, 2nd ed., PWS- Email   Send inquiry

 eetindia.com | February 2006 | EE Times-India