# Patent

## Title
Method and apparatus of communication

## Abstract

The invention pertains to a method and apparatus of efficient encoding and decoding of vector quantized data. The method and system explores and implements sub-division of a quantization vector space comprising class-leader vectors and representation of the class-leader vectors by a set of class-leader root-vectors facilitating faster encoding and decoding, and reduced storage requirements.

## Background
CROSS-REFERENCE TO RELATED APPLICATION
This application is a continuation of International Application No. PCT/CN2008/070719, filed on Apr. 16, 2008, which is hereby incorporated by reference in its entirety.


TECHNICAL FIELD
The technical field includes communications and signal processing. More particularly, the invention relates to a method and apparatus providing data processing of low complexity for spherical vector quantization, SVQ.
BACKGROUND
Today's communications are to a great extent digital. They are both time discrete and discrete in amplitude, relying upon digital samples. Well-known examples of the technical development from analogue communications systems to digital communications systems are digitization for distribution of analogue telephony and the switch from vinyl records to audio compact discs, audio CDs in the 70's and 80's. Other examples have followed, such as portable digital audio players and digital television broadcasting.
For fixed analogue telephony, analogue speech is distributed in electrical signals over phone wires. When analogue telephone systems have been digitized, the speech is still carried in analogue electrical signals from the phone to a switch of the operator, where it is digitized so as to allow reconstruction within predefined requirements or criteria as regards distortion of the analogue signal. To provide required dynamics with a limited number of bits, the speech signal is compressed before the digitization providing a digital signal for distribution. The compressors provide signals of reduced dynamics but are essentially lossless, since the analogue signal could be expanded in a receiver. This compression is known as A-law or μ-law compression. At the receiving end, the signal is then expanded. Today there are also fixed telephone systems being digital all the way from one phone to another. In this description, compression is used for referring to lossy or lossless compression.
As regards CDs, analogue samples of time-continuous sound are quantized into a fixed number of bits (16 bits) with no compression of the quantized data. The limitation of sound samples to fixed levels provides some difference between the digitized samples and the analogue samples. This is known as quantization noise or distortion. Since the number of quantization levels is great (216), the distortion is negligible compared to the noise produced in analogue components of most audio CD players or amplifiers and loudspeakers.
As regards portable audio players and video broadcasting, the requirement on reducing the number of bits required for storage or transmission while not requiring too complex equipment requiring a huge amount of storage or power for feeding extremely fast (and power consuming) computers. Today, portable digital audio players and set top boxes for TV reception are available to many of those households that want them due to achievements of the technical development as regards, e.g., coding, storage media, such as flash memories, and computational capacity. Digital content stored on most portable digital audio players or broadcast in digital television or sound radio systems is compressed by lossy compression.
A communications channel may include media such as electromagnetic storage, electronic memories, propagation of signals in traveling waves of electromagnetic fields from a transmitting antenna to a receiving antenna, or propagation of optical signals from an optical transmitter to a receiver for optical signals.
Telephone systems, CDs, digital portable audio players and television broadcasting all provide examples of communications over a communications channel. The fixed wire provides a communications channel for the telephone system, the CD for the distribution of audio from a studio to a listener via a CD player, the flash memory or other storage medium for the portable audio player or the radio channel for television broadcasting.
R. M. Gray and D. L. Neuhoff, “Quantization,” IEEE Transactions on Information Theory, 1998, vol. 44, no. 6, pp. 2325-2383, traces the history of quantization from its origins, starting from 1898, and survey the fundamentals of many of the popular and promising techniques for quantization.
Gray and Neuhoff refer quantization to “the division of a quantity into a discrete number of small parts.” As an example, any real number can be rounded off to the nearest integer. In binary computing, integers are commonly represented by sequences of binary digits, bits, thereby providing a binary representation of the quantized real number. Other example data representations exist as well.
Quantization and source coding have their origins in pulse code modulation, PCM, the system used for audio CD recording. A PCM system consists fundamentally of three components: a sampler (11), a quantizer (12) and an encoder (13) as schematically illustrated in FIG. 1. Sampling converts a continuous time waveform (14) into a discrete time waveform (14). Quantization (12) of the samples (15) renders the quantized samples (16) to be approximations of the unquantized samples (15). The quantized samples, or indices thereof, are transmitted on a communications channel (17) as provided by the encoder (13). With scalar quantization, SQ, each (quantized) sample is independently encoded into a fixed number of bits, and correspondingly decoded into a reproduction. For a given distortion or reconstruction error, scalar quantization generally requires comparatively greater data rates than vector quantization, VQ.
Vector quantization, VQ, quantizes a number of samples simultaneously. VQ provides significantly higher quantization performance than scalar quantization, SQ, in the case of a fixed bit rate. In case of k successive samples to be quantized, VQ, makes use of a k-dimensional partition or a k-dimensional codebook, C, comprising k-dimensional code vectors, each code vector representing a cell of vectors with minimum distortion according to a predefined criterion, such as minimum Euclidean distance. For this purpose it is convenient to consider the quantization and encoding to be tightly related or one concept as schematically indicated by a dashed line (18) in FIG. 1. An advantage of VQ as compared to SQ is that it inherently can exploit memory of source signals to be quantized, source signals such as the discrete time sequence (14) of the sampled waveform. Thereby, source signals such as speech signals or image signals commonly comprising memory or dependencies between different samples can be represented more efficiently. Also VQ comprises merits on its own and, in principle, SQ cannot perform better in terms of distortion versus rate than the best VQ. In prior art, the price for this improvement has been paid by increased complexity of, particularly, the encoder.
FIG. 2 illustrates a simplified block diagram for vector quantization. A signal sequence (285) is represented by vectors (281) and signals (286) carrying the vectors are mapped (282) into an index (287) corresponding to a representation or codeword of the codebook, a code vector, providing a minimum distortion encoding of the vectors (286) according to a predefined criterion or measure, e.g. Euclidean distance. The vector to be represented (288) and the quantized vector or a representative thereof (289) are exchanged between the minimum distortion determining entity (282) and the entity comprising the code book representation (283). At the output of the channel (at a receiving end) the reconstructed vector is achieved by using a similar codebook and looking up the code vector represented by the received index.
Essentially, transmission on a communications channel comprises all technical arrangements for distributing or communicating a signal from a source sender to a destination as schematically illustrated in FIG. 3. A sequence representing a code index (34, 35) is transmitted through a communications channel (32) to the destination where it is decoded in the receiver (33). From the viewpoint of a source encoder and decoder, the channel may be considered to comprise channel coding as need be to transmit or detect errors on a transmission channel. In practice, though, channel encoders and decoders separated from the source encoding and decoding are included in physical transmitters and receivers, respectively. So, from the viewpoint of the source encoding, also parts of physical transmitters and receivers are frequently included in the communications channel (32).
For low bit rates, a good way to design a vector quantizer, from a rate distortion perspective, is to adapt the quantizer to characteristics of a given input source, e.g. provided in training sequences. FIG. 4 illustrates schematically a flowchart for iteratively determining a codebook Y according to a generalized Lloyd algorithm, frequently referred to as an LBG algorithm (as disclosed by Y. Linde A. Buzo and R. Gray). The algorithm is initiated (41) by initializing a counter m, an initial codebook Y0, a maximum possible (within the applicable range of the application) distortion D−1 and a precision level ε. For each iteration, m, a partitioning Sm defining the cells surrounding the various code vectors of the code book, is determined (42) for the code book Ym, and the distortion Dm is determined (43). The algorithm is interrupted (44) when the relative distortion is smaller than the precision set initially. In case the relative distortion is greater than the preset level, ε, a refined codebook is determined, the iteration counter is updated (46) and the process repeats for another iteration starting with determining a partitioning for the refined codebook (42).
The LBG algorithm is commonly considered to be computational expensive in terms of number of instructions when there is a great number of quantization levels. It is also sensitive to the initial choice of codebook (41). Also the amount of read-only memory, ROM, required by a trained vector quantizer is usually considered to be too large. Another problem is related to the LBG algorithm being trained to provide minimum distortion for a particular training data sequence. If data from another source with substantially different statistical properties is quantized, the performance is most often suboptimal. For vectors of dimension 1, the LBG quantizer reduces to the scalar Lloyd-Max quantizer.
For high bit rates, the theory of VQ provides a method for creating a codebook providing the smallest distortion, e.g. in terms of Euclidean distance or squared Euclidean distance, given a certain statistic of the input signal based on the calculation of a point density function from the probability density function, PDF, of the input signal. Structured codebooks do not exploit linear or non-linear dependency to increase the quantization performance that vector quantizers are generally capable of. At least linear dependencies, however, can be transformed to provide a benefit in quantization performance by means of Linear Prediction or Transform Coding. Therefore, the structured vector quantizers are designed such that they have high performance for memoryless sources.
A lattice vector quantizer is a vector quantizer of which the codebook is composed of vectors which are arranged in a regular lattice according to a mathematical rule. A degenerate example lattice quantizer is a uniform scalar quantizer for the special case of a vector quantizer of dimension Lv=1. Lattices in higher dimensions benefit from a more efficient space filling. In other words, a lattice, A, comprises all vectors in an Lv dimensional vector space with




  
    
      
        L
        ∷
        
          y
          ∈
          
            
              {
              
                
                  
                    
                      ∑
                      
                        j
                        =
                        0
                      
                      
                        
                          L
                          L
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        λ
                        j
                      
                      ·
                      
                        v
                        j
                      
                    
                  
                  ∷
                  
                    
                      λ
                      j
                    
                    ∈
                    Z
                  
                
                ,
                
                  
                
                ⁢
                
                  
                    v
                    j
                  
                  ∈
                  
                    R
                    
                      L
                      v
                    
                  
                
              
              }
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        1
      
    
  




where  denotes integers, and  denotes real Lv-tuples. The vectors v=[vi,0, vi,1, . . . , vi,LV−1] are the basis vectors of the lattice, and all lattice vectors are linear combinations of these basis vectors. The factors λj to weight each basis vector are integer numbers. A lattice in general is a subset of an Lv-dimensional vector space but consists of a countable infinite number of points,

L⊂  eq. 2

The number, L, of weighting factors λi determines the lattice's degree of freedom and is also called the dimension of the lattice. L can be greater or smaller than Lv. In most cases, the dimension equals the dimension of the vector space in which the basis vectors are defined, LL=Lv.
For the case that the dimension of the lattice equals the dimension of the code-vector space, equation 1 is equivalent to a representation including a generator matrix M,

L:yε{λ·M:λ=[λ0,λ1, . . . ,λLv−1],M=[v0T,v1T, . . . ,vLv−1T]},  eq. 3

where the factors λj as before are integer weight factors and Lv is the dimension of the vector space. When more than one matrix provide the same distribution of points considering all λ in equation 3, they are all generator matrices of one and the same lattice.
FIG. 5 illustrates an example two dimensional hexagonal lattice and corresponding basis vectors forming the generator matrix M. There are four vectors (51, 52, 53, 54) depicted. Vectors [1, 0] (51) and [1⁄2, √{square root over (3)}/2] (52) span the same set of points as do basis vectors [0, −√{square root over (3)}] (53) and [1⁄2, −√{square root over (3)}/2] (54).
An example generator matrix providing the lattice is consequently




  
    
      
        M
        =
        
          
            [
            
              
                
                  1
                
                
                  
                    1
                    /
                    2
                  
                
              
              
                
                  0
                
                
                  
                    
                      3
                    
                    /
                    2
                  
                
              
            
            ]
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        4
      
    
  




Another example generator matrix of the lattice is




  
    
      
        
          M
          ′
        
        =
        
          
            [
            
              
                
                  0
                
                
                  0
                
              
              
                
                  
                    
                      -
                      
                        3
                      
                    
                    /
                    2
                  
                
                
                  
                    -
                    
                      3
                    
                  
                
              
            
            ]
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        5
      
    
  




An alternative, but equivalent, definition of the two dimensional hexagonal lattice, also referred to as the A2 lattice, in FIG. 5 is




  
    
      
        
          A
          2
        
        ∷
        
          y
          ∈
          
            
              {
              
                
                  
                    [
                    
                      
                        y
                        0
                      
                      ,
                      
                        y
                        1
                      
                      ,
                      ...
                      ⁢
                      
                        
                      
                      ,
                      
                        y
                        
                          
                            L
                            v
                          
                          -
                          1
                        
                      
                    
                    ]
                  
                  ∷
                  
                    y
                    ∈
                    
                      R
                      
                        L
                        v
                      
                    
                  
                
                ,
                
                  
                
                ⁢
                
                  
                    
                      ∑
                      
                        j
                        =
                        0
                      
                      
                        
                          L
                          v
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      y
                      j
                    
                  
                  =
                  0
                
              
              }
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        6
      
    
  




Jacques Martinet, “Perfect Lattices in Euclidean Spaces,” Springer-Verlag, Berlin, 2003, pp. 110-114, defines lattices of prior art such as the hexagonal lattice, ALv, and its dual, A*Lv, the checkerboard lattice, DLV, and its dual D*Lv, and the integer lattice, ZLv, for arbitrary dimensions Lv. In the sequel, the printing symbol asterisk will be used for other purposes than for denoting a dual lattice.
Other known lattices are the Gosset lattice, E8, the Coxeter-Todd-Lattice, K12, the Barnes-Wall lattice L16, and the Leech Lattice L24.
A permutation code P defines all vectors of a codebook by means of class-leader vectors, {tilde over (x)}P, of dimension Lv. A class-leader vector {tilde over (x)}P is composed of coordinate entries {tilde over (x)}P,j, 0≦j<Lv, comprising wj components taken from a set of LP≦Lv real values, μl, 0≦l<LP, sorted in decreasing order, μ0>μ1> . . . >μLP−1,




  
    
      
        
          
            
              
                
                  x
                  ~
                
                P
              
              =
              
                
                  [
                  
                    
                      
                        
                          x
                          
                            P
                            ,
                            0
                          
                        
                      
                      
                        
                          x
                          
                            P
                            ,
                            1
                          
                        
                      
                      
                        ...
                      
                      
                        
                          x
                          
                            P
                            ,
                            
                              
                                L
                                v
                              
                              -
                              1
                            
                          
                        
                      
                    
                  
                  ]
                
                T
              
            
          
        
        
          
            
              =
              
                
                  
                    [
                    
                      
                        
                          
                            
                              μ
                              0
                            
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              0
                            
                            ⁢
                            
                              
                            
                            ⁢
                            ...
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              0
                            
                          
                        
                        
                          
                            
                              μ
                              1
                            
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              1
                            
                            ⁢
                            
                              
                            
                            ⁢
                            ...
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              1
                            
                          
                        
                        
                          ...
                        
                        
                          
                            
                              μ
                              
                                
                                  L
                                  P
                                
                                -
                                1
                              
                            
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              
                                
                                  L
                                  P
                                
                                -
                                1
                              
                            
                            ⁢
                            
                              
                            
                            ⁢
                            ...
                            ⁢
                            
                              
                            
                            ⁢
                            
                              μ
                              
                                
                                  L
                                  P
                                
                                -
                                1
                              
                            
                          
                        
                      
                      
                        
                          
                            ←
                            
                              
                                w
                                0
                              
                              →
                            
                          
                        
                        
                          
                            ←
                            
                              
                                w
                                1
                              
                              →
                            
                          
                        
                        
                          ...
                        
                        
                          
                            ←
                            
                              
                                w
                                
                                  
                                    L
                                    P
                                  
                                  -
                                  1
                                
                              
                              →
                            
                          
                        
                      
                    
                    ]
                  
                  T
                
                .
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        7
      
    
  




wl is the weight related to real value μl and is the number of occurrences of real value μl, 0≦l<LP,




  
    
      
        
          
            ∑
            
              l
              =
              0
            
            
              
                L
                P
              
              -
              1
            
          
          ⁢
          
            w
            l
          
        
        =
        
          
            L
            v
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        8
      
    
  




A permutation of a class-leader vector {tilde over (x)}P is a vector {tilde over (x)}*P that is composed of the same real values, μl, as {tilde over (x)}P but in a different order. The corresponding permutation operation can be specified by means of matrix, P, referred to as the permutation matrix. The relation between {tilde over (x)}P and {tilde over (x)}*P could then be expressed as

{tilde over (x)}*P=P·{tilde over (x)}P=[{tilde over (x)}*P,0{tilde over (x)}*P,1 . . . {tilde over (x)}*P,Lv−1]T.  eq. 9

An example permutation vector reversing the sequence order is




  
    
      
        P
        =
        
          
            [
            
              
                
                  0
                
                
                  ...
                
                
                  0
                
                
                  0
                
                
                  1
                
              
              
                
                  0
                
                
                  ...
                
                
                  0
                
                
                  1
                
                
                  0
                
              
              
                
                  ...
                
                
                  ...
                
                
                  ...
                
                
                  ...
                
                
                  ...
                
              
              
                
                  0
                
                
                  1
                
                
                  0
                
                
                  ...
                
                
                  0
                
              
              
                
                  1
                
                
                  0
                
                
                  0
                
                
                  ...
                
                
                  0
                
              
            
            ]
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        10
      
    
  




The permutation processing is preferably realized in a digital signal processor, DSP, adapted for the permutation of interest. High speed applications may require the permutations to be implemented in hardware, which can be achieved by employment of e.g. shift register circuitry. Reversal of sequence order is e.g. achieved by storing the vector components in a shift register of the same length as the vector, in component-wise sequential order, and feeding out the shift register content in the reverse order. This is illustrated in FIG. 6. The example shift register is composed of a number of D latches (601-603). The vector to be reversed is input (604) to the shift register through closed switches (605-607) during a sequence of clock cycles during which one component of the vector is input after another. When the entire vector has been shifted into the D elements (601-603), the previously closed switches (605-607) are being opened, and switches (608-610), previously open while shifting the vector into the register, are being closed. During the next clock cycles, the components are shifted out of the shift register (611) in reverse order. Effectively, the shift register of FIG. 6 could be replaced by memory circuitry or a storage medium for storing controlled by a signal processor. The corresponding processing comprises storing the vector components in the memory or storage medium and reading out the memory content or stored content component wise in the reverse order.
Given a class-leader vector and corresponding weights wl, the number of possible permutations is




  
    
      
        
          
            N
            P
          
          =
          
            
              
                
                  (
                  
                    
                      ∑
                      l
                    
                    ⁢
                    
                      w
                      l
                    
                  
                  )
                
                !
              
              
                
                  ∏
                  l
                
                ⁢
                
                  
                    w
                    l
                  
                  !
                
              
            
            .
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        11
      
    
  




NP is known as the multinomial coefficient. To identify one among all possible permutations, a vector index iP, 0≦iP<NP, is useful for describing and understanding the encoding process and mapping of code vectors. Since all permuted vectors are composed of the same coordinate values but in different order, the absolute value, or length, of the code vectors is identical for all permutated vectors. Using the vector index, this is

∥{tilde over (x)}iP∥=√{square root over (Σlwl·μl2)}∀iP.  eq. 12

The NP permutations of the class-leader vector altogether form a permutation codebook {tilde over (X)}P.
A further issue in the quantization process relates to compaction or how to represent the various vectors with fewer class representatives, such that the errors introduced by information loss due to the compaction will be acceptably small, or at best not be noticeable, to a user.
One representation of a vector x based on the class-leader vector, {tilde over (x)}P of a permutation code that provides the minimum Euclidean distance is achieved as follows. For a vector x of dimension Lv, x=[x0 x1 . . . xLv−1]T to be (further) quantized or compacted, permute the vector coordinates such that the components of the permuted vector x*=[x*0 x*1 . . . x*Lv−1]T are ordered in decreasing order x*0≧x*1≧ . . . x*Lv−1. The required permutations are represented by a matrix Px, x*=Px·x. The ordered vector x* is represented by a class-leader vector as specified in equation 7 and that also has its components sequentially ordered according to magnitude.
For reconstructing x from x*, the process is reversed x=(Px)−1·x*. The matrix P=(Px)−1 also provides a minimum Euclidean distance representative {tilde over (x)}*P for the vector x to be quantized or compressed.

{tilde over (x)}*P=(Px)−1·{tilde over (x)}P.  eq. 13

To achieve the compression a vector index, iP, is determined for the vector representative {tilde over (x)}*P. This is achieved by a permutation to index mapping and which is preferably achieved by a mapping suggested by J. Pieter and M. Schalkwijk.
The mapping consequently transforms the permuted vector {tilde over (x)}*P into an index iP. A decoder realizes the reverse operation and maps the index iP back into a permuted vector {tilde over (x)}*P, corresponding to the original permuted vector. Consequently, there is a one-one mapping between permuted vector {tilde over (x)}*P and index iP, the index iP providing a representation of the permuted vector {tilde over (x)}*P suitable for transmission, storage or further processing such as for channel encoding. In brief, the index is suitable for transfer on a communications channel. The number of indices, |IP|, is equal to the number of possible permutations, NP (see equation 11).
U.S. Pat. No. 4,075,622 describes a method and apparatus for data compression which utilizes a random walk through Pascal's triangle directed by an incoming binary source sequence. The random walk starts at the apex of Pascal's triangle and proceeds downward according to an algorithm until it terminates at a boundary which has been constructed in such a way that the encoding of each source sequence can be accomplished in a fixed number of bits.
U.S. Pat. No. 6,054,943 describes a variable-to-block universal multilevel digital information compression making use of a random walk in Pascal's hypervolume, a multi-dimensional generalization of Pascal's triangle. Codewords and decoded source sequences are either determined in the encoder and decoder, respectively, on the fly at encoding/decoding or pre-computed and stored. Variable length sequences of source symbols are encoded into fixed length codeword blocks. Encoders and decoders including dedicated hardware including registers, counters and latches are disclosed as are flowcharts. FIG. 26 of U.S. Pat. No. 6,054,943 illustrates graphically an example encoding (and decoding) of an example sequence of a ternary source. Depending on the source sequence and for each incoming source symbol, a particular candidate prefix is selected and a running sum is updated. The final value of the running sum, rs, for a sequence of symbols {jk}k=1n corresponds at least to a part of an index or codeword and equals




  
    
      
        
          rs
          =
          
            
              ∑
              
                k
                =
                1
              
              n
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  
                    j
                    k
                  
                  -
                  1
                
              
              ⁢
              
                
                  
                    (
                    
                      k
                      -
                      1
                    
                    )
                  
                  !
                
                
                  
                    
                      (
                      
                        
                          w
                          i
                          k
                        
                        -
                        1
                      
                      )
                    
                    !
                  
                  ⁢
                  
                    
                      ∏
                      
                        
                          p
                          =
                          0
                        
                        
                          p
                          ≠
                          i
                        
                      
                      
                        m
                        -
                        1
                      
                    
                    ⁢
                    
                      
                        (
                        
                          w
                          p
                          k
                        
                        )
                      
                      !
                    
                  
                
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        14
      
    
  




where jkε[0, m−1] is the incoming symbol at stage k and where the summation is over all n incoming symbols and wik is the number of symbols iε[0, m−1] that have arrived after k stages. The outer sum is determined recursively by adding the inner summation for each incoming symbol to encode. The encoding is terminated at a particular element in Pascal's hyper volume. This point is added as a starting point prefix for the decoder to know where to start tracing back in Pascal's hyper volume. It is also suggested in U.S. Pat. No. 6,054,943 to add a prefix to allow uncoded transmission in order to avoid encoder expansion to happen for some sequences. At encoding, a recursion for determining the running sum for an incoming symbol j is




  
    
      
        
          rs
          ←
          
            rs
            +
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  j
                  -
                  1
                
              
              ⁢
              
                oldPos
                *
                
                  
                    w
                    i
                  
                  
                    
                      w
                      j
                    
                    +
                    1
                  
                
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        15
      
    
  




where oldPos is the old position in Pascal's hyper volume. The position in Pascal's hyper volume is similarly updated recursively for the next iteration,




  
    
      
        
          l
          ←
          
            l
            +
            1
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        16
      
    
  
  
    
      
        
          oldPos
          ←
          
            oldPos
            *
            
              l
              
                
                  w
                  j
                
                +
                1
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        17
      
    
  




where l corresponds to the number of symbols that have come in.
The recursion for decoding works the path through Pascal's hyper volume for choosing a symbol j that provides a position that is not greater than a candidate for the corresponding position in the hyper volume. The recursion for the running sum in reverse direction, decoding position l of a codeword, in U.S. Pat. No. 6,054,943 is




  
    
      
        
          rs
          ←
          
            rs
            -
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  j
                  -
                  1
                
              
              ⁢
              
                curPos
                *
                
                  
                    w
                    i
                  
                  l
                
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        18
      
    
  




with the associated recursions decoding next




  
    
      
        l
        ←
        
          l
          +
          1
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        19
      
    
  
  
    
      
        curPos
        ←
        
          curPos
          *
          
            
              
                w
                j
              
              l
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        20
      
    
  




Khalid Sayood, “Introduction to Data Compression, 2nd edition, 2000, pp. 290, 291” provides a first introduction to spherical vector quantizers. For the Gaussian probability distribution, the contours of constant probability are circles in two dimensions. In two dimensions an input vector can be quantized by transforming it into polar coordinates comprising radius, r, and phase, θ. Polar coordinates span the same space as do Cartesian coordinates. r and θ can either be quantized independently, or quantized values of r can be used as an index to a quantizer for θ. The advantage to quantizing r and θ independently is reduced complexity as compared to a quantizer for which the quantization of θ depends on the quantization of r. As mentioned above in relation to scalar quantizers, not making full use of interdependencies within a block tend to reduce performance.
Jon Hamkins, ‘Design and analysis of spherical codes,’ Thesis submitted in partial fulfillment of the requirements for the degree of Doctor of philosophy in Electrical Engineering in the Graduate College of the University of Illinois at Urbana-Champaign, dated 1996, briefly defines and provides properties of the root lattices Ak, Dk, E8 and Zk and their duals in chapter 2, the “root” relating to the root systems of certain Lie algebras. Hamkins also defines a codebook as a set of output points or vectors forming the code points or code vectors. A k-dimensional spherical code is defined as a finite set of points in  that lie on the surface of the k-dimensional unit radius sphere Ωk,




  
    
      
        
          Ω
          k
        
        ≡
        
          
            {
            
              
                
                  (
                  
                    
                      x
                      1
                    
                    ,
                    
                      x
                      2
                    
                    ,
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      x
                      k
                    
                  
                  )
                
                ∈
                
                  
                    R
                    k
                  
                  :
                  
                    
                      ∑
                      
                        i
                        =
                        1
                      
                      k
                    
                    ⁢
                    
                      x
                      2
                    
                  
                
              
              =
              1
            
            }
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        21
      
    
  




In chapter 6, Hamkins describes wrapped spherical codes as vector quantizers for a memoryless Gaussian source and provides an algorithmic description of an encoder in table 6.1 quantizing gain and shape of a vector independently, the gain corresponding to the length or radius of the vector, and the shape corresponding to the vector normalized to 1. The gain codebook is optimized by the Lloyd-Max algorithm. Since the PDF is known (Gaussian source), no training is required. The algorithmic description is also included in Jon Hamkins and Kenneth Zeger, Gaussian Source Coding with Spherical Codes, IEEE Transactions on Information Theory, vol. 48, No. 11, pp. 2980-2989 (2002).
SUMMARY
In prior art technology, the number of class-leader vectors for representing source data, e.g. speech, tend to be large, thereby requiring substantial storage capacity of e.g. codebook representation for encoding and decoding in digital communications equipment. A great number of class leaders requires a great time for determining the code vector in the encoding process in order to minimize distortion.
None of the cited documents provides a method or system of quantization or coding wherein a metric or distortion forming a criterion according to which a signal, or (using vector notation) code vector or codeword, to output for an unquantized input signal, or vector, is determined from a reduced set of code vectors of an E-lattice being linked to the (full) set of code vectors by a sign distribution.
In communications in general and in today's digital communications in particular, it is a challenge to provide communications resources meeting increasing amounts of data being communicated at an increasing rate while providing communications services at a decreasing cost. One crucial element for making digital communications financially and technically possible to a great number of people is efficient quantization of data for efficient signaling. Speech encoding and decoding for speech communications in mobile telephone systems, sound encoding for storage of songs and decoding for reproducing the sound in portable audio players or surround sound equipment reproducing movie sound, or other multi-channel sound, stored on a DVD or CD or received from public broadcasting companies by wire or over the air and image coding and decoding for digital television are some communications examples well known to the public.
For further development, it is a challenge to reduce complexity or storage requirements for a given code, or maintain complexity or storage requirements while allowing more complex coding principles, and there is a need of improved encoding and decoding efficiency.
Consequently, it is an object of example embodiments of the invention to provide reduced processing or storage requirements compared to processing required for a representation based on a set of class-leader vectors compared to today's requirements for given codes.
It is an object of a preferred example embodiment of the invention to determine a quantization output from a reduced set of code vectors providing the same metric/distortion and output as if determined from the full set of code vectors.
It is also an object of example embodiments of the invention to allow for more complex encoding and decoding without increasing cost or complexity of encoders or decoders.
Further, it is an object of an embodiment of the invention to allow quantization or coding of signals being less restricted to particular block lengths, corresponding in vector notion to the dimension of the vector space.
It is an object of an embodiment of the invention to provide signals or signaling representation by sub-division of a codebook facilitating a one-one representation of class-leader vectors (using vector notation) with a (smaller) number of vectors suitable for storage in electronic, magnetic or optic storage media or representation for communication signaling.
Further, it is an object of a preferred embodiment of the invention to provide associated indexing for communication on a communications channel.
The invention provides a method and system implementing sub-dividing a set of class-leader vectors of a vector quantization encoder or decoder for encoding and decoding of communications data and mapping of corresponding data as described in detail below in relation to encoding and decoding processes.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 schematically illustrates a sampler, a quantizer and a coder according to prior art.
FIG. 2 illustrates a simplified block diagram for vector quantization according to prior art.
FIG. 3 illustrates schematically transmission on a communications channel according to prior art.
FIG. 4 demonstrates schematically a flowchart for iteratively determining a codebook according to a generalized Lloyd algorithm of prior art.
FIG. 5 illustrates an example two dimensional hexagonal lattice in prior art.
FIG. 6 depicts a block diagram of an example shift register according to prior art.
FIG. 7 shows a basic block diagram for parallel quantization of a radius and a normalized vector according to prior art.
FIG. 8 shows a basic block diagram for serial quantization of a radius and a normalized vector according to an example mode of the invention.
FIG. 9 plots an example distribution of code vectors according to the invention.
FIG. 10 illustrates a flowchart of an efficient quantization procedure according to the invention.
FIG. 11 illustrates schematically sub-ranges corresponding to equivalence classes in relation to root-vector classes for a simplified example according to the invention.
FIG. 12 displays a flowchart illustrating example indexing in an embodiment of the invention.
FIG. 13 depicts a basic flowchart for quantization according to an embodiment of the invention.
FIG. 14 shows a simplified flowchart for determining a transformed distortion metric according to a preferred embodiment of the invention.
FIG. 15 illustrates schematically indexing providing codewords from quantized data according to an embodiment of the invention.
FIG. 16 illustrates schematically a flow-chart of a preferred decoder according to the invention.
FIG. 17 displays schematically preferred index processing of code vectors of category A according to the invention.
FIG. 18 illustrates schematically preferred index processing of code vectors of category B according to the invention.
FIG. 19 monitors a simplified block diagram of example equipment according to the invention.



DETAILED DESCRIPTION
Vector quantizers based on structured codebooks generally provide a good compromise between memory requirement, computational complexity and quantization performance for practical use. For a given input signal probability distribution function, PDF, the theoretically optimal code-vector point-density-function for a given input signal PDF is well approximated by structured codebooks such as lattice codebooks and permutation codebooks. These codebooks are not stored completely in memory and are searched efficiently for codebooks according to the invention.
Knowledge on the probability distribution function, PDF, is required for the structured codebooks. It is not useful to assume a certain (statistical) characteristic of audio signals. Worst case assumptions are preferably made so that the designed VQ has good performance even for the signal that is hardest to quantize. Among all signal characteristics, Gaussian noise has the highest differential entropy. Therefore, following the worst case approach, a quantizer for audio coding should preferably be designed to have good performance for Gaussian sources.
Spherical vector quantization, SVQ, is a quantization that approximates the optimal code-vector point-density for the Gaussian distribution and at the same time can be realized efficiently. If properly designed, the achieved signal to noise ratio, SNR, related to SVQ is independent from the PDF of the input signal and from the dynamics of the input signal for a wide dynamic range.
In the course of the quantization process, an example input signal representing an input signal vector, x, is transformed into a signal representing a radius, Rx=∥x∥, of the vector, x, and a normalized vector c=x/Rx. Both the radius and the normalized vector will be quantized to produce a quantized radius, {tilde over (R)}x=QR(Rx), and a quantized normalized vector {tilde over (c)}=Qsp(c), with the codebooks {tilde over (X)}R for the radius and {tilde over (X)}sp for the normalized vector. In the sequel {tilde over (c)}=Qsp(c) is referred to as a spherical code vector and {tilde over (X)}sp as the codebook for the spherical vectors. If the radius is quantized by means of logarithmic quantization, e.g. A-law quantization well known from compression of PCM in telephone systems, the quantization signal to noise ratio, SNR, is independent of the probability density function of the input signal. This is also referred to as logarithmic SVQ.
The quantized output signal vector is

{tilde over (x)}={tilde over (c)}·{tilde over (R)}x.  eq. 22

FIG. 7 shows a basic block diagram for parallel quantization of a radius (72) and a normalized vector (73). The radius and normalized vector are quantized independently. Both the block (71) separating the radius and the spherical vector and the quantizers (72), (73) are preferably included in an encoder entity, whereas the combining entity (74) is preferably included in a decoder entity. The output signal representing an output vector, {tilde over (x)}, of the combining entity (74) is the reconstructed value of the input signal represented as input vector x. The figure does not include processing equipment of index determining for reasons of simplicity. Signaling carrying codewords corresponding to indices are preferably transferred on a communications channel. Accordingly, the invention preferably includes processing equipment for index determining.
FIG. 8 shows a basic block diagram for serial quantization of a radius (82) and a normalized vector (83). As for the parallel quantization, both the block (81) separating the radius and the spherical vector and the quantizers (82), (83) are preferably included in an encoding entity, whereas the combining entity (84) is preferably included in a decoder entity. In contrast to the parallel realization the radius quantization is performed after the quantization of the normalized vector, c. This will allow for considering the curvature of the quantization cells, which is effective particularly for large cells. Especially for low bit rates, the sequential approach provides a slightly higher performance. The output signal representing an output vector, {tilde over (x)}, of the combining entity (84) is the reconstructed value of the input signal represented as input vector x. The figure does not include index determining for {tilde over (R)}x or {tilde over (x)}, respectively. In similarity with the parallel quantization, an encoder preferably comprises equipment for determining one or more indices. Signaling carrying codewords corresponding to indices rather than quantized vectors are preferably transferred on a communications channel.
FIG. 9 plots an example distribution of code vectors, indicated by black points (91), (92), (93), of spherical vector quantization with quantization cells (94), (95) corresponding to parallel quantization for Lv=2 and signal vectors x=[x0 x1]. The code vectors are located on the surface of spheres, which for the 2-dimensional case are circles. The radii differs for code vectors on different circles (92), (93).
There are different encodings for representing the quantized vectors (code vectors). The scalar radius quantizer, QR, (72), (82) is preferably realized by electrical circuitry implementing a lookup table, since the number of quantization and reconstruction levels is usually modest and, consequently, the number of entries required to be stored is small, particularly if logarithmic quantization is applied. For the serial quantizer in FIG. 8, the quantization process is, e.g., realized by processing circuitry implementing a bisection based on a table containing all interval bounds. The sequential combination of the quantizers is referred to as re-quantization of the radius.
Denote a quantized vector (code vector) as {tilde over (x)}iQ. The index iQ of the code vector {tilde over (x)}iQ denotes required and sufficient information to reconstruct the code vector in the decoder. Considering, e.g., logarithmic SVQ, there are two indices, iQ, R and iQ, sp corresponding to the selected quantization reconstruction levels of the radius and the quantized normalized vector, respectively. There are two modes of combining the indices into a single index in the invention. The former is preferred due to a small advantage for transfer over communication channels introducing channel errors. They are

iQ=iQ,R·Nsp+iQ,sp, and  eq. 23

iQ=iQ,sp·NR+iQ,R,  eq. 24

where Nsp is the number of code vectors for the normalized vector and NR is the number of available quantizer reconstruction values for the radius.
A Gosset Low Complexity Vector Quantizer according to an embodiment of the invention is based on code vectors from a lattice derived from the well known Gosset lattice, E8. The E8 lattice is known to have the highest possible density of points in eight dimensions. The invention identifies advantages as regards encoding and decoding that can be achieved based on a generalized Gosset lattice, E-lattice. Thereby efficiency gains as regards computational complexity and memory/storage requirements are achieved.
The Gosset lattice was originally designed for eight dimensions, Lv=8. In order not to limit the invention to Lv=8, the E-lattice (to be further explored as will be explained below) is generalized in the invention from the Gosset lattice to an arbitrary dimension Lv as follows

ELv=DLv∪(DLv+v):v=[1⁄2 . . . 1⁄2],  eq. 25

where




  
    
      
        
          
            D
            
              L
              v
            
          
          :
          
            y
            ∈
            
              {
              
                
                  
                    [
                    
                      
                        y
                        0
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        y
                        1
                      
                      ⁢
                      
                        
                      
                      ⁢
                      ...
                      ⁢
                      
                        
                      
                      ⁢
                      
                        y
                        
                          
                            L
                            v
                          
                          -
                          1
                        
                      
                    
                    ]
                  
                  :
                  
                    
                      y
                      j
                    
                    ∈
                    Z
                  
                
                ,
                
                  
                    
                      ∑
                      
                        j
                        =
                        0
                      
                      
                        
                          L
                          v
                        
                        -
                        1
                      
                    
                    ⁢
                    
                      y
                      j
                    
                  
                  ≡
                  
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      
                        modulo
                        ⁢
                        
                          
                        
                        ⁢
                        2
                      
                      )
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        26
      
    
  




is the checkerboard lattice, or D-lattice, of the same number of dimensions, Lv, as the E-lattice. The well-known modulo operation provides the remainder, so that (modulo 2) refers to the remainder when dividing by 2.
Lattice vectors with a same distance to the origin define a shell, S, of the lattice. To simplify notion, for the generalized Gosset lattice, or E-lattice, ELv, a shell with a squared distance to the origin equal to 2u is denoted . The radius of the particular shell of the E-lattice is denoted . Consequently, the shell is defined as




  
    
      
        
          S
          u
          
            (
            
              E
              
                L
                v
              
            
            )
          
        
        :
        
          y
          ∈
          
            
              {
              
                
                  
                    E
                    
                      L
                      v
                    
                  
                  :
                  
                    
                    x
                    
                  
                
                =
                
                  R
                  u
                  
                    (
                    
                      E
                      
                        L
                        v
                      
                    
                    )
                  
                
              
              }
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        27
      
    
  




Each E-lattice spherical vector codebook, , is composed of all vectors related to a specific shell of squared radius 2u, normalized to radius 1,




  
    
      
        
          
            
              X
              ~
            
            
              sp
              ,
              u
            
            
              (
              
                E
                
                  L
                  v
                
              
              )
            
          
          :
          
            c
            ~
          
        
        =
        
          
            y
            
              
                2
                ⁢
                u
              
            
          
          ⁢
          
            ∀
            
              y
              ∈
              
                
                  S
                  u
                  
                    (
                    
                      E
                      
                        L
                        v
                      
                    
                    )
                  
                
                .
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        28
      
    
  




The effective bit rate of the E-lattice is




  
    
      
        
          
            r
            
              eff
              ,
              u
            
            
              (
              
                E
                
                  L
                  v
                
              
              )
            
          
          =
          
            
              1
              
                L
                v
              
            
            ·
            
              
                log
                2
              
              (
              
                N
                
                  sp
                  ,
                  u
                
                
                  (
                  
                    E
                    
                      L
                      v
                    
                  
                  )
                
              
              )
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        29
      
    
  




where  is the number of code vectors located on a shell with radius √{square root over (2u)} of ELv. The number of code vectors, , located on the various shells of ELv depends on the radius √{square root over (2u)} and the particular E-lattice. Table 1 lists the number of code vectors versus half the squared radius for the well known Gosset lattice, E8. Also included in the table is the respective effective bit rate to address the code vectors of the shell.
Given a specific effective target bit rate per sample for the spherical codebook, reff, sp, shells of successively greater radii of the lattice of interest are investigated one by one, starting with a shell of smallest radius, i.e. smallest natural number u, when constructing the codebook. The codebook is finally based upon a shell usp, with as many code vectors as possible provided that the effective bit rate per sample does not exceed the effective target bit rate per sample,




  
    
      
        
          
            u
            sp
          
          =
          
            
              argmax
              
                
                  u
                  ∈
                  
                    N
                    :
                  
                
                
                  
                    r
                    
                      eff
                      ,
                      u
                    
                    
                      (
                      
                        E
                        
                          L
                          v
                        
                      
                      )
                    
                  
                  ≤
                  
                    r
                    
                      eff
                      ,
                      u
                    
                  
                
              
            
            ⁢
            
              N
              
                sp
                ,
                u
              
              
                (
                
                  E
                  
                    L
                    v
                  
                
                )
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        30
      
    
  




where  denotes natural numbers.







TABLE 1







Number of code vectors on different shells of the Gosset lattice.









u
Nsp, u(E8)
reff, u(E8)












1
240
0.9884


2
2160
1.3846


3
6720
1.5893


4
17520
1.7621


5
30240
1.8605


6
60480
1.9855


7
82560
2.0416


8
140400
2.1374


9
181680
2.1839


10
272160
2.2568


15
846720
2.4614


20
2207520
2.6342


30
7620480
2.8577









For reasons of simplicity, a codebook for encoding and decoding according to the invention based on a particular E-lattice is also referred to by the particular shell or by the half of its squared radius, usp.
The E-lattice is invariant under an interchange of vector coordinates. All spherical code vectors can be grouped into a number, , of equivalence classes, Em, m=0, 1, . . . , −1. Each equivalence class is composed of vectors generated by a permutation code Pm given the class-leader vector {tilde over (c)}E, Pm. Hence, the spherical vector codebook  can be expressed as a superposition of  codebooks, {tilde over (X)}Pm, of a permutation code Pm,




  
    
      
        
          
            X
            ~
          
          
            sp
            ,
            u
          
          
            (
            
              E
              
                L
                v
              
            
            )
          
        
        =
        
          
            ⋃
            
              m
              =
              0
            
            
              
                M
                
                  E
                  ,
                  u
                
                
                  (
                  
                    E
                    
                      L
                      v
                    
                  
                  )
                
              
              -
              1
            
          
          ⁢
          
            
              
                X
                ~
              
              
                P
                m
              
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        31
      
    
  




The respective number of equivalence classes related to spherical codebooks of different shells with half squared radius u=1, 2, . . . , 10 are listed in table 2.
With the decomposition of the E-lattice spherical codebook into equivalence classes and the quantization procedure related to permutation codes, an efficient quantization procedure according to the invention is as follows and as also illustrated in the flowchart of FIG. 10.
For a normalized vector c to be quantized, reordering corresponding to a permutation matrix Pc is determined such that when applied to the normalized vector, the coordinates of the vector are rearranged in decreasing order (101). The permuted vector c*=Pc·c is

c*=[c*0c*1 . . . c*Lv−1]T,  eq. 32

where c*0≧c*1≧ . . . cLv−1.
Class-leader vectors are usually pre-stored in read-only memory or other storage medium. From the set of all the class-leader vectors, {tilde over (c)}E, Pm, m=0, 1, . . . , −1, a candidate m=mQε[0, −1] is, e.g., searched and selected (102) by processing circuitry from the equivalence classes Em, mε[0, −1], that out of the stored class leader vectors, provides minimum distortion with respect to the (unquantized) vector c*, according to a predefined criterion, such as minimum squared Euclidean distance,




  
    
      
        
          m
          Q
        
        =
        
          
            argmin
            
              
                m
                =
                0
              
              ,
              1
              ,
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ,
              
                
                  M
                  
                    E
                    ,
                    u
                  
                  
                    (
                    
                      E
                      
                        L
                        v
                      
                    
                    )
                  
                
                -
                1
              
            
          
          ⁢
          
            
              
                
                
                  
                    
                      c
                      ~
                    
                    
                      E
                      ,
                      
                        P
                        m
                      
                    
                  
                  -
                  
                    c
                    *
                  
                
                
              
              2
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        33
      
    
  




Since the vectors {tilde over (c)}E, Pm and c* are of fixed (normalized) length, minimizing, and distortion in equation 33 is equivalent to maximizing the correlation or scalar product of the vectors




  
    
      
        
          m
          Q
        
        =
        
          
            argmax
            
              
                m
                =
                0
              
              ,
              1
              ,
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ,
              
                
                  M
                  
                    E
                    ,
                    u
                  
                  
                    (
                    
                      E
                      
                        L
                        v
                      
                    
                    )
                  
                
                -
                1
              
            
          
          ⁢
          
            
              
                c
                ~
              
              
                E
                ,
                
                  P
                  m
                
              
            
            ·
            
              
                c
                *
              
              .
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        34
      
    
  




The spherical code vector preferred to represent c is determined (103) by processing the class-leader vector representative corresponding to applying the inverse of the permutation matrix P=(Pc)−1. Hence, the spherical code vector determined to represent the normalized vector c is




  
    
      
        
          c
          ~
        
        =
        
          
            
              (
              
                P
                c
              
              )
            
            
              -
              1
            
          
          ·
          
            
              c
              ~
            
            
              E
              ,
              
                
                  P
                  m
                
                Q
              
            
          
          ·
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        35
      
    
  




The quantized vector {tilde over (c)} is mapped (104) to a codeword, or index, iQ, sp in digital signal processing equipment. This is preferably achieved by applying the Schalkwijk algorithm, well-known in the art, to the particular code of the invention as follows.
Given more than one permutation code, in the range of all possible indices iQ, spε[0, Nsp−1] respective sub-ranges (111), (112), (113), (114) corresponding to the  equivalence classes, E0, E1, E2 and E3 are determined as chematically illustrated in FIG. 11, for the example case of four equivalence classes. The example sub-ranges are not uniform. Index offset corresponding to the sub-ranges,




  
    i
    
      off
      ,
      
        E
        0
      
    
  
  ,
  
    i
    
      off
      ,
      
        E
        1
      
    
  
  ,
  ...
  ⁢
  
    
  
  ,
  
    i
    
      off
      ,
      
        E
        
          
            M
            
              E
              ,
              u
            
            
              (
              
                E
                
                  L
                  v
                
              
              )
            
          
          -
          1
        
      
    
  
  ,




included in FIG. 11 for ME, u−1=3, are preferably stored for each of the sub-ranges (111), (112), (113), (114) to speed-up encoding or decoding and then need not be transferred on the communications channel.

For the sub-range (111), (112), (113), (114), corresponding to equivalence class EmQ digital signal processing equipment determines an index iP in analogy with prior art methods. Thus, the desired index of the quantized vector {tilde over (c)} is determined in the signal processing as

iQ,sp=ioff,mQ+iP.  eq. 36

The determining of the index iP is described in brief as follows. For an index range IP, the number of indices is NP. Assume that {tilde over (c)}j=μlj, then Lv−1 coordinates remain to be determined, i.e. to be associated to a specific value μl. The number of possible permutations for the remaining sub-vector is calculated from the number of permutations in equation 11 with adjusted weights wl(adj)




  
    
      
        
          w
          l
          
            (
            adj
            )
          
        
        =
        
          {
          
            
              
                
                  
                    w
                    l
                  
                  ,
                
              
              
                
                  l
                  =
                  
                    l
                    j
                  
                
              
            
            
              
                
                  
                    
                      w
                      l
                    
                    -
                    1
                  
                  ,
                
              
              
                
                  l
                  ≠
                  
                    
                      l
                      j
                    
                    .
                  
                
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        37
      
    
  




For each choice of lj, the number of possible permutations of the sub-vector comprising the remaining vector components defines a sub-range of indices, provided {tilde over (c)}j=μlj. This sub-range is denoted . Thereby, the index range IP is sub-divided into sub-ranges




  
    
      
        
          I
          P
        
        =
        
          
            ⋃
            
              
                l
                j
              
              =
              0
            
            
              
                I
                P
              
              -
              1
            
          
          ⁢
          
            
              I
              
                
                  
                    c
                    ~
                  
                  
                    P
                    ,
                    j
                  
                
                =
                
                  μ
                  
                    l
                    j
                  
                
              
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        38
      
    
  




The number of indices in a sub-range associated with a particular value μlj is




  
    
      
        
          
          
            
              I
              
                
                  c
                  ~
                
                
                  P
                  ,
                  j
                
              
            
            =
            
              μ
              
                l
                j
              
            
          
          
        
        =
        
          
            
              
                (
                
                  
                    
                      ∑
                      l
                      
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      w
                      l
                    
                  
                  -
                  1
                
                )
              
              !
            
            
              
                ∏
                
                  l
                  :
                  
                    l
                    ≠
                    
                      l
                      j
                    
                  
                
                
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    w
                    l
                  
                  !
                
                ·
                
                  
                    (
                    
                      
                        w
                        
                          l
                          j
                        
                      
                      -
                      1
                    
                    )
                  
                  !
                
              
            
          
          .
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        39
      
    
  




The sub-ranges are further sub-divided into smaller sub-ranges, and at last there is a single index.
FIG. 12 displays a flowchart illustrating an example indexing as explained above for encoding of a sequence for communication over a communications channel. Indexing is initialized (121), where wt(•) denotes the weight or the number of occurrences of a particular symbol. The rank of an incoming symbol {tilde over (c)}j is determined (122) and the index is updated accordingly by the sum of number of indices in corresponding sub-range (123). The weights are updated (124) and the recursion continues for the next incoming symbol (125) until the last LV symbol of the code vector have been encoded (126). The index then finally results from the last recursion (127).
The invention identifies that in many cases a great number of equivalence classes are involved depending on, e.g., dimensionality and sphere radius. As a non-exclusive example illustrated in table 2, the number of equivalence classes, ME, 10(E8), for u=10 is 162. A brute-force implementation of the quantization process will, for such cases, tend to require great memory and computational capacities in terms of number of bytes and number of operations per second, respectively.







TABLE 2







Number of equivalence classes and root classes for different shells


of the Gosset lattice.









u
ME, u(E8)
MF, u(E8)












1
8
2


2
15
3


3
24
3


4
42
5


5
54
5


6
57
5


7
103
8


8
119
9


9
124
9


10
162
11









According to a preferred embodiment of the invention, the requirements on the quantization equipment is substantially relieved by a quantizer implementing grouping of equivalence classes, Em, in root classes, Fm′. For the example radius corresponding to u=10, the number of classes is reduced from 162 to 11 for the Gosset lattice, or more than by a factor of 10, providing a load reduction in a corresponding order of magnitude, while providing identically the same codewords and distortion, e.g. in terms of minimum Euclidean distance.
For the definition of the root classes consider two categories of code vectors, labeled categories A and B. Vectors of category A are in DLv and comply with the requirement in equation 26 and vectors of category B are in DLv+v, v=[1⁄2 . . . 1⁄2] and comply with the requirement in equation 25. Consider a spherical code vector, {tilde over (c)}, of category A, and denote it {tilde over (c)}(A). When changing the sign of a single coordinate position, e.g. position j0, the resulting vector is also a vector of category A, since




  
    
      
        
          
            
              
                ∑
                
                  j
                  =
                  0
                
                
                  
                    L
                    v
                  
                  -
                  1
                
              
              ⁢
              
                
              
              ⁢
              
                
                  c
                  ~
                
                j
                
                  (
                  A
                  )
                
              
            
            -
            
              2
              ⁢
              
                
                  c
                  ~
                
                
                  j
                  0
                
                
                  (
                  A
                  )
                
              
            
          
          ≡
          
            0
            ⁢
            
              (
              
                modulo
                ⁢
                
                  
                    
                  
                  ⁢
                  
                    
                  
                
                ⁢
                2
              
              )
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        40
      
    
  




and the radius of the vector remains unchanged.
Consider a spherical code vector, {tilde over (c)}, of category B, and denote it {tilde over (c)}(B). When changing the sign of exactly two coordinate positions, e.g. positions j0 and j1, the resulting vector is also a vector of category B, since




  
    
      
        
          
            
              
                ∑
                
                  j
                  =
                  0
                
                
                  
                    L
                    v
                  
                  -
                  1
                
              
              ⁢
              
                
              
              ⁢
              
                
                  c
                  ~
                
                j
                
                  (
                  B
                  )
                
              
            
            -
            
              2
              ⁢
              
                
                  c
                  ~
                
                
                  j
                  0
                
                
                  (
                  B
                  )
                
              
            
            -
            
              2
              ⁢
              
                
                  c
                  ~
                
                
                  j
                  1
                
                
                  (
                  B
                  )
                
              
            
          
          ≡
          
            
              ∑
              
                j
                =
                0
              
              
                
                  L
                  v
                
                -
                1
              
            
            ⁢
            
              
            
            ⁢
            
              
                
                  c
                  ~
                
                j
                
                  (
                  B
                  )
                
              
              ⁡
              
                (
                
                  modulo
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                )
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        41
      
    
  




and each vector {tilde over (c)}(B) of category B, can be expressed in terms of a vector comprising integer components, , in DLv as for y in equation 26 from the relation {tilde over (c)}j(B)=κj=+1⁄2, while the radius of the vector remains unchanged.
According to the invention, a sign parity check sum for code vectors {tilde over (c)}, is defined.




  
    
      
        
          
            sgn
            ⁢
            
              
            
            ⁢
            
              par
              ⁡
              
                (
                
                  c
                  ~
                
                )
              
            
          
          =
          
            
              ∑
              
                j
                =
                0
              
              
                
                  L
                  v
                
                -
                1
              
            
            ⁢
            
              
            
            ⁢
            
              
                sgn
                ⁡
                
                  (
                  
                    
                      c
                      ~
                    
                    j
                  
                  )
                
              
              ⁢
              
                (
                
                  modulo
                  ⁢
                  
                    
                  
                  ⁢
                  2
                
                )
              
            
          
        
        ,
        
          

        
        ⁢
        where
      
    
    
      
        eq
        .
        
          
        
        ⁢
        42
      
    
  
  
    
      
        
          sgn
          ⁡
          
            (
            
              
                c
                ~
              
              j
            
            )
          
        
        =
        
          {
          
            
              
                
                  0
                  ,
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        c
                        ~
                      
                      j
                    
                  
                  ≥
                  0
                
              
            
            
              
                
                  1
                  ,
                
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        c
                        ~
                      
                      j
                    
                  
                  <
                  0.
                
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        43
      
    
  




It is observed that all class-leader vectors {tilde over (c)}E, Pm can be constructed from class-leader root-vectors {tilde over (c)}F, Pm′, for 0≦m′<, where MF, is the number of root classes, Fm′, each comprising one class-leader root-vector {tilde over (c)}F, Pm′. The The required codebook size, e.g., is substantially reduced by doing so for most codes based on E-lattices of practical interest. Also, the encoding complexity is reduced, since not all class leader vectors need to be searched during the encoding. According to the invention, preferably the class-leader root-vectors are searched. In the preferred embodiment, there is a small additional computational load due to searching for category-B vectors providing minimum distortion. A class-leader root-vector is composed of LF different values μlε, each occurring wl times, where wl also being referred to as the weight of μl.
Similar to the class-leader vector in equation 7, the class-leader root-vector can be expressed as



  
    
      
    
    ⁢
    
      eq
      .
      
        
      
      ⁢
      44
    
  




  
    
      
        
          
            
              c
              ~
            
            
              F
              ,
              
                P
                
                  m
                  ′
                
              
            
          
          =
          
            
              [
              
                
                  
                    
                      c
                      
                        F
                        ,
                        
                          P
                          
                            m
                            ′
                          
                        
                        ,
                        0
                      
                    
                  
                  
                    
                      c
                      
                        F
                        ,
                        
                          P
                          
                            m
                            ′
                          
                        
                        ,
                        1
                      
                    
                  
                  
                    ...
                  
                  
                    
                      c
                      
                        F
                        ,
                        
                          P
                          
                            m
                            ′
                          
                        
                        ,
                        
                          
                            L
                            v
                          
                          -
                          1
                        
                      
                    
                  
                
              
              ]
            
            T
          
        
      
    
    
      
        
          
            =
            
              
                
                  
                    [
                    
                      
                        μ
                        0
                      
                      ⁢
                      
                        μ
                        
                          0
                          ⁢
                          
                            
                          
                        
                      
                      ⁢
                      ...
                      ⁢
                      
                        
                      
                      ⁢
                      
                        μ
                        0
                      
                    
                  
                
                
                  
                    
                      μ
                      1
                    
                    ⁢
                    
                      μ
                      
                        1
                        ⁢
                        
                          
                        
                      
                    
                    ⁢
                    ...
                    ⁢
                    
                      
                    
                    ⁢
                    
                      μ
                      1
                    
                  
                
                
                  ...
                
                
                  
                    
                      
                        
                          μ
                          
                            
                              L
                              F
                            
                            -
                            1
                          
                        
                        ⁢
                        
                          μ
                          
                            
                              L
                              F
                            
                            -
                            1
                          
                        
                        ⁢
                        
                          
                        
                        ⁢
                        ...
                        ⁢
                        
                          
                        
                        ⁢
                        
                          μ
                          
                            
                              L
                              F
                            
                            -
                            1
                          
                        
                      
                      ]
                    
                    T
                  
                
              
              
                
                  
                    ←
                    
                      
                        w
                        0
                      
                      →
                    
                  
                
                
                  
                    ←
                    
                      
                        w
                        1
                      
                      →
                    
                  
                
                
                  ...
                
                
                  
                    ←
                    
                      
                        w
                        
                          
                            L
                            F
                          
                          -
                          1
                        
                      
                      →
                    
                  
                
              
            
          
          ,
        
      
    
  



where, μl≧0 for all class-leader root-vectors. The respective number, Nm′(F), of class-leader vectors of a particular category equals the number of possible sign permutations related to the weights, wl, of non-zero coordinate values, μl≈0 for the class-leader root-vector class. For a category A class-leader root-vector of equivalence class Em′, this number is




  
    
      
        
          .
          
            N
            
              m
              ′
            
            
              (
              F
              )
            
          
        
        =
        
          
            ∏
            
              l
              =
              
                0
                :
                
                  
                    μ
                    l
                  
                  ≠
                  0
                
              
            
            
              
                L
                F
              
              -
              1
            
          
          ⁢
          
            
          
          ⁢
          
            
              (
              
                
                  w
                  l
                
                +
                1
              
              )
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        45
      
    
  




For a category B class-leader root-vector, the number of possible sign permutations is considered for pair wise components in order to maintain sign parity. Accordingly, the respective numbers of sign permutations for the cases of even and odd sign parity are




  
    
      
        
          N
          
            m
            ′
          
          
            (
            F
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        (
                        
                          
                            ∏
                            
                              l
                              =
                              
                                0
                                :
                                
                                  
                                    μ
                                    l
                                  
                                  ≠
                                  0
                                
                              
                            
                            
                              
                                L
                                F
                              
                              -
                              1
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            (
                            
                              
                                w
                                l
                              
                              +
                              1
                            
                            )
                          
                        
                        )
                      
                      +
                      1
                    
                    2
                  
                  ,
                
              
              
                
                  for
                  ⁢
                  
                    
                      
                    
                    ⁢
                    
                      
                    
                  
                  ⁢
                  even
                  ⁢
                  
                    
                  
                  ⁢
                  sign
                  ⁢
                  
                    
                  
                  ⁢
                  parity
                
              
            
            
              
                
                  
                    
                      
                        (
                        
                          
                            ∏
                            
                              l
                              =
                              
                                0
                                :
                                
                                  
                                    μ
                                    l
                                  
                                  ≠
                                  0
                                
                              
                            
                            
                              
                                L
                                F
                              
                              -
                              1
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            (
                            
                              
                                w
                                l
                              
                              +
                              1
                            
                            )
                          
                        
                        )
                      
                      -
                      1
                    
                    2
                  
                  ,
                
              
              
                
                  for
                  ⁢
                  
                    
                      
                    
                    ⁢
                    
                      
                    
                  
                  ⁢
                  odd
                  ⁢
                  
                    
                  
                  ⁢
                  sign
                  ⁢
                  
                    
                  
                  ⁢
                  
                    parity
                    .
                  
                
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        46
      
    
  




The number of root classes for different shells of the Gosset, E8, are also listed in table 2.
As an example to demonstrate how to construct the class-leader vectors from the class-leader root-vectors, the class-leader vectors for a shell with radius 2, corresponding to u=2 are included in table 3.







TABLE 3







Class-leader root-vectors and corresponding class-leader vectors, u = 2.









Cate-




gory
{tilde over (c)}F,Pm′
{tilde over (c)}E,Pm





A
[ 1 0 0 0 0 0 0 0 ]T




  
    
      
        
          
            [
            
              
            
            ⁢
            
              1
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                0
                ⁢
                
                  
                
                ⁢
                0
                ⁢
                
                  
                
                ⁢
                0
                ⁢
                
                  
                
                ⁢
                0
                ⁢
                
                  
                
                ⁢
                0
                ⁢
                
                  
                
                ⁢
                0
                ⁢
                
                  
                
                ⁢
                0
              
              ⁢
              
                
              
              -
              1
            
            ]
          
          T
        
      
    
  
   






 


A
[ 1/2 1/2 1/2 1/2 0 0 0 0 ]T




  
    
      
        
          
            
              
                
                  
                    
                      
                        
                          
                            
                              [
                              
                                
                              
                              ⁢
                              
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                              
                              ⁢
                              
                                
                              
                              ]
                            
                            T
                          
                        
                      
                      
                        
                          
                            
                              [
                              
                                
                              
                              ⁢
                              
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  1
                                  /
                                  2
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                0
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  
                                    
                                      —
                                    
                                  
                                  
                                    
                                      
                                        1
                                        /
                                        2
                                      
                                    
                                  
                                
                              
                              ]
                            
                            T
                          
                        
                      
                    
                  
                
                
                  
                    
                      
                        [
                        
                          
                        
                        ⁢
                        
                          
                            1
                            /
                            2
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            1
                            /
                            2
                          
                          ⁢
                          
                            
                          
                          ⁢
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          0
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              
                                —
                              
                            
                            
                              
                                
                                  1
                                  /
                                  2
                                
                              
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              
                                —
                              
                            
                            
                              
                                
                                  1
                                  /
                                  2
                                
                              
                            
                          
                        
                        ⁢
                        
                          
                        
                        ]
                      
                      T
                    
                  
                
              
            
          
          
            
              
                
                  [
                  
                    
                  
                  ⁢
                  
                    
                      1
                      /
                      2
                    
                    ⁢
                    
                      
                    
                    ⁢
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    0
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        
                          —
                        
                      
                      
                        
                          
                            1
                            /
                            2
                          
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        
                          —
                        
                      
                      
                        
                          
                            1
                            /
                            2
                          
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        
                          —
                        
                      
                      
                        
                          
                            1
                            /
                            2
                          
                        
                      
                    
                  
                  ⁢
                  
                    
                  
                  ]
                
                T
              
            
          
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              0
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
  
   






 


B
[ 3/4 1/2 1/2 1/2 1/2 1/2 1/2 1/2 ]T




  
    
      
        
          
            [
            
              
            
            ⁢
            
              
                3/4
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                3/4
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                3/4
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                3/4
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      3/4
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      3/4
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      3/4
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
    
      
        
          
            [
            
              
            
            ⁢
            
              
                1
                /
                2
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      1
                      /
                      2
                    
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    —
                  
                
                
                  
                    
                      3/4
                    
                  
                
              
            
            ⁢
            
              
            
            ]
          
          T
        
      
    
  
   













In the application of lattice vector quantization, the number of code vectors is limited and only a limited set of the vectors constructed by the lattice rule is considered.
The computational burden of quantization processing is significantly reduced due to example embodiments of the invention as explained above.
Lattice vector quantizers in general are very well suited for quantization also for the reason that no explicit codebook has to be stored but could be determined from, e.g., its generator matrix. When lattices are used for generating a codebook, the codebook will be structured, thereby facilitating fast search for code vectors. In brief, lattice vector quantization is an efficient example of quantization.
FIG. 13 depicts a basic flowchart for quantization according to an embodiment of the invention. For a vector x to be quantized, it is preferably normalized to a vector c of radius 1 (131) to simplify subsequent processing. Each component of the (normalized) vector is separated into respective magnitude and sign to form a magnitude vector and a sign vector (132),

cmag=[|c0| |c1| . . . |cLv−1|]T, and  eq. 47

csgn=[sgn(c0) sgn(c1) . . . sgn(cLv−1)]T.  eq. 48

The magnitude vector is permuted to arrange the components in decreasing order (133),

c*mag=Pc·cmag,  eq. 49

and the sign vector is permuted accordingly (133),

c*sgn=PC·csgn,  eq. 50

Using component-wise notion, the permuted magnitude vector can also be written

c*mag=[c*mag,0c*mag,1 . . . c*mag,Lv−1]T, and  eq. 51

c*sgn=[c*sgn,0c*sgn,1 . . . c*sgn,Lv−1]T.  eq. 52

A metric is usually considered a quantity to be maximized. However, this specification preferably refers to a quantity to be minimized, similar to a distance. The difference merely resides in a different sign. The negative distance is maximized when the distance is minimized. A distortion metric Dm′, preferably a Euclidean distance, is determined for, preferably, each of the class-leader root-vectors, {tilde over (c)}F, Pm′, in relation to the permuted magnitude vector c*mag (134),




  
    
      
        
          
            D
            
              m
              ′
            
          
          =
          
            
              
              
                
                  
                    c
                    ~
                  
                  
                    F
                    ,
                    
                      P
                      
                        m
                        ′
                      
                    
                  
                
                -
                
                  c
                  mag
                  *
                
              
              
            
            2
          
        
        ,
        
          0
          ≤
          
            m
            ′
          
          <
          
            
              M
              F
              
                (
                
                  E
                  
                    L
                    v
                  
                
                )
              
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        53
      
    
  




Similar to equations 33 and 34 and as an alternative to the distortion as expressed in equation 53, the correlation could be maximized. Equivalently, the negative correlation could be minimized, since the distortion measure in equation 53 equals




  
    
      
        
          
            D
            
              m
              ′
            
          
          =
          
            Ç
            -
            
              2
              ⁢
              
                
                  
                    c
                    ~
                  
                  
                    F
                    ,
                    
                      P
                      
                        m
                        ′
                      
                    
                  
                
                ·
                
                  c
                  mag
                  *
                
              
            
          
        
        ,
        
          0
          ≤
          
            m
            ′
          
          <
          
            M
            F
            
              (
              
                E
                
                  L
                  v
                
              
              )
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        54
      
    
  




where  is a constant corresponding to the lengths of vectors {tilde over (c)}F, Pm′ and c*mag. For normalized vectors {tilde over (c)}F, Pm′, and c*mag,  consequently equals 2. The subsequent processing conditionally depends on whether the selected class-leader root-vector is of category A or B and the distortion Dm′, determined initially, conditionally requires to be transformed to correspond to the distortion of the class-leader vectors (135). The class-leader root-vector providing the least (transformed) distortion, Dm′(t), is selected for the output of the quantization processing (136).




  
    
      
        
          m
          Q
          ′
        
        =
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              
                
                  m
                  ′
                
                =
                0
              
              ,
              1
              ,
              ...
              ⁢
              
                
              
              ,
              
                
                  M
                  
                    F
                    ,
                    u
                  
                  
                    (
                    
                      E
                      
                        L
                        v
                      
                    
                    )
                  
                
                -
                1
              
            
          
          ⁢
          
            
              D
              
                m
                ′
              
              
                (
                t
                )
              
            
            .
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        55
      
    
  




FIG. 14 shows a simplified flowchart for determining a transformed distortion metric. For a class-leader root-vector of category A (141), minimizing the distortion in equation 53 and corresponding to an equivalence class Em′, the class-leader vector which achieves the lowest distortion is determined by the sign distribution of the permuted sign vector c*sgn which is identical to the sign distribution of the class-leader vector. In this case, the distortion is the same for the class-leader vector as for the class-leader root-vector of category A (142). Consequently, transformation of distortion as determined for the class-leader root-vector is not required for vectors of category A (142),

Dm′(t)=Dm′, if category A,m′=m′Q.  eq. 56

For a class-leader root-vector {tilde over (c)}F, Pm′ of category B, {tilde over (c)}F, Pm′(B), there are two cases to consider depending on sign parity of the permuted sign vector and the class-leader root-vector. In case the sign parities are identical (143), the calculated distortion does not require to be transformed (142), since it is the minimum distortion achievable by all respective class-leader vectors and, consequently,

Dm′(t)=Dm′, if category B, case 1, m′=m′Q.  eq. 57

For case 1 and for the class-leader root-vector of category B providing the smallest distortion in equation 53, the class-leader vector {tilde over (c)}F, Pm′(B), has identically the same sign distribution as the permuted sign vector c*sgn (143), as was also the case for category A above.
In case the sign parity of the permuted sign vector c*sgn differs from sign parity of the class-leader root-vector for a class-leader root-vector {tilde over (c)}F, Pm′(B) of category B, case 2, the sign of a coordinate of the class-leader root-vector differs from c*sgn. Denote this coordinate by j0. The transformed distortion then is




  
    
      
        
          
            
              
                
                  D
                  
                    m
                    ′
                  
                  
                    (
                    t
                    )
                  
                
                =
                
                  
                    
                      
                        D
                        
                          m
                          ′
                        
                      
                      ⁡
                      
                        (
                        
                          
                            c
                            
                              mag
                              ,
                              
                                j
                                0
                              
                            
                            *
                          
                          -
                          
                            
                              c
                              ~
                            
                            
                              F
                              ,
                              
                                P
                                
                                  m
                                  ′
                                
                              
                              ,
                              
                                j
                                0
                              
                            
                            
                              (
                              B
                              )
                            
                          
                        
                        )
                      
                    
                    2
                  
                  +
                  
                    
                      (
                      
                        
                          c
                          
                            mag
                            ,
                            
                              j
                              0
                            
                          
                          *
                        
                        +
                        
                          
                            c
                            ~
                          
                          
                            F
                            ,
                            
                              P
                              
                                m
                                ′
                              
                            
                            ,
                            
                              j
                              0
                            
                          
                          
                            (
                            B
                            )
                          
                        
                      
                      )
                    
                    2
                  
                
              
            
          
          
            
              
                
                  =
                  
                    
                      D
                      
                        m
                        ′
                      
                    
                    +
                    
                      4
                      ⁢
                      
                        
                          c
                          
                            mag
                            ,
                            
                              j
                              0
                            
                          
                          *
                        
                        ·
                        
                          
                            c
                            ~
                          
                          
                            F
                            ,
                            
                              Pm
                              ′
                            
                            ,
                            
                              j
                              0
                            
                          
                          
                            (
                            B
                            )
                          
                        
                      
                    
                  
                
                ,
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            if
            ⁢
            
              
            
            ⁢
            category
            ⁢
            
              
            
            ⁢
            B
          
          ,
          
            
          
          ⁢
          
            case
            ⁢
            
              
            
            ⁢
            2
          
          ,
          
            
              m
              
                ′
                ⁢
                
                  
                
              
            
            =
            
              
                m
                Q
                ′
              
              .
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        58
      
    
  




The permuted sign vector c*sgn is corrected accordingly by increasing the permuted sign-vector component in position j0 by 1 (modulo 2),

c*sgn, j0←c*sgn,j0+1(modulo 2).  eq. 59

This operation corresponds to an XOR operation ⊕ inverting a sign bit in position j0 in a binary representation of c*sgn.
The position j0 is determined from the minimum of the second term in the second equality of equation 58 corresponding to additional distortion,




  
    
      
        
          j
          0
        
        =
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              0
              ≤
              
                m
                ′
              
              <
              
                L
                v
              
            
          
          ⁢
          
            
              c
              
                mag
                ,
                j
              
              *
            
            ·
            
              
                
                  c
                  ~
                
                
                  F
                  ,
                  
                    P
                    
                      m
                      ′
                    
                  
                  ,
                  j
                
                
                  (
                  B
                  )
                
              
              .
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        60
      
    
  




As mentioned above, one or more indices are preferred to the code vector for information transfer on a communications channel. For this purpose, an indexing machine and related processing has been developed beyond previous work of e.g. Pieter and Schalkwijk.
Provided a permutation matrix P, a permuted sign vector c*sgn and a root class Fm′Q, for which equation eq. 55 applies, the indexing is preferably performed as follows and schematically illustrated in the flowchart of FIG. 15 and implemented in processing equipment (191), (194) of FIG. 19.

    
    
        Determine (151) equivalence classes EmQ (111-113), (114) corresponding to the selected root class Fm′Q (115), (116) as illustrated in example FIG. 11 and table 3.
        Based upon the permuted sign vector c*sgn, select (152) the equivalence class EmQ, or equivalently its class leader, from the equivalence classes corresponding to the selected root class as described above in relation to the flowchart of FIG. 13.
        Determine (153) index offset  as illustrated in FIG. 11.
        Determine (153) a permutation index iPc with respect to matrix Pc, preferably according to previous work of Pieter and Schalkwijk.
    
    


The quantization index codeword is then determined (154) as described in relation to equation 36 on page 26 considering permutation matrix Pc,




  
    
      
        
          
            i
            
              Q
              ,
              sp
            
          
          =
          
            
              i
              
                P
                c
              
            
            +
            
              i
              
                off
                ,
                
                  E
                  
                    m
                    Q
                  
                
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        61
      
    
  




where the permutation matrix Pc of the normalized vector c, output from, e.g., the indexing provided by Pieter and Schalkwijk, replaces P of equation 36. The offset  is set in relation to the equivalence class of interest EmQ and is incorporated in the index iQ,sp for communication on the communications channel. In FIG. 11, index range grouping in relation to example root-vector classes is demonstrated. In the example of FIG. 11, root class F0 (115) represents example equivalence classes E0 (111), E1 (112), E2 (113) and example root class F1 (116) corresponds to equivalence class E3 (114). The equivalence class offsets ioff, E0 and ioff, E3 are also offsets for the root classes F0 and F1, respectively. The equivalence class offsets ioff, E0, ioff, E1, ioff, E2 and ioff, E3 are preferably stored in read-only memory.
According to one embodiment of the invention, indexing of class-leader vectors is performed on the basis of the sign vector c*sgn in equation 52. c*mag in equation 51 is preferably indexed similarly, though c*mag is not necessarily binary, while c*sgn is binary. For class leaders in category B, the sign vector c*sgn with corrected position j0 as in equation 59 is preferably indexed.
Codeword representation by a class-leader root-vector in place of a plurality of class-leader vectors due to the suggested sign separation and parity constraint provides substantial complexity reduction according to preferred embodiments of the invention. Correspondingly, preferred embodiments of the invention provide reduced vector searches, searching an equivalence root class instead of searching a plurality of equivalence classes for a codeword providing least distortion.
The invention identifies the fact that the equivalence classes, E, related to one equivalence root class, F, are based on vector components with the same amplitudes but with different signs. For an equivalence root class, F, one of the equivalence classes need be identified at the decoder to get information on the sign distribution.
The specific equivalence class is preferably determined by index comparison for the equivalence root class, the index range of which corresponds to the index range of one or more equivalence classes as illustrated in FIG. 11.
For an incoming vector quantization index iQ, sp, preferably with assistance of stored index offsets ioff, mQ, the class-leader root-vector that has been identified by the encoder and a corresponding sign distribution index identifying the equivalence class leader are determined. After removal of offset, the resulting index, iP, is input to a decoder, preferably operating in accordance with the suggestions of Schalkwijk and Pieter. From the class-leader root-vector and the sign distribution indicating negative vector components, the relevant information required by the decoder for determining the equivalence class-leader is available.
For all class-leader root-vectors, the weights wl and the amplitudes μl, 0≦l<LP, are preferably stored without signs. The decoder then modifies/adjusts these values in accordance with the sign adjustments in equation 59 from the sign distribution of the decoded index as received to produce a specific class-leader vector. The weights wl are adjusted correspondingly. The resulting weights wl(adj), omitting “(adj)” in the flow chart of FIG. 16 as described below for reasons of simplicity, and amplitudes are preferably included in the decoding according to Schalkwijk and Peter as follows.
Weights and amplitudes appear in pairs wl, μl. As earlier described, the index iP comprises information on the sequential order in which the amplitudes are combined in a vector, referred to as the permutation of the class-leader vector. The sequence lc=[l0 l1 l2 . . . lLv−1] in the flow chart in FIG. 16 describes how to arrange the sequences of wl(adj) and (1−2c*sgn, l)·μl, including also the adjusted signs. Except for the adjusted signs, once the sequence lc is known, the output code vector {tilde over (x)}iQ is determined as

{tilde over (x)}iQ=[μl0μl1μl2μLv−1].  eq. 62

FIG. 16 illustrates schematically a flow-chart of an example decoder according to the invention. Index offsets, ioff, mQ, are stored in the receiver for each equivalence class, c.f. FIG. 11 (111, 112, 113). As illustrated in FIG. 11, some of the offsets are also index offsets of a particular root class (115, 116). Also, a particular offset for a root class (115) corresponds to an equivalence class and sign distribution (111, 112, 113). The stored offsets of root classes (115, 116) identify a particular root class (115, 116) from a received index. The stored offsets identify a particular equivalence class, which corresponds to a particular sign distribution. The identified equivalence class is transformed into a sign distribution. The weights are adapted to this sign distribution (1602) and the index offset is preferably subtracted from the received index (1601) to form a residual index, iP, (1602) for processing according to the principles of Schalkwijk and Pieter.
After initialization (1603), initiating values, μl, and weights, wl, for lε[0, LP−1] to pre-stored values of the class-leader root-vector corresponding to the offset or index range, a range is determined (1604), such that for some mε[0, Lv−1] there is an lm fulfilling




  
    
      
        
          
            
              ∑
              
                l
                =
                0
              
              
                
                  l
                  m
                
                -
                1
              
            
            ⁢
            
              
            
            ⁢
            
              
              
                I
                
                  
                    c
                    
                      P
                      ,
                      m
                    
                  
                  =
                  
                    μ
                    l
                  
                
              
              
            
          
          ≤
          i
          <
          
            
              ∑
              
                l
                =
                0
              
              
                l
                m
              
            
            ⁢
            
              
            
            ⁢
            
              
              
                I
                
                  
                    c
                    
                      P
                      ,
                      m
                    
                  
                  =
                  
                    μ
                    l
                  
                
              
              
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        63
      
    
  




where IcP,mμl is an index sub-range of equation 38, omitting the  ̃ in {tilde over (c)}P,m to simplify typography. The quantized code vector component is allotted (1605) its magnitude corresponding to the determined range and the index is updated by subtracting (1606) the amount determined earlier (1604) and updating the weights (1607). The recursion proceeds similarly for the next component (1608) until all vector components are determined (1609) and the magnitudes and weights, and consequently the code vector, results (1610).
The encoder and decoder preferably store weights, wl, amplitudes, μl, a mode or category flag, M, indicating category A or B for each of the class-leader root-vectors of the code. Also, a sign-parity flag, sgnpar({tilde over (c)}), indicating odd or even parity of the binary sign vector c*sgn is preferably stored at least for class-leader root-vectors of category B.
A distribution of signs σ1 indicating number of negative signs to transform a class-leader root into a class-leader vector is transferred from the encoder to the decoder over the communications channel as need be.
As a non-exclusive example, consider a class-leader root-vector of a single non-zero amplitude 2 of weight 3 with one negative sign, for a vector of length 5. For a class-leader root-vector of [2 2 2 0 0], the class-leader vector is then [2 2 0 0 −2], remembering that class-leader vectors have their components sorted in decreasing order, c.f. equation 7.
For another example, consider a weight distribution of w0=3, w1=2 and a sign distribution of σ0, σ1. Considering the three positions corresponding to w0=3, there are 4 possible sign distributions of these positions














σ0
+/−









0
+ + +



1
+ + −



2
+ − −



3
− − −










Considering the two positions corresponding to w1=2, there are three possible sign distributions














σ1
+/−









0
+ +



1
+ −



2
− −










Considering all five positions, there are consequently 12 different sign distributions possible. The index subspace could then be subdivided in relation to, e.g., w1, such that an index offset of an integer multiple of three corresponds to a different sign distribution of the w0 positions.













σ0, σ1




















0, 0
0, 1
0, 2
1, 0
1, 1
1, 2
2, 0
2, 1
2, 2
3, 0
3, 1
3, 2























index
0
1
2
3
4
5
6
7
8
9
10
11









Of course, this is a simplified example for purpose of illustration. For most codes, there are more than two different weights. The index processing preferably subdivides the index (sub-)space for each additional weight under consideration.
For category A vectors, a particular value on a particular position of the sign distribution, e.g. θo, does not precondition a restricted number of possible sign distributions considering the remaining positions, since all sign distributions are possible for category A. For the simplified example above, all 12 sign distributions are possible for vectors of category A.
For vectors of category B, however, also the sign-parity constraint need be considered. Consider again the simplified example above. The value of σ0 provides a sign-parity contribution of σ0 (modulo 2). E.g., in case of a sign-parity contribution of π0 of the corresponding positions of the class-leader root vector, the sign-parity constraint for the subsequent positions corresponding to weight w1 in the simplified example will restrict the index sub-grouping in relation to the subsequent positions such that, for the simplified example, the index sub-grouping is preferably restricted to subsets fulfilling π1=π0+σ0 (modulo 2). Consequently, for the simplified example of twelve indices above, indices 0-2 and 6-8 are considered in case the first w0=3 positions of the class-leader root vector is of even sign parity, and indices 3-5 and 9-11 are considered in case the first w0=3 positions of the class-leader root vector are of odd sign parity.
In analogy with the simplified example, a preferred indexing of code vectors of category A and B, respectively, is described in more detail below.
As explained above, encoder and decoder preferably store weights, w1, and amplitudes, μ1, 0≦1<NF for class-leader root vectors of a root equivalence class F with NF weights for non-zero component amplitudes, μ1. Preferably, the weights and amplitudes are stored in read-only memory, ROM. Other non-limiting example storage media for the weights and amplitudes are random access memory, RAM, or magnetic or electro-magnetic storage devices for reading of amplitudes and weights into RAM, e.g. at startup. Of course, they may be communicated over the communications channel at the expense of an increased load on the communications channel.
In the encoder the stored weights and amplitudes are combined with a sign distribution σl, where 0≦σ1≦w1, 0≦1≦NF, to provide an index IE from which the decoder is capable of reconstructing the quantized vector. In effect, the decoder can be made to reconstruct the class-leader vector and the equivalence class from the index and pre-stored data.
To simplify notion, a helping function NE(A)({wl}l=mn) is defined for vectors of category A,




  
    
      
        
          
            
              N
              E
              
                (
                A
                )
              
            
            ⁡
            
              (
              
                
                  {
                  
                    w
                    l
                  
                  }
                
                
                  l
                  =
                  m
                
                n
              
              )
            
          
          =
          
            
              ∏
              
                l
                =
                m
              
              n
            
            ⁢
            
              
            
            ⁢
            
              (
              
                
                  w
                  l
                
                +
                1
              
              )
            
          
        
        ,
      
    
    
      
        eq
        .
        
          
        
        ⁢
        64
      
    
  




where 0≦NE(A)({wl}l=0NF−1)<IE, and where m and n are integers, n>m.
A corresponding helping function, NE(B)({wl}l=mn; π), is preferably defined for vectors of category B, where π denotes a sign-parity constraint and {wl}l=mn is the weight distribution as for vectors of category A.




  
    
      
        
          
            N
            E
            
              (
              B
              )
            
          
          ⁡
          
            (
            
              
                
                  {
                  
                    w
                    l
                  
                  }
                
                
                  l
                  =
                  m
                
                n
              
              ;
              π
            
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      N
                      E
                      
                        (
                        A
                        )
                      
                    
                    ⁡
                    
                      (
                      
                        
                          {
                          
                            w
                            l
                          
                          }
                        
                        
                          l
                          =
                          m
                        
                        n
                      
                      )
                    
                  
                  2
                
              
              
                
                  if
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      N
                      E
                      
                        (
                        A
                        )
                      
                    
                    ⁡
                    
                      (
                      
                        
                          {
                          
                            w
                            l
                          
                          }
                        
                        
                          l
                          =
                          m
                        
                        n
                      
                      )
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  even
                
              
            
            
              
                
                  
                    
                      
                        N
                        E
                        
                          (
                          A
                          )
                        
                      
                      ⁡
                      
                        (
                        
                          
                            {
                            
                              w
                              l
                            
                            }
                          
                          
                            l
                            =
                            m
                          
                          n
                        
                        )
                      
                    
                    +
                    1
                  
                  2
                
              
              
                
                  
                    
                      
                        
                          if
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              N
                              E
                              
                                (
                                A
                                )
                              
                            
                            ⁡
                            
                              (
                              
                                
                                  {
                                  
                                    w
                                    l
                                  
                                  }
                                
                                
                                  l
                                  =
                                  m
                                
                                n
                              
                              )
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          odd
                        
                        ,
                      
                    
                  
                  
                    
                      
                        π
                        ⁢
                        
                          
                        
                        ⁢
                        even
                      
                    
                  
                
              
            
            
              
                
                  
                    
                      
                        N
                        E
                        
                          (
                          A
                          )
                        
                      
                      ⁡
                      
                        (
                        
                          
                            {
                            
                              w
                              l
                            
                            }
                          
                          
                            l
                            =
                            m
                          
                          n
                        
                        )
                      
                    
                    -
                    1
                  
                  2
                
              
              
                
                  
                    
                      
                        
                          if
                          ⁢
                          
                            
                          
                          ⁢
                          
                            
                              N
                              E
                              
                                (
                                A
                                )
                              
                            
                            ⁡
                            
                              (
                              
                                
                                  {
                                  
                                    w
                                    l
                                  
                                  }
                                
                                
                                  l
                                  =
                                  m
                                
                                n
                              
                              )
                            
                          
                          ⁢
                          
                            
                          
                          ⁢
                          odd
                        
                        ,
                      
                    
                  
                  
                    
                      
                        
                          π
                          ⁢
                          
                            
                          
                          ⁢
                          odd
                        
                        ,
                      
                    
                  
                
              
            
          
        
      
    
    
      
        eq
        .
        
          
        
        ⁢
        65
      
    
  




where NE(A)({wl}l=0NF−1), NE(B)({wl}l=0NF−1; π)<IE.
The helping functions, NE(A)({wl}l=0NF−1), NE(B)({wl}l=0NF−1; π), correspond to the size of the index space for sign permutations. For category B vectors, it corresponds to the size of the index space for sign permutations given the sign-parity constraint π for the class-leader root-vector. The helping function also corresponds to the number of class-leader vectors and equivalence classes that can be produced from the current class-leader root-vector, for category B preconditioned on the sign-parity constraint.
The preferred index processing of code vectors of category A, forming an example component (142) of FIG. 14 and adopting the principles of FIG. 12, is schematically illustrated in FIG. 17. The target index, IE, and an iteration counter, k, are initialized (171) and the weights wl preferably loaded into operational memory of a processing entity. For each iteration, the index is updated (172, 175). Preconditioned on the iteration number, k, it is incremented by σk·NE(A)({wl}i=k+1NF−1) (172) or σk (175), where NF is the number of weights of non-zero component amplitudes, μ1, for the class-leader root-vector.
An example for non-zero weight distribution w0=1, w1=3, w2=3, and sign distribution σ0=1, σ1=0, σ2=1 illustrates the processing of FIG. 17 for target class-leader vector [μ1 μ1 μ1 μ2 μ2−μ2−μ0]. According to the helping function, there are NE(A)(1, 3, 3)=32 equivalence classes related to the class-leader root vector of this example. After the first iteration, the candidate for index IE is determined to 16. The second iteration does not change the candidate index since σ1=0. After the third iteration, the index is finally determined to 17 from the previous candidate index and σ2=1.
The preferred index processing of code vectors of category B, forming an example component (144) of FIG. 14 and adopting the principles of FIG. 12, is illustrated schematically in FIG. 18. The mode flag is set to M=1 to indicate category B (M=0 for category A). The target index, IE, and an iteration counter, k, are initialized (181) and the weights w1 preferably loaded into operational memory of a processing entity. A parity flag is initialized (181) to the preferably pre-stored sign-parity π of the class-leader root-vector corresponding to the class-leader vector of the equivalence class. For each iteration the candidate for index IE is updated (182, 185). For all but the last iteration, the candidate index is updated by a sum of index (sub-)space sizes NE(B)({w1}1=k+1NF−1; p*), where p* is adjusted candidate parity, adjusted for the parity of the various sign combinations corresponding to the various weights as illustrated above for the simplified example. As before, NF is the number of weights for non-zero component amplitudes, μ1. The adjustment is expressed in FIG. 18 as a summation modulo 2, indicated (182) by ⊕ for brevity even though t is not necessarily binary. For each iteration, the candidate parity is updated in relation to the sign distribution and the next weight and sign combinations are considered (183) until all but one non-zero weight(s) have been considered (184). Again, ⊕ denotes (183) a modulo-2 sum. For the last update of the candidate parity it is preferably verified that σNF−1−p is even, and an integer representing half of this amount increments the candidate index to form the final index for category B (185).
FIG. 19 illustrates a block diagram of example equipment (191) according to the invention. The equipment comprises an input (192) for inputting signals to be quantized or indexed, for which a block of data is represented by a vector x, and an output (193) providing signal codewords. According to different modes of the embodiment, the output signal carries codewords or indices corresponding to input vector x, or a normalized vector of radius 1 and a radius. In case indexing is not included in processing circuitry (194), a signal carrying code vectors is output (192) in one mode of operating an embodiment of the invention. For efficient encoding and decoding, the equivalence class offsets  are preferably stored in read only memory, ROM, flash memory or other storage medium (195). Processing circuitry (194) of the equipment (191) implements quantization as described above. Preferably, the processing circuitry implements indexing. Class-leader root-vectors are preferably stored in memory or other storage medium (195) to improve decoding speed or reduce amount of communicated data, and the processing circuitry (194) accesses (196) the storage medium (195) and reads memory or storage content (197). The processing circuitry also preferably accesses some random access memory, RAM, (194), (195) for its operations.
While the invention has been described in connection with specific embodiments thereof, it will be understood that it is capable of further modifications. This application is intended to cover any variations, uses, adaptations or implementations of the invention, not excluding software enabled units and devices, within the scope of subsequent claims following, in general, the principles of the invention as would be obvious to a person skilled in the art to which the invention pertains.

## Claims

1. A method of representing signal samples with quantized samples for communication over a communications channel characterized in that comprising:
quantizing, using a processor, the signal samples to signals corresponding to points of an E-lattice, wherein each quantized signal has a class-leader root-vector representative as determined including a sign distribution, a quantized signal being identified by the class-leader root vector representative and the sign distribution,
wherein the sign distribution is communicated over a communications channel;
wherein the quantization is minimizing a distortion criterion as determined from class-leader root-vectors of the E-lattice;
wherein the minimum is transformed as need be to form a minimum over the set of class leaders; and
wherein the distortion as determined from class-leader root-vectors of the E-lattice is conditionally transformed depending on a sign distribution of components of a vector representation of a signal sample to be quantized.

2. The method according to claim 1, comprising a conditional sign-parity update.

3. The method according to claim 2, wherein the signal sample representation includes inversion of a sign bit when sign parity of a signal sample and sign parity of a class-leader root-vector differ.

4. The method according to claim 1, wherein each signal sample is represented by a vector, for which each component comprises a magnitude and a sign bit and distortion determined from the one or more class-leader root-vectors is transformed when the sign parity of the vector representation differs from the sign parity of the class-leader root-vector.

5. The method according to claim 4, wherein the determined distortion is additively increased proportional to a product of the magnitude of the signal sample representation and a class-leader root-vector selected for providing minimum transformed distortion for a component for which the sign bits of an ordered signal sample and the class-leader root-vector differ.

6. The method according to claim 4, wherein an index is determined for a vector comprising the magnitude components.

7. The method according to claim 1, wherein the cardinality of a set of said class-leader root-vectors of the E-lattice is smaller than the cardinality of a set of class leaders for said points of the E-lattice.

8. The method according to claim 1, wherein the distortion criterion comprises squared Euclidean distance.

9. The method according to claim 1, wherein an index is determined representing a vector comprising the sign distribution.

10. The method according to claim 9, wherein the index is determined for an adjusted vector, wherein a vector component has been adjusted corresponding to a sign inversion.

11. The method according to claim 1, wherein the quantized samples are communicated over the communications channel by means of offset codewords determined by, for each codeword, offsetting an index achieved for a sequentially ordering of components of a data block of magnitudes according to size, and wherein the offset represents a particular equivalence class corresponding to the root class representative of the quantized signal.

12. The method according to claim 1, wherein the E-lattice fulfills the requirement


ELv=DLv∪(DLv+v):v=[1⁄2 . . . 1/2],

where





  
    
      D
      
        L
        v
      
    
    ⁢
    
      :
    
    ⁢
    
      
    
    ⁢
    y
  
  ∈
  
    {
    
      
        
          
            [
            
              
                y
                0
              
              ⁢
              
                y
                1
              
              ⁢
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              
                y
                
                  
                    L
                    v
                  
                  -
                  1
                
              
            
            ]
          
          ⁢
          
            :
          
          ⁢
          
            
          
          ⁢
          
            y
            j
          
        
        ∈
        
                    ⁢
          Z
        
      
      ,
      
        
          
            ∑
            
              j
              =
              0
            
            
              
                L
                v
              
              -
              1
            
          
          ⁢
          
            
          
          ⁢
          
            y
            j
          
        
        ≡
        
          0
          ⁢
          
            (
            
              modulo
              ⁢
              
                
              
              ⁢
              2
            
            )
          
        
      
    
    }
  



is the checkerboard lattice, or D-lattice, of the same number of dimensions, Lv, as the E-lattice for integers .