```Method "a", or Method "1" in your example is the correct way:
Bit/Polynomial message --convert--> Exponential message --encode-->
Exponential codeword --convert--> Bit/Polynomial codeword.

-Jagan

>When converting bits to RS symbols in GF(n+1)for a RS(n,k)code for
>commercial standards like DVB, CD-ROM etc, does one:
>
>Method a). Convert message bits to polynomial representation {which
>lies in [0,n-1]}in GF(n+1), perform systematic encoding after
>converting to exponent form, and reconvert the resulting systematic
>code-word to polynomial form prior to transmission??
>
>or
>
>Method b). Convert bits to exponent representation in {which lies in
>[-1,n-2]} in GF(n+1), perform systematic encoding, and transmit the
>resulting code-word, after converting back to binary data.
>
>The code-words generated in these two cases are different since the
>mapping from bits to RS symbols is different in each case.
>
>Kindly let me know as to which is the commercially used method...
>Also let me know if the parity is inserted post/before the message
>symbols...
>
>Thank you
>Regards
>Vikram
>
>PS: Here is an example to illustrate the resulting code-words in
>either scheme for a RS(7,3) code over GF(8):
>
>Method 1:
>--------
>If message bits=[0 1 1 1 1 0 1 0 1] {I am going to use LSB first
>representation}
>
>implies Message=[6 3 5] in polynomial format with lowest power first.
>(or) Message = [4 3 6] in exponent format.
>{since a^4=a+a^2, or decimal 6, a^3=1+a or decimal 3, a^6=1+a^2 or
>decimal 5 in GF(8)}.
>Generator=[3 1 0 3 1]in exponent format starting with lowest power
>first.
>Systematic encoding of message polynomial using exponent format yields
>the Code word: [3 -1 -1 6 4 3 6] in exponent format
>or Code word: [3 0 0 5 6 3 5] in polynomial format
>This corresponds to the code bits
>[1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 1 0 1 0 1]
>
>Method 2:
>--------
>Message=[0 1 1 1 1 0 1 0 1]
>Mapping bits to exponent format, with 000-->-1, and so on till
>111--->6, we get
>Message=[5 2 4] exponent format
>Code-word=[2 6 6 4 5 2 4] exponent format
>         =[1 1 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 0 1]
>

This message was sent using the Comp.DSP web interface on
www.DSPRelated.com
```
```Hello,
I am not sure if my previous message got posted successfully, so here
I am sending the message associated with Reed-Solomon encoding once
again. I am testing my RS encoder/decoder that I built using LabVIEW.
I had a few questions to ask to this knowledeable audience... Here
they are:

When converting bits to RS symbols in GF(n+1)for a RS(n,k)code for
commercial standards like DVB, CD-ROM etc, does one:

Method a). Convert message bits to polynomial representation {which
lies in [0,n-1]}in GF(n+1), perform systematic encoding after
converting to exponent form, and reconvert the resulting systematic
code-word to polynomial form prior to transmission??

or

Method b). Convert bits to exponent representation in {which lies in
[-1,n-2]} in GF(n+1), perform systematic encoding, and transmit the
resulting code-word, after converting back to binary data.

The code-words generated in these two cases are different since the
mapping from bits to RS symbols is different in each case.

Kindly let me know as to which is the commercially used method...
Also let me know if the parity is inserted post/before the message
symbols...

Thank you
Regards
Vikram

PS: Here is an example to illustrate the resulting code-words in
either scheme for a RS(7,3) code over GF(8):

Method 1:
--------
If message bits=[0 1 1 1 1 0 1 0 1] {I am going to use LSB first
representation}

implies Message=[6 3 5] in polynomial format with lowest power first.
(or) Message = [4 3 6] in exponent format.
{since a^4=a+a^2, or decimal 6, a^3=1+a or decimal 3, a^6=1+a^2 or
decimal 5 in GF(8)}.
Generator=[3 1 0 3 1]in exponent format starting with lowest power
first.
Systematic encoding of message polynomial using exponent format yields
the Code word: [3 -1 -1 6 4 3 6] in exponent format
or Code word: [3 0 0 5 6 3 5] in polynomial format
This corresponds to the code bits
[1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 1 0 1 0 1]

Method 2:
--------
Message=[0 1 1 1 1 0 1 0 1]
Mapping bits to exponent format, with 000-->-1, and so on till
111--->6, we get
Message=[5 2 4] exponent format
Code-word=[2 6 6 4 5 2 4] exponent format
=[1 1 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 0 1]
```