In this post, let us discuss a simple implementation friendly scheme for computing the absolute value of a complex number . The technique called (alpha Max + beta Min) algorithm is discussed in Chapter 13.2 of Understanding Digital Signal Processing, Richard Lyons and is also available online at Digital Signal Processing Tricks – High-speed vector magnitude approximation

The magnitude of a complex number is

.

The simplified computation of the absolute value is

where

.

The values of and can be tried out to understand the performance. For analysis we can use a complex number with magnitude 1 and phase from 0 to 180 degrees.

Option#1

= 1, = 1/2,

Option#2

= 1, = 1/4,

Option#3

= 1, = 3/8

Option#4

= 7/8, = 7/16

Option#5

= 15/16, = 15/32

Simulation Model

The script performs the following.

(a) Generate a complex number with phase varying from 0 to 180 degrees.

(b) Find the absolute value using the above 5 options

(c) For each option, find the maximum error, average error and root mean square error

Click here to download Matlab/Octave script for computing the approximate value of magnitude of a complex number

Figure: Plot of approximate value of magnitude of a complex number

Table: Error in the approximate value computation with various values of ,

Observations

1. The chosen values of , facilitates simple multiplier-less implementation of approximate computation (can be implemented using only bit shift and addition).

2. For Options (1),  (3) the maximum error is more than the expected value. Hence we need to allocate extra bits for the output to prevent overflow.

3. The error in the approximate magnitude computation repeats every 90 degrees.

Reference

Chapter 13.2 of Understanding Digital Signal Processing, Richard Lyons

Related posts:

1. Using CORDIC for phase and magnitude computation
2. BER for BPSK in Rayleigh channel
3. Peak to Average Power Ratio for OFDM

In a previous post (here), we looked at using CORDIC (Co-ordinate Rotation by DIgital Computer) for understanding how a complex number can be rotated by an angle without using actual multipliers. Let us know try to understand how we can use CORDIC for finding the phase and magnitude of a complex number.

Basics

The CORDIC algorithm is built on successively multiplying the complex number , by . As can be noticed, as the elements of can be represented in powers of 2, the multiplication can be achieved by using the appropriate ‘bit shift’. For further details, please refer to the previous post (CORDIC for phase rotation).

Finding the magnitude and phase

It is reasonably obvious that the multiplying a complex number by does not change the magnitude of .

Given so, if phase rotation of results in , and the imaginary component of is 0, then the real part of stores the magnitude of .

To put in equations, if

, where ,

then,

(real part of is the magnitude of )

(the rotation angle is the negative of the phase of )

This is the fundamental idea behind finding the magnitude and phase of a complex number using CORDIC.

The sequence of events is as shown below:

(a) The input complex number is subject to a series of phase rotations.

(b) The sign of the phase rotation is the negative of the sign of imaginary component of .

(c) After multiple iterations, imaginary component of tends to zero.

(d) Then, the real part of the new complex vector represents the magnitude and the cumulative phase value represents the negative of the phase of .

Figure: Flow chart for the operations involved in using CORDIC for computing phase and magnitude

The reference phase (phase of ).

The scaling factor of 1.64676025786545 is to remove the ‘gain’ following successive rotations by . Please look at the previous post on CORDIC (here) for details.

Note:

If the input complex number lies in the second or third quadrant, it needs to be first shifted to the first/fourth quadrant before we start the sequence of events shown in the figure above (as the CORDIC range is limited to around +/-90 degrees). This can be achieved by multiplication by or , as appropriate.

Simulation model

Simple Matlab/Octave script for computing the phase and magnitude of a complex number using the CORDIC approach. Quick comparison indicate that the computed and acutal values are closely matching.

Click here to dowload
Reference

[DSPGURU-CORDIC] CORDIC FAQ in dspGuru(TM)

Hope this helps.

Krishna

Related posts:

1. CORDIC for phase rotation
2. Approximate Vector Magnitude Computation
3. Negative Frequency

My understanding of the CORDIC (Co-ordinate Rotation by DIgital Computer) thanks to the nice article in [DSPGURU-CORDIC].

The idea is that rotation of a complex number by an angle can be achieved without using multipliers. The phase angle is approximately equal to successive addition or subtraction of angles from a set of reference angles i.e. , where

,

is the set of reference angles,

is the sign (takes +1 or -1) and

is the number of iteration.

Let the complex number corresponding to reference phase is . The reference angles for different values of is listed in the table below

	Re{Y}	Im{Y} =	(in degrees)	abs()
0	1	1.000000000	45.000000000	1.414213562
1	1	0.500000000	26.565051177	1.118033989
2	1	0.250000000	14.036243468	1.030776406
3	1	0.125000000	7.125016349	1.007782219
4	1	0.062500000	3.576334375	1.001951221
5	1	0.031250000	1.789910608	1.000488162
6	1	0.015625000	0.895173710	1.000122063
7	1	0.007812500	0.447614171	1.000030517
8	1	0.003906250	0.223810500	1.000007629
9	1	0.001953125	0.111905677	1.000001907
….

Table: List of for = 1 to 10

The set of operations for rotating a complex number by an angle to generate in the CORDIC way can be as shown below:

Figure: CORDIC for phase rotation

As the multiplication by involves only power of two, the operation can be implemented with out using ‘real’ multipliers. Nice advantage when we need to save hardware. The flip side is the number of iterations required for obtaining accurate estimate.

Additionally, the multiplication by introduces gain (as shown in the Table above) and after 16 iterations () the cumulative gain come to 1.64676025786545. Hence the block for compensating the gain.

% Simple Matlab example of phase rotation using CORDIC
clear
% creating the reference angles
Y_k = ones(32,1) + j*2.^(-1*[0:1:31])’; % values of Y
alpha_k = angle(Y_k)*180/pi; % reference angles

X = 2+3*j; % complex number to be phase rotated
thetaDeg = 25; % the phase to be rotated
K = 16; % number of iterations

thetaHat = 0; % initial phase angle
Z = X; % assigning the output as the input

% for different values of k
for k = 0: K-1
s = sign(thetaDeg – thetaHat); % difference
if s == 0 s = 1; end % to handle when thetaDeg = 0
Z = Z*[1 + s*j*2^(-1*k)];
thetaHat = thetaHat + s*alpha_k(k+1);
% dumping the variables for plot
sign_v(k+1) = s;
thetaHat_v(k+1) = thetaHat;
end

Z_ideal = X*exp(j*thetaDeg*pi/180);
Z_cordic = Z/1.64676025786545;
err = Z_ideal – Z_cordic;
errdB = 10*log10(err*err’)

close all
figure
plot(thetaHat_v,’m.-’)
grid on
xlabel(‘k’)
ylabel(‘thetaHat, degree’)
title(‘thetaHat converging to theta over K iterations’)

Reference

[DSPGURU-CORDIC] CORDIC FAQ in dspGuru(TM)

Related posts:

1. Using CORDIC for phase and magnitude computation
2. First order digital PLL for tracking constant phase offset
3. Gray code to Binary conversion for PSK and PAM

Two points suffice for drawing a straight line. However we may be presented with a set of data points (more than two?) presumably forming a straight line. How can one use the available set of data points to draw a straight line?

A probable approach is to draw a straight line which hopefully minimizes the error between the observed data points and estimated straight line.

where is the observed data points and is the points from estimated straight line.

To draw the estimated straight line , we need to estimate the slope, and the constant, .

Formulating as a matrix,

,

where,

= is the set of observations is a matrix of dimension ,

= is the set of coefficients is a matrix of dimension ,

is the slope and constant estimate of dimension ,

= is the noise is a matrix of dimension .

The least square estimate of the straight line is,

.

A simple MATLAB code for least squares straight line fit is given below:

% Least Squares Estimate
rand(’state’,100); % initializing the random number generation
y = [5:3:50]; % observations, y_i
y = y + 5*rand(size(y)); % y_i with noise added
x = 1:length(y); % the x co-ordinates

% Formulating in matrix for solving for least squares estimate
Y = y.’;
X = [x.' ones(1,length(x)).'];
alpha = inv(X’*X)*X’*Y; % solving for m and c

% constructing the straight line using the estimated slope and constant
yEst = alpha(1)*x + alpha(2);

close all
figure
plot(x,y,’r.’)
hold on
plot(x,yEst,’b')
legend(‘observations’, ‘estimated straight line’)
grid on
ylabel(‘observations’)
xlabel(‘x axis’)
title(‘least squares straight line fit’)

References:

[1] Details on Curve fitting toolbox from MathWorks(TM) website

Related posts:

1. First order digital PLL for tracking constant phase offset
2. Approximate Vector Magnitude Computation
3. IQ imbalance in transmitter

It might be interesting to interpret the output of the fft() function in Matlab. Consider the following simple examples.

fsMHz = 20; % sampling frequency
fcMHz = 1.5625; % signal frequency
N = 128; % fft size
% generating the time domain signal
x1T = exp(j*2*pi*fcMHz*[0:N-1]/fsMHz);
x1F = fft(x1T,N); % 128 pt FFT
figure;
plot([-N/2:N/2-1]*fsMHz/N,fftshift(abs(x1F))) ; % sub-carriers from [-128:127]
xlabel('frequency, MHz')
ylabel('amplitude')
title('frequency response of complex sinusoidal signal');

With anpoint fft() and sampling frequency of , the observable spectrum from is split to sub-carriers.

Additionally, the signal at the output of fft() is from . As the frequencies from get aliased to , the operator fftshift() is used when plotting the spectrum.

In the example above, with a sampling frequency of 20MHz, the spectrum from [-10MHz, +10MHz) is divided into 128 sub-carriers with spaced apart by 20MHz/128 = 156.25kHz. The generated signal x1T of frequency 1.5625MHz corresponds to the information on the 10th sub-carrier, which can also be generated in the frequency domain.

% generating the frequency domain signal with subcarrier indices [-N/2:-1 dc 1:N/2-1]
x2F = [zeros(1,N/2) 0 zeros(1,9) 1 zeros(1,N/2-10-1)]; % valid frequency on 10th subcarrier, rest all zeros
x2T = N*ifft(fftshift(x2F)); % time domain signal using ifft()
% comparing the signals
diff = x2T – x1T;
err = diff*diff’/length(diff)

Plotting the frequency response of a filter

Consider a filter with the a sinc() shaped impulse response. The Matlab code for plotting the frequency response is as follows:

% impulse response of a sinc() filter
hT = sinc([-20:20]/3); % consider sample at 30MHz sampling;
hF = fft(hT,1024); % 128 pt FFT
figure;
plot([-512:511]*30/1024,fftshift(abs(hF))) ;
xlabel('frequency, MHz')
ylabel('amplitude')
title('frequency response of sinc filter');

Hopefully, the post provides some insights on the query raised in the comp.dsp thread.

Related posts:

1. Polyphase filters for interpolation
2. Zero-order hold and first-order hold based interpolation
3. Transmit pulse shaping filter – rectangular and sinc (Nyquist)