Modulo-N code: Difference between revisions

Content deleted Content added

Inline

Revision as of 02:44, 20 February 2020

Modulo-N code is a lossy compression algorithm used to compress correlated data sources using modular arithmetic.

Compression

When applied to two nodes in a network whose data are in close range of each other modulo-N code requires one node (say odd) to send the coded data value as the raw data $M_{o}=D_{o}$ ; the even node is required to send the coded data as the $M_{e}=D_{e}{\bmod {N}}$ . Hence the name modulo-N code.

Since at least $\log _{2}K$ bits are required to represent a number K in binary, the modulo coded data of the two nodes requires $\log _{2}M_{o}+\log _{2}M_{e}$ bits. As we can generally expect $\log _{2}M_{e}\leq \log _{2}M_{o}$ always, because $M_{e}\leq N$ . This is the how compression is achieved.

A compression ratio achieved is ${\text{C.R.}}={\frac {\log _{2}M_{o}+\log _{2}M_{e}}{2\log _{2}M_{o}}}.$

Decompression

At the receiver by joint decoding we may complete the process of extracting the data and rebuilding the original values. The code from the even node is reconstructed by the assumption that it must be close to the data from the odd node. Hence the decoding algorithm retrieves even node data as

\operatorname {CLOSEST} (M_{o},N.k+M_{e}).

The decoder essentially finds the closest match to $M_{o}\simeq N.k+M_{e}$ and the decoded value is declared as $N.k+M_{e}$

Example

For a mod-8 code, we have Encoder

D_o=43,D_e=47
M_o=43,M_e=47 mod(8) = 7,

Decoder

 M_o=43,M_e=47 mod(8) = 7,
 D_o=43,D_e=CLOSEST(43,8⋅k + 7)
  $43\simeq 8\cdot 5+7$ 
 D_o=43,D_e=47

Modulo-N decoding is similar to phase unwrapping and has the same limitation: If the difference from one node to the next is more than N/2 (if the phase changes from one sample to the next more than $\pi$ ), then decoding leads to an incorrect value.

@@ Line 1: / Line 1: @@
 {{Unreferenced|date=December 2009}}
-'''Modulo-N code''' is a [[lossy compression]] algorithm used to compress [[correlated]] data sources using [[modulo arithmetic]].
+'''Modulo-''N'' code''' is a [[lossy compression]] algorithm used to compress [[correlated]] data sources using [[modular arithmetic]].
 ==Compression==
-When applied to two nodes in a [[computer networking|network]] whose data are in close range of each other Modulo-N code
+When applied to two nodes in a [[computer networking|network]] whose data are in close range of each other modulo-''N'' code requires one node (say odd) to send the coded data value as the raw data <math>M_o = D_o</math>; the even node is required to send the coded data as the <math> M_e = D_e \bmod N </math>. Hence the name modulo-''N'' code.
-requires one node (say odd) to send the coded data value as the raw data <math>M_o = D_o</math>; the even node is required
-to send the coded data as the <math> M_e = (D_e) mod (N) </math>. Hence the name Modulo-N code.
+Since at least <math>\log_2 K</math> bits are required to represent a number ''K'' in binary, the modulo coded data of the two nodes requires <math>\log_2 M_o + \log_2 M_e</math> bits. As we can generally expect <math>\log_2 M_e \le \log_2 M_o</math> always, because <math>M_e \le N</math>. This is the how compression is achieved.
-Since it is known that for a number K, at least <math>log_2(K)</math> bits are required to represent it
-in binary. So the modulo coded data of the two nodes requires totally <math>log_2(M_o) + log_2(M_e)</math>.
-As we can generally expect <math>log_2(M_e) \le log_2(M_o)</math> always, because <math>M_e \le N</math>.
-This is the how compression is achieved.
-A compression ratio achieved is <math>C.R = \frac{log_2(M_o) + log_2(M_e)}{2log_2(M_o)}</math>.
+A compression ratio achieved is <math>\text{C.R.} = \frac{\log_2 M_o + \log_2 M_e}{2\log_2 M_o}.</math>
 ==Decompression==
-At the receiver by joint decoding we may complete the process of extracting the data and rebuilding the
+At the receiver by joint decoding we may complete the process of extracting the data and rebuilding the original values. The code from the even node is reconstructed by the ''assumption'' that it must be  close to the data from the odd node. Hence the decoding algorithm retrieves even node data as
-original values. The code from the even node is reconstructed by the ''assumption'' that it must be
-close to the data from the odd node. Hence the decoding algorithm retrieves even node data as <BR />
-<math>CLOSEST(M_o,N.k+ M_e)</math>.
+: <math>\operatorname{CLOSEST}(M_o,N.k+ M_e).</math>
-The decoder essentially finds the closest match to <math>M_o \simeq N.k + M_e</math> and the decoded
-value is declared as <math>N.k + M_e</math>
+The decoder essentially finds the closest match to <math>M_o \simeq N.k + M_e</math> and the decoded value is declared as <math>N.k + M_e</math>
 ==Example==
@@ Line 35: / Line 28: @@
   D_o=43,D_e=47
-Modulo-N decoding is similar to [[phase unwrapping]] and has the same limitation: If the difference from one node to the next is more than N/2 (if the phase changes from one sample to the next more than <math>\pi</math>), then decoding leads to an incorrect value.
+Modulo-''N'' decoding is similar to [[phase unwrapping]] and has the same limitation: If the difference from one node to the next is more than ''N''/2 (if the phase changes from one sample to the next more than <math>\pi</math>), then decoding leads to an incorrect value.
-===See also===
+==See also==
 * [[DISCUS]] is a more sophisticated technique for compressing correlated data sources.
 * [[Delta encoding]] is a related algorithm used in lossless compression algorithms designed for correlated data sources.