THE VITERBI ALGORITHM IN MATHCAD

Transcription

1 THE VITERBI ALGORITHM IN MATHCAD. Introduction This worksheet contains procedures comprising the Viterbi Algorithm (VA). Although it is written a specific trellis code, it is easily adaptable to many other situations, such as space-time (ST) coding, convolutional encoding and Viterbi equalization. Two types of Viterbi decoder are provided. One keeps an ever-growing record of encoder and decoder states. It is primarily instructional and debug purposes, so you can wrap your mind around the data structures and algorithms. The other keeps only the last d symbols, so that you can run simulations over very large numbers of symbols. It is harder to understand, although it's not bad if you have already sorted out the first m of Viterbi decoder. You may want to make some modifications to the programs (other than the obvious ones a different code or channel estimation procedure, etc): The procedures have been written clarity more than efficiency, and you may find some superfluous or inefficient computations here and there. Some parameters (notably N state, N succ, N pred and d) are globally defined, rather than being passed in the parameter lists of procedures. It's convenient if you plan simply to modify this worksheet. However, if you want to make this a reference file (an "include" file) in another worksheet, you might find it easier to redefine the parameter lists of the procedures.. Variables and Data Structures N state number of states N succ number of trellis successors of each state N pred number of predecessors of each state, equals N succ trell invtrell an N succ x N state matrix in which trellis i,k is the i th successor state of state k an N pred x N state matrix in which invtrell i,k is the i th predecessor state of state k

2 sig invsig constell an N succ x N state matrix in which sig i,k gives the index of the transmitted constellation point in the transition from state k to its i th successor state an N pred x N state matrix in which invsig i,k gives the index of the transmitted constellation point in the transition to state k from its i th predecessor state a length-n const array of complex constellation points. M an N state x vector of accumulated metric values indexed by state pred a growing N state x time matrix, column t is the optimum predecessor state vector at time t (pred s,t is the opt predecessor index of state s at time t) the number of symbols in the simulation run sent a x matrix: top row is sequence of states, bottom row the transmitted constellation points. The Example TCM Code This is an 8 state 8PSK code from E. Biglieri et al, Introduction to Trellis Coded Modulation With Applications, Macmillan 99, Fig. {,,,} data Grey Code {,,,} next state index The trellis states are labelled.. (not shown on the diagram). From the trellis connections, we can view the state label as a -bit shift register into which new bits are shifted from the right (least significant bits) every symbol time. Thus the LSBs of any state specify the inmation bits conveyed in the transition to that state. The labels to the left of each state identify the 8PSK constellation point associated with each of the transitions out of that state.

3 To define the code, you fill in the elements of the highlighted arrays below. Change their dimensions other codes. matrix defining trellis connections matrix defining transmitted constellation points trell := sig := constell := π j e π j j e j e π j j e π T the constellation points themselves Some global values used in many of the procedures below N state := cols( trell) N pred := rows( trell) N succ := N pred N const := rows( constell). Some Utility Procedures These procedures are used frequently in the simulations further below. an all-zeros vector an all-ones vector zeros( K) := i.. K ones( K) z z i := i.. K u u i vector of integers from..k- unit variance complex Gaussian variate index( K) := i.. K cgauss( x) := ln( rnd ) exp j rnd π u u i i random M-ary variate data( M) := floor( M rnd ) ( )

4 decibels (clipped at -) inverse db db( x) := if x >, log( x), nat( x) :=. x. Inversion of Trellis Description The trellis and signal structure are defined by the matrices trell and sig used by the transmitter. For the VA in the receiver, it is more convenient to use the inverse descriptions. These procedures perm the conversion. The first produces the data structure invtrell defined in Section. invert_trellis( trell) := N state cols( trell) N succ rows( trell) invst.. N state predind invst st.. N state next.. N succ invtrell invst trell next, st pred predind invst invtrell pred, invst st predind invst predind invst + initialize the predecessor index sweep through trellis in lexicographical order Now use the procedure on the trellis defined in Section : invtrell := invert_trellis( trell) and this is the result: invtrell = Compare this with the trellis diagram and the definition of the trellis matrix in Section.

5 To accompany the trellis inversion, we need a signal inversion to obtain the data structure invsig defined in Section (it gives the signals on branches leading into a state, not out of it). invert_signal( sig, trell) := N state cols( sig) N succ rows( sig) invst.. N state predind invst st.. N state next.. N succ invsig invst trell next, st pred predind invst invsig pred, invst sig next, st predind invst predind invst + invsig := invert_signal( sig, trell) invsig = Compare this with the trellis diagram and the definition of the sig matrix above.. Error Counting Inevitably, channel noise causes the receiver to make occasional incorrect decisions on the state sequence or constellation point. We are really interested in the number of inmation bit errors in these events, so we need a procedure determining how many bit errors there were at each symbol time. The error counting function compares the true and candidate constellation indices at a single time step and returns the number of bit errors.

6 biterrs( true, cand) := true floor true cand cand floor err if true = cand err if true cand = err err otherwise This one works a trellis code using QPSK subsets of 8PSK: LSB is trimmed off to create variables in range.., then compared. Note this assumes a prior Grey coding, even through constellation points are labelled in natural order. An alternative is off-page to the right.. Procedures That Use Ever-Growing Data Structures The first implementation uses data structures that keep a record of all bits decoded, so their size is generally proportional to the number of bits in the simulation. The Encoder Generate the transmitted signal. Columns indexed by time. Top row is states, bottom row is constellation point index gen_sig sent :=, start in state sent t.. sndx data N succ oldst sent, t sent, t trell sndx, oldst sent, t sig sndx, oldst successor index sndx Select the length of the simulation run, in symbols, and generate the random transmitted data. := sent := gen_sig

7 The Channel Model as AWGN (additive white Gaussian noise). Select the SNR: γ db := γ := nat γ db noise variance is /γ Generate the received signals. Note this is 8PSK. i :=.. r i := constell sent i +, γ cgauss() i v i := This is the channel gain estimate v. Make it perfect channel estimation here. The Metric Here is the metric PSK - try to maximize it. The procedure calculates the metric the received signal r with channel gain estimate v and a specific state transition (predecessor index pndx, current state st). Note this is PSK-type metric( r, v, pndx, st) Re r := v constell invsigpndx, st constellations, since it's a correlation. The Traceback Algorithm Once the simulation has run to its full time steps, we process the pred array in the VA (see below) to create an array of decisions in the same mat as the sent matrix of the transmitter. Pick the state at the last time step with the largest metric, then trace back, converting the predecessor indexes to predecessor states and constellation points.

8 := statelist index( N state ) traceback pred, M, temp csort( augment( M, statelist), ) decn Nsim, temp rows( temp), find terminal state with largest accumulated metric t,.. decn st pndx decn, t pred st, t decn, t invtrell pndx, st decn, t invsig pndx, st then work back to the start, recording the states and the constellation indexes The Viterbi Algorithm Finally, the VA itself. In the Viterbi algorithm below: first initialize the metric vector M to ce operation beginning with state ; then at each time step, run through the states; each state, run through the predecessors to see which gives the largest sum of branch metric and predecessor's own accumulated metric. Save the best predecessor index in pred. init_metric N state := M st.. N state M M st 8

9 := M init_metric( N state ) predlist index( N pred ) viterbi r, v, t.. st.. N state pndx.. N pred pst invtrell pndx, st temp_metric pndx M pst, t + metric r t, v t, pndx, st temp csort( augment( temp_metric, predlist), ) new_m st temp rows( temp), pred st, t temp rows( temp), M t new_m traceback pred, M t, decode := viterbi r, v, Now compare the sent and decoded signals. Remember our SNR and simulation length were γ db = = sent = 8 9 decode = 8 9 How many errors did we get? 9

10 t = biterrs sent, t, decode, t = t = biterrs sent, t, decode, t = 9 This graph shows the number of errors at each time step. t :=.. errors 8 9 symbol time. Viterbi Algorithm with Bounded Data Structures For long simulations, or live code, we need a Viterbi implementation that: puts signal generation, channel and detection all in the same time loop; releases decisions after a finite delay d, usually a few multiples of the constraint length. Use circular arrays of size d, so that the data structures do not grow without bound. Select the delay d - it is another global variable: d := This procedure generates the signal (state and constellation point) a new time step. The record sent is limited to d columns.

11 gen_sig d ( t, sent) := sndx data N succ oldst sent, mod( t, d) next_sent trell sndx, oldst next_sent sig sndx, oldst next_sent generate transmitted signal. top row is states, bottom is constell pt index This is the traceback routine bounded data structures. Convert the pred matrix to an array of states and signals in same mat as sent. i wrap( i, n) := i n floor like mod function, but allows neg arguments n traceback d ( pred, M, t) := statelist index N state temp csort( augment( M, statelist), ) decn, mod( t, d) temp rows( temp), t' t, t.. t d+ decn t'' st pndx mod( t', d) decn, t'' pred st, t'' decn, wrap( t'', d) invtrell pndx, st decn, t'' invsig pndx, st find terminal state with largest accumulated metric then work back to the start, recording the state and the constellation index And, finally, the Viterbi Algorithm itself. It is set up here generate the transmitted and received signals and count the errors, not return the decisions. The VA detector alone is the set of statements following v in the "t loop."

12 := M init_metric( N state ) predlist index( N pred ) viterbi d γ, sent zeros errs t.. sent mod( t, d) r constell sent mod t, d v st.. N state gen_sig d ( t, sent) +, γ cgauss() t pndx.. N pred errs pst invtrell pndx, st temp_metric pndx M pst + metric( r, v, pndx, st) temp csort( augment( temp_metric, predlist), ) new_m st temp rows( temp), pred st, mod( t, d) temp rows( temp), M new_m if t > d decn traceback d ( pred, M, t) errs errs + biterrs decn, mod( t, d), sent, mod( t, d) Let's do a run. Pick the SNR and the run length: γ db := db γ := nat γ db convert from db := in symbols How many errors will we get? viterbi d ( γ, ) =

13 .