Abstract:
The invention relates to a device and a method for storing binary data in a storage device, in which the binary data is transformed to and stored as ternary data. The storage device uses memory cells capable of storing three states. The device and method furthermore are configured to identify and correct falsified ternary data when reading and outputting the data from storage device.

Description:
FIELD 
       [0001]    The invention relates to a method and device for storing data, particularly for storing binary data in a memory using ternary storage. A method and corresponding circuitry are provided allowing the correction of stored binary data. 
       BACKGROUND 
       [0002]    Data processing systems of today operate on data represented to any processing device in a binary format. Storage of these data takes place in a memory device typically using binary storage systems comprising storage cells. Typically each storage cell stores one bit, i.e. the storage cell is capable of storing two distinguishable states representing the states of the bit, i.e. either one or zero. A stream of binary data that is to be stored can be passed to a storage device for storing. The storage device is adapted and configured to set the memory cells corresponding to the input data stream when receiving the data for storing and to read the data from the memory cells upon request. 
         [0003]    However the data read out from a memory can differ from the original data, i.e. the data that were provided for storing for variable reasons. In one example a storage cell may be faulty. 
         [0004]    Numerous algorithms and corresponding solutions for identifying and correcting bit errors in stored data are known to prevent any falsification of data when reading stored data from binary memory cells. 
         [0005]    Modern memory devices may use ternary memory or storage cells, i.e. cells adapted and configured for storing data, wherein each cell is adapted and configured to distinguish between three states. These memories may be used in combination with binary processing devices that provide binary data, i.e. wherein the information is represented in bits, each bit representing a binary value. So when storing binary data in a ternary memory device, i.e. a device using ternary storage cells, there must be some arrangement in the memory device not only for converting the binary to ternary data upon storage and for converting ternary to binary data when reading, but also for providing correction means to ensure that the read out data equals the data provided upon storing. 
     
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         [0006]    The following figures shall illustrate the invention, wherein 
           [0007]      FIG. 1  depicts an encoder; 
           [0008]      FIG. 2  depicts a circuit arrangement for storing data sequences; 
           [0009]      FIG. 3  depicts circuitry for correcting an error; 
           [0010]      FIG. 4  depicts an arrangement of the circuitry depicted in  FIGS. 1-3 ; 
           [0011]      FIG. 5  depicts an embodiment of a circuit arrangement for storing data sequences; 
           [0012]      FIGS. 6   a  and  6   b  depict embodiments of circuitry for transforming binary to ternary values; 
           [0013]      FIGS. 7   a  and  7   b  depict embodiments of circuitry for transforming ternary to binary values; 
           [0014]      FIGS. 8   a ,  8   b  and  8   c  depict embodiments of implementations of partial circuit F; 
           [0015]      FIG. 9  depicts a partial circuit; and 
           [0016]      FIG. 10  depicts circuitry for error recognition. 
       
    
    
     DETAILED DESCRIPTION 
       [0017]    The invention will now be described by means of embodiments. Note that the embodiments shall be understood as illustration only but not restricting the invention. 
         [0018]      FIG. 1  illustrates an encoder Cod  11  encoding a binary data sequence u=u 1 , . . . , u k  of k bits, wherein, k≧2, to an encoded binary data sequence x=x 1 , . . . , x n  of n bits with n&gt;k corresponding to a linear code C. 
         [0019]    The linear code C may, as is usual, be described by a (k, n) generator matrix G with k rows and n columns, and by a (n−k, n) parity check matrix H, also referred to as H-matrix. The encoded binary data sequence x is determined from the binary data sequence u by 
         [0000]        x =( x   1   , . . . ,x   n )=( u   1   , . . . ,u   k )· G=u≠G   (1)
 
         [0020]    The k-bit data sequence u=u 1 , . . . , u k  is available at the k-bit input line  12  of the encoder Cod  11 , and the data sequence x=x 1 , . . . , x n  determined according to equation (1) is output on the n-bit output line  13 . 
         [0021]      FIG. 2  illustrates a block diagram of a circuit arrangement Schspei  21  for storing data sequences. The circuit arrangement Schspei  21  comprises a data input  22  of at least n bits for the input of a binary data sequence x=x 1 , . . . , x n  of word size n, an address input  24  for the input of a binary address a=a 1 , . . . , a l  with l address bits, wherein l≧2, and a data output  23  of at least n bits for the output of an n-bit binary data sequence x′=x′ 1 , . . . , x′ n . The data sequence x is encoded by using a code C. Additional control signals such as, for instance, the read signal and the write signal that are common for memory circuits and are known to a person skilled in the art are not illustrated in  FIG. 2 . 
         [0022]    The circuit arrangement Schspei  21  is configured such that it is possible to write a binary data sequence x under an address a, to store corresponding values, and to read out a binary data sequence at a later point in time, for instance, also under the address a. The binary data available at the inputs are transformed to analog values in the circuit arrangement Schspei and stored as analog values, for example voltages or electric charges, in memory cells. These analog values may, depending on the belonging of the analog value to three different intervals, be interpreted as ternary values, as is, for instance, proposed in P. J. Krick, THREE-STATE MNOS FET MEMORY ARRAY, IBM technical disclosure bulletin, vol. 18, 12, 1976, pp. 4192-4193. The stored values may be designated as analog values in general and, if one intends to emphasize their belonging to the three intervals considered, also as ternary values. The value stored in a memory cell is also referred to as the condition of the memory cell. 
         [0023]    On reading out, the ternary values stored are re-transformed to binary values and read out as binary values, so that the circuit arrangement Schspei  21  behaves in its external behavior like a binary memory, although the values are internally stored as ternary values. 
         [0024]    When data is stored in the circuit arrangement Schspei, it is possible that these data are modified incorrectly, so that a binary data sequence x=x 1 , . . . , x n  written under the address a, and which is stored in a ternary manner in the circuit arrangement, differs from a binary data sequence x′=x′ 1 , . . . , x′ n  read out under the same address after a certain time. So if x=x′ applies, no error has occurred, but if x≠x′ applies, then an error has occurred. If a stored ternary value changes due to an error, this error in a ternary value may have the effect that one bit or several bits in a read-out binary data sequence change. A single error in a ternary, stored value may result in a multi bit error in the binary data sequence. 
         [0025]    So far, no circuit arrangement and no method for error correction are known which enable one to correct those single bit and multi bit errors in the read-out binary data sequences that occur due to single errors in the ternary stored values. 
         [0026]    In one embodiment, the present invention serves to correct single bit and multi bit errors in the read-out binary data sequences that occur due to single errors in the stored ternary data. 
         [0027]    If an error occurs in the stored data, the read-out binary data sequence x′ differs from the corresponding written binary data sequence x. Usually, the bit-wise difference of x and x′ is designated as an error vector e that is determined as 
         [0000]    
       
      
       e=e 
       1 
       , . . . ,e 
       n 
       =x 
       1 
       ⊕x′ 
       1 
       , . . . ,x 
       n 
       ⊕x′ 
       n 
       =x⊕x′ 
      
     
         [0000]    wherein ⊕ designates the addition modulo 2 (or the logic function antivalence or XOR). For the components e i  of the error vector e there applies that e i =1 if x i ≠x′ i . Similarly we have e i =0 if x i =x′ i . 
         [0028]      FIG. 3  illustrates a circuit arrangement for error correction, referred to as corrector  38 . The corrector  38  includes a syndrome generator Syndr  31 , a decoder Dec  32 , and an XOR circuit  33 . 
         [0029]    The syndrome generator Syndr  31  is configured to generate from the binary sequence x′=x′ 1 , . . . , x′ n  a q-component error syndrome s=s 1 , . . . , s q  with q=n−k according to the relation 
         [0000]        s   T =( s   1   , . . . ,s   q ) T   =H ·( x′   1   , . . . ,x′   n ) T   =H·x′   T   (2)
 
         [0000]    H is the H-matrix, i.e. the parity check matrix, (with q rows and n columns) of the code C. 
         [0030]    Decoder circuitry DEC  32  is configured to generate an error vector e=e 1 , . . . , e n  for the correction of the possibly incorrect bit sequence x′ to the corrected bit sequence x c =x c   1 , . . . , x c   n  from the error syndrome s=s 1  . . . , s q  of the length q, wherein the correction is performed according to the relation 
         [0000]        x   c   =x   c   1   , . . . ,x   c   n   =x′   1   ⊕e   1   , . . . ,x′   n   ⊕e   n   =x′⊕x   c   (3)
 
         [0000]    wherein s T  is a q-component column vector with the components s 1 , . . . , s q , and (x′ 1 , . . . , x n ) T  is an n-component column vector. 
         [0031]    If the error occurred is an error correctable by the used code C, there applies 
         [0000]    
       
      
       x 
       c 
       =x′⊕e=x,  
      
     
         [0000]    and the error is corrected properly. 
         [0032]    The circuit arrangement for error correction pursuant to  FIG. 3  will now be described in more detail. 
         [0033]    The line  34  carrying the binary sequence x′=x′ 1 , . . . , x′ n  is both coupled to the n-bit input of the syndrome generator Syndr  31  and to an n-bit first input of the XOR circuit  33 . The q=n−k bit output line  35  of the syndrome generator Syndr  31  which carries the error syndrome s=s 1 , . . . , s q  is coupled to the input of the decoder Dec  32 . The n-bit output line  36  of the decoder  32  which carries the n components of the error vector e=e 1 , . . . , e n  is connected in the correct position to the second, n-bit input of the XOR circuit  33  whose n-bit output carries the components x c   1 , . . . , x c   n  of the binary sequence x c . The XOR circuit  33  is implemented in one embodiment by n parallel 2-input XOR gates with one output each. 
         [0034]      FIG. 4  illustrates how the partial circuits illustrated in  FIGS. 1 ,  2 , and  3  may be connected to form a complete circuit enabling correction of storage errors according to one embodiment. 
         [0035]    The circuit arrangement of  FIG. 4  includes an encoder  41  ( 11  in  FIG. 1 ), a circuit arrangement Schspei  42  ( 21  in  FIG. 2 ) for storing data sequences, a corrector  43  ( 38  in  FIG. 3 ) comprising a series connection of a syndrome generator Syndr  45  ( 31  in  FIG. 3 ) and a decoder Dec  46  ( 32  in  FIG. 3 ), and an XOR circuit  44  ( 33  in  FIG. 3 ). 
         [0036]    The k-bit input line  47  carrying the data sequence u=u 1 , . . . , u k  is coupled to the input of the encoder  41 . The n-bit output  48  of encoder  41  carries coded data sequence x=x 1 , . . . , x n  and is coupled to the input of the circuit arrangement Schspei  42 . The n-bit output  49  of the circuit arrangement Schspei  42  which carries the data sequence x′=x′ 1 , . . . , x′ n  is coupled to the input of the syndrome generator Syndr  45  and to the first input of the XOR circuit  44 . The output  410  of the syndrome generator Syndr  45  which carries the n−k=q bit error syndrome s is coupled to the input of the decoder Dec  46 , which in turn is coupled with its output line  411  to the second input of the XOR circuit  44 . The n-bit error vector e=e 1 , . . . , e n  is output on output line  411  of the decoder Dec. 
         [0037]    The n-bit output  412  of the XOR circuit  44  carries the corrected binary sequence x c =x c   1 , . . . , x c   n . 
         [0038]    In one embodiment it is provided that only a subset of n′ bits of the n bits with n′≦n of the binary sequence x′ is corrected. Then, it is only necessary that the decoder Dec  46  provides only a subset of n′ components of the error vector e. 
         [0039]      FIG. 5  illustrates an embodiment of a circuit arrangement Schspei  21  for storing data sequences. It comprises a circuit TrBT  51  for transforming binary sequences to analog sequences representing ternary signals, i.e. ternary sequences. Memory  52  is referred to as ternary memory that is adapted and configured to store sequences whose components are analog signals representing ternary signals. Circuit TrTB  53  is adapted and configured to transform analog sequences to binary sequences, wherein the components of the analog sequences represent ternary signals. 
         [0040]    Analog signals representing ternary values or conditions are also simply referred to as ternary values or ternary conditions. Correspondingly, the circuits TrBT and TrTB are referred to as a circuit for transforming binary sequences to ternary sequences or signals and as a circuit for transforming ternary sequences to binary sequences or signals. 
         [0041]    At the n-bit input line  54  of the circuit TrBT  51 , n binary values x 1 , . . . , x n  are provided. These are transformed by circuit  51  to a sequence of 2·m ternary signals A 1 , B 1 , . . . , A m , B m  and are output at the 2·m outputs  55  thereof. These 2-m outputs  55  are coupled to the data inputs of the ternary memory  52  to be stored in this memory under an address a available at the address input  57 . If n is divisible by 3 without remainder, then m=n/3. If n is not divisible by 3 without remainder, the binary sequence x=x 1 , . . . , x n  may be supplemented by one further or two further bits which are, for instance, constantly equal to 0, to a binary sequence x 1 , x 2 , . . . , x n′ , with n′ components, so that n′ is divisible by 3 without remainder. The supplemented bits may, for instance, be chosen to be constantly equal to 0. 
         [0042]    If the ternary data stored in the ternary memory  52  are read under the address a that is available on the address line  57  of the ternary memory, the ternary data A 1 ′, B 1 ′, . . . , A m′ , B m′  are output on the 2·m data outputs  58  of the memory  52 . Due to an error, possibly caused by radiation or by a gradual loss of charge or other reasons, the data written in the memory may be erroneous. 
         [0043]    If no error exists, there applies 
         [0000]        A   1   ,B   1   , . . . ,A   m   ,B   m   =A   1   ′,B   1   ′, . . . ,A   m   ′,B   m ′
 
         [0000]    and in the case of an error there applies 
         [0000]        A   1   ,B   1   , . . . ,A   m   ,B   m   ≠A   1′   ,B   1′   , . . . ,A   m′   ,B   m′ . 
         [0044]    The 2m-bit output line  58  of ternary memory  52  is coupled to 2m analog inputs of circuit TrTB  53 . Circuit TrTB  53  transforms ternary values A 1 ′, B 1 ′, . . . , A m ′, B m ′ to binary values x′ 1 , . . . , x′ n  that are output on the n-bit output  56  of circuit TrTB  53 . 
         [0045]      FIG. 6   a  and  FIG. 6   b  illustrate embodiments of the circuit TrBT  51  for transforming a binary sequence x 1 , . . . , x n  of length n to a sequence A 1 , B 1 , . . . , A m , B m  of length 2·m of analog data representing ternary values. These ternary values are stored in the memory cells of the ternary memory  52 . The analog value representing the ternary value stored in a memory cell is also referred to as the condition of the memory cell. The analog values A and B may be voltage values. In a non-volatile memory this is, for instance, the threshold voltage of the memory cell which is determined by the charging condition on the floating gate. Other physical quantities may, however, also be taken into consideration. In the instant embodiment, A and B are intended to be voltage values. 
         [0046]    Depending on the fact in which of three predetermined intervals W 0 , W 1 , W 2  the values A, B are positioned, these analog values are referred to as A 0 , A 1 , A 2  or B 0 , B 1 , B 2 , respectively. Thus, if AεW 1  applies for i=0, 1, 2, the analog signal A represents the ternary value A 1 . If BεW 1  applies for j=0, 1, 2, the analog signal B represents the ternary value B j . 
         [0047]      FIG. 6   a  and  FIG. 6   b  illustrate how a sequence of binary signals x 1 , . . . , x n  can be transformed to a sequence of ternary signals A 1 , B 1 , . . . , A m , B m . 
         [0048]    Circuit TrBT  51  of  FIG. 6   a  is composed of partial circuits F 1    611 , F 2    612 , . . . , F m    61   m . These m partial circuits F i , i=1, . . . , m each implement a direct mapping F i  of three-digit binary triples to 2-digit analog values whose components represent a ternary value depending on their belonging to one of the three intervals W 0 , W 1 , W 2 . It is not necessary that the three binary values forming a triple of binary values, and which is transformed to a tuple of two ternary values, are directly consecutive in the sequence x=x 1 , . . . , x n . It is, for instance, possible that the binary values x 1 , x 11 , x 14  form a triple that is transformed to the tuple A 1 , B 1 . 
         [0049]    To make the description easily understandable, we assume as an example that the triples of binary data, which are transformed to tuples of ternary data, are each consecutive bits in the sequence x. 
         [0050]    In  FIG. 6   a  the partial circuit F 1  611 maps the triple x 1 , x 2 , x 3  of binary values to the tuple of the analog values A 1 , B 1 . The partial circuit F 2    612  maps the triple x 4 , x 5 , x 6  of binary values to the tuple of the analog values A 2 , B 2 , and the partial circuit F m    61   m  maps the triple x n-2 , x n-1 , x n  of binary values to the tuple of the analog values A m , B m . The function, which is implemented by partial circuit F i , is designated with f i . In one embodiment all partial circuits F 1 , . . . , F m  may be identical to partial circuit F  61 , as is illustrated in  FIG. 6   b , so that there applies F=F 1 = . . . =F m . Then, the partial circuit implements the function ƒ. 
         [0051]    Circuit TrBT  51  is thus implemented in  FIG. 6   b  as a parallel circuit of m identical partial circuits F  61  with three binary inputs and two analog outputs each. 
         [0052]      FIG. 7   a  illustrates an embodiment of the circuit TrTB  53  for transforming the values A 1 ′, B 1 ′, . . . , A m ′, B m ′ output by the ternary memory  52  to binary values x′ 1 , x′ 2 , . . . , x′ n . Circuit  53  is composed of m partial circuits R 1    711 , R 2    712 , . . . , R m    71   m  for transforming the values A 1 ′, B 1 ′ to the values x′ 1 , x′ 2 , x′ 3 , the values A 2 ′, B 2 ′ to the values x′ 4 , x′ 5 , x′ 6 , . . . , the values A m ′, B m ′ to the values x′ n-2 , x′ n . The function implemented by the partial circuit R i    71   i  is designated with r i . 
         [0053]    The values A i ′, B i ′ are analog values which, as explained, are interpreted as ternary values depending on their belonging to the three different intervals W 0 , W 1 , and W 2 . The function implemented by a partial circuit R i  is designated with r i  for i=1, . . . , m. 
         [0054]    In  FIG. 7   b , all partial circuits R 1    711 , R 2    712 , . . . R m    71   m  of  FIG. 7   a  were chosen equal to a partial circuit R  71 , so that the circuit TrTB  53  is implemented as a parallel circuit of m partial circuits R  71 . Each of these partial circuits then implements a function r. 
         [0055]    In the following, various embodiments of partial circuits F  61  and R  71  are described. 
         [0056]    First of all, the circuit F for implementing the function ƒ is described. The function ƒ is defined by Table 1. 
         [0057]    Table 1 illustrates how the tuples A, B of analog values are, in accordance with an embodiment, assigned to the 8 possible triples of binary values 000, 001, . . . , 111 by function ƒ. The corresponding binary variables are designated in Table 1 with x 1 , x 2 , x 3 , so that Table 1 describes the function ƒ for the first three variables. For the respectively following three variables [x 4 , x 5 , x 6 ], [x 7 , x 8 , x y ], . . . , the same function ƒ is used. Depending on the belonging of the analog values A, B to one of the intervals W 0 , W 1 , W 2 , they are designated as ternary values A 0 , A 1 , A 2  or B 0 , B 1 , B 2 , respectively. Function ƒ as determined by Table 1 is implemented by circuits F  61  depicted in  FIG. 6   b.    
         [0058]    It is generally not necessary that analog values A, B that correspond to the first three binary variables x 1 , x 2 , x 3  are stored in the first two memory cells of the ternary memory  52 . Likewise analog values not necessarily correspond to binary variables x 4 , x 5 , x 6 , that are stored in the following two memory cells, etc. If analog values A, B, which are determined by the values of the binary variables x i , x j , x k , are stored in a pair of memory cells, the binary variables x 1 , x 1 , x k  are called the variables corresponding to the memory cells in which the analog values A, B are stored. 
         [0059]    Thus, if, for example, analog values A, B, that are determined by the binary variables x 7 , x 11 , x 21 , are stored in the second and third memory cells of the ternary memory, the variables x 7 , x 11 , x 21  are the binary variables corresponding to the second and third memory cells. 
         [0060]    In Table 1, the variables x 1 , x 2 , x 3  are the binary variables corresponding to the pair of memory cells storing ternary values A, B. 
         [0061]    Table 1 describes a first example of a function ƒ that can be implemented by the partial circuit F  61 . 
         [0000]    
       
         
               
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 x 1 x 2 x 3   
                 A 
                 B 
               
               
                   
               
             
             
               
                 000 
                 A 0   
                 B 0   
               
               
                 001 
                 A 1   
                 B 2   
               
               
                 010 
                 A 0   
                 B 1   
               
               
                 011 
                 A 0   
                 B 2   
               
               
                 100 
                 A 2   
                 B 1   
               
               
                 101 
                 A 2   
                 B 0   
               
               
                 110 
                 A 2   
                 B 2   
               
               
                 111 
                 A 1   
                 B 0   
               
               
                   
               
             
          
         
       
     
         [0062]    For instance, the tuple of ternary values A 0 , B 0  is assigned by Table 1 or by function ƒ to the triple of binary values 000 (first line of Table 1), and the tuple A 2 , B 1  to the triple 100 (5 th  line of Table 1). The analog values A and B of a tuple of analog values A, B are each stored in a memory cell of the ternary memory  52 . The values stored in a memory cell are referred to as the conditions of the memory cell. 
         [0063]    Since there exist eight different triples of binary values and nine different tuples of ternary values, one of the tuples of ternary values, according to Table 1 the tuple A 1 , B 1 , does not occur. This tuple of ternary values is assigned to none of the triples of binary values. 
         [0064]    For any of the triples x 1 , x 2 , x 3  of binary values written into memory Schspei  21 , tuple A 1 , B 1  is not written into the ternary memory  52 . If one writes, for instance, the triple 100 into the memory Schspei  21 , the tuple of ternary values A 2 , B 1  is written into the corresponding two memory cells of the ternary memory  52 . 
         [0065]    Due to an error, however, the tuple A 2 , B 1  written into the ternary memory  52  may be distorted or falsified to tuple A 1 , B 1  when the corresponding memory cells are read, so that on reading from the memory instead of the correct tuple A 2 , B 1  the incorrect tuple A 1 , B 1  is stored in the corresponding memory cells of the ternary memory  52 , and an incorrect value A 1 , B 1  and hence also an incorrect value x′ 1 , x′ 2 , x′ 3  is read. 
         [0066]    Although tuple A 1 , B 1  is never written into the ternary memory, it is necessary to assign a triple of binary values to this tuple during reading from the memory. In one embodiment, it is of advantage to choose an assignment such that an error correction of the error, which distorted A 2 , B 1  to A 1 , B 1 , can be performed as easily as possible. 
         [0067]    Table 2 describes a function r, illustrating how the corresponding triples x 1 , x 2 , x 3  of binary values may be assigned to tuples A 1 , B 1 . This function r is implemented by partial circuit R  71  of  FIG. 7   b . 
         [0000]    
       
         
               
               
               
               
             
               
               
               
               
               
             
           
               
                   
                 TABLE 2 
               
               
                   
                   
               
               
                   
                 A 0   
                 A 1   
                 A 2   
               
               
                   
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 B 0   
                 000 
                 111 
                 101 
               
               
                   
                 B 1   
                 010 
                 000 
                 100 
               
               
                   
                 B 2   
                 011 
                 001 
                 110 
               
               
                   
                   
               
             
          
         
       
     
         [0068]    By means of Table 2 one recognizes which triples of binary values are assigned during reading to the tuples of ternary values that are stored in the memory. The triple of binary values corresponding to A i , B j  is positioned in the field of intersection of the column designated with A i  and the row designated with B j . Thus, the triple 101 corresponds to the tuple A 2 , B 0  and the triple 000 corresponds to the tuple A 1 , B 1 . In correspondence with Table 2, the triple 000 (left upper field) is assigned to the tuple A 0 , B 0 , the triple 000 (central field) is assigned to the tuple A 1 , B 1 , and the triple 001 (central field of the lower row) is assigned to the tuple A 1 , B 2 . This assignment is in correspondence with Table 1. 
         [0069]    If, by Table 1, the tuple of ternary values A 0 , B 0  is assigned to the binary triple 000, the triple of binary values 000 is assigned to the tuple of ternary values A 0 , B 0  by Table 2. In other words: If the triple of binary values 000 is written into the circuit arrangement Schspei  21 , it is stored internally in the ternary memory  52  as A 0 , B 0  in two appropriate memory cells and output during reading as a triple of binary values 000. In general, the mapping of triples of binary values to tuples of ternary values as defined by Table 1 is inverted by the mapping of tuples of ternary values to triples of binary values described in Table 2. Moreover, the triple 000 is assigned to the tuple A 1 , B 1 . For the description of errors in the ternary values or conditions of the memory elements stored in the ternary memory, the term of the contiguous value combination is used. Contiguous value combinations, i.e. tuples of ternary values, are such pairs of value combinations of ternary values that are relatively easy to disturb due to an error into one another. 
         [0070]    Two value combinations A i , B j  and A i , B k  of ternary values or of conditions of memory cells are called contiguous if k and j differ by 1. Likewise, two value combinations A i , B j  and A i , B j  are called contiguous if i and l differ by 1. Thus, the value combinations A 0 , B 1  and A 0 , B 2  are contiguous, while the value combinations A 0 , B 1  and A 1 , B 2  are not contiguous. 
         [0071]    The assignment in Table 1 is implemented such that there applies: 
         [0000]    If the value combination A i , B j  is assigned to x 1 , x 2 , x 3  and the value combination A l , B k  is assigned to x′ 1 , x′ 3 , and if A i , B j  and A l , B k  are contiguous, then x 1 , x 2 , x 3  and x′ 1 , x′ 2 , x′ 3  differ in an odd number of bits. In other words, the value combinations x 1 , x 2 , x 3  and x′ 1 , x′ 2 , x′ 3  then differ by 1 or 3 bits. 
         [0072]    Thus, triples being adjacent in a row or in a column in Table 2 and corresponding to contiguous value combinations of conditions differ by 1 or 3 bits respectively. 
         [0073]    Table 1 describes how the 8 triples of binary values x 1 , x 2 , x 3  can be mapped to 8 tuples A i , A j  of ternary values during writing into the memory. No binary values are mapped to the tuple A 1 , B 1  during writing. Due to an error in the memory, a tuple of ternary values, for, instance, the tuple A 2 , B 1  may be distorted to tuple A 1 , B 1 , so that tuple A 1 , B 1  may occur in the memory although it was not generated intentionally during writing. For reading, the binary value 000 is assigned to the tuple A 1 , B 1 . 
         [0074]    By means of Table 2 one also recognizes that it is not possible to assign to all value combinations of pairs of conditions that are contiguous triples of binary values that differ in one bit only. Thus, the value combination A 1 , B 1  has four neighbors, namely the value combinations [A 0 , B 1 ], [A 1 , B 0 ], [A 1 , B 2 ], and [A 2 , B 1 ]. There are, however, only 3 triples, namely [  x   1 , x 2 , x 3 ], [x 1 ,  x   2 , x 3 ], [x 1 , x 2 ,  x   3 ] that differ from [x 1 , x 2 , x 3 ] in one bit. In Table 2, the pairs of triples of binary values 000 and 111 and 111 and 000 which are assigned to the contiguous value combinations A 0 , B 0  and A 0 , B 1  or A 0 , B 1  and A 1 , B 1 , respectively, differ by 3 bits each. Such assignment can be used to enable an implementation of an error correction circuit. 
         [0075]    Table 3 describes a further embodiment of an assignment of analog values A, B to the possible eight triples 000, 001, . . . , 111 of binary values which variables x 1 , x 2 , x 3 , may take wherein the analog values are again designated as A 0 , A 1 , A 2  or as B 0 , B 1 , B 2 , respectively, depending on their belonging to one of the intervals W 0 , W 1 , W 2 . 
         [0000]    
       
         
               
               
               
             
           
               
                 TABLE 3 
               
               
                   
               
               
                 x 1 x 2 x 3   
                 A 
                 B 
               
               
                   
               
             
             
               
                 000 
                 A 1   
                 B 1   
               
               
                 001 
                 A 2   
                 B 1   
               
               
                 010 
                 A 1   
                 B 0   
               
               
                 011 
                 A 2   
                 B 0   
               
               
                 100 
                 A 0   
                 B 1   
               
               
                 101 
                 A 0   
                 B 2   
               
               
                 110 
                 A 0   
                 B 0   
               
               
                 111 
                 A 1   
                 B 2   
               
               
                   
               
             
          
         
       
     
         [0076]    By Table 3, tuple A 1 , B 1  is, for instance, assigned to triple 000 and tuple A 1 , B 2  is assigned to triple 111. According to table 3 tuple A 2 , B 2  is assigned to none of the triples, so that this tuple of ternary values can only be stored in the ternary memory  52  if an error has occurred. 
         [0077]    Table 4 illustrates an embodiment wherein triples of binary values are assigned to tuples of ternary values. 
         [0000]    
       
         
               
               
               
               
             
               
               
               
               
               
             
           
               
                   
                 TABLE 4 
               
               
                   
                   
               
               
                   
                 A 0   
                 A 1   
                 A 2   
               
               
                   
                   
               
             
             
               
                   
               
             
          
           
               
                   
                 B 0   
                 110 
                 010 
                 011 
               
               
                   
                 B 1   
                 100 
                 000 
                 001 
               
               
                   
                 B 2   
                 101 
                 111 
                 000 
               
               
                   
                   
               
             
          
         
       
     
         [0078]    If two tuples of ternary values are contiguous, the triples of binary values assigned to them by Table 4 differ in an odd number of bits, wherein at least one pair of triples of contiguous tuples differs in 3 bits. Thus, binary triple 000, which is assigned to ternary tuple A 1 , B 1 , differs from the binary triple 111, that is assigned to the contiguous tuple A 1 , B 2 , by three bits. 
         [0079]    In the following the advantage that the tuple A 2 , B 2  is assigned to none of the triples of binary values is shown. 
         [0080]    In one embodiment ternary memory can be a flash memory. If low threshold voltage values (positive to low negative stored charging values on the floating gate) correspond to ternary values A 0  and B 0  stored in the memory cells, medium threshold voltage values (low to medium negative stored charging values on the floating gate) correspond to ternary values A l  and B 1 , and high threshold voltage values (medium to high negative stored charging values on the floating gate) correspond to ternary values A 2  and B 2 , a tuple A 2 , B 2  can only be stored in the memory cells of the ternary memory  52  if, due to an error, a low or medium threshold voltage value was distorted to a higher threshold voltage value. If the ternary memory is a flash memory, the error may, for instance, also have occurred by incorrect programming. 
         [0081]    In the case of analog values that have already been written into the ternary memory and that are, for instance, assumed as threshold voltage values here, the analog value, here the threshold voltage value, will increase rarely only, but will rather be diminished incorrectly due to loss of charge. This is due to the fact that the relatively high incorporated electrical fields occur with the higher charging amounts and hence higher threshold voltage values may result in a loss of negative charge. Thus, a stored tuple A 1 , B 2  will only very rarely be distorted incorrectly to the tuple A 2 , B 2  since the charge pertaining to A 2  on the floating gate is more negative than that pertaining to A 1 . The tuple A 2 , B 2  can, however, more easily distort to one of the tuples A 1 , B 2  or A 2 , B 1  by loss of charge. 
         [0082]    Tuple A 2 , B 2  is, however, pursuant to the assignment of Table 3, not written into ternary memory  52 . So this can only occur in case of a processing error during writing. Accordingly it is of advantage if tuple A 2 , B 2  is not assigned to any triple of binary values, as is illustrated in Table 3. 
         [0083]    Table 3 reveals that value A 1  is written into a first memory cell of the ternary memory  52  for the allocations 000, 010, and 111. This is exactly the case if the Boolean expression 
         [0000]        T   1   =  x     1     x     2     x     3   V  x     1   x   2     x     3   Vx   1   x   2   x   3   =  x     1     x     3 ( x   2   V  x     2 ) Vx   1   x   2   x   3   =  x     1     x     3   Vx   1   x   2   x   3   (4)
 
         [0000]    equals 1. 
         [0084]    Correspondingly, Table 3 reveals that A 2  is written into the corresponding memory cell of the ternary memory for the allocations 001 and 011 of x 1 , x 2 , x 3 . 
         [0085]    This is the case if the Boolean expression 
         [0000]        T   2   =  x     1     x     2   x   3   V  x     1   x   2   x   3   =  x     1   x   3   (5)
 
         [0000]    equals 1. 
         [0086]    For all other allocations of x 1 , x 2 , x 3  the corresponding memory cell is allocated with A 0 . 
         [0087]    Table 3 also reveals that B 1  is written into a corresponding second memory cell of ternary memory  52  for the allocations 000, 001, and 100 of x 1 , x 2 , x 3 . 
         [0088]    This is the case if the Boolean expression 
         [0000]        T   3   =  x     1     x     2     x     3   V  x     1     x     2   x   3   Vx   1     x     2     x     3   =x   2 (   x     1   V  x     3 )  (6)
 
         [0000]    equals 1. 
         [0089]    Correspondingly, Table 3 reveals that B 2  is written into the corresponding memory cell of the ternary memory for the allocations 101 and 111 of x 1 , x 2 , x 3 . This is the case if the Boolean expression 
         [0000]        T   4   =x   1     x     2   x   3   Vx   1   x   2   x   3   =x   1   x   3   (7)
 
         [0000]    equals 1. For all other allocations of x 1 , x 2 , x 3  the corresponding memory cell is allocated with B 0 . 
         [0090]    If the ternary memory  52  is a flash memory, it is well-known that a memory cell in a memory area is only written into after the deletion of the memory area. After deletion, all memory cells of the deleted memory area are set to a value A 0  or B 0 , respectively, so that only the values differing from A 0  or from B 0 , respectively, have to be written. 
         [0091]      FIGS. 8   a ,  8   b ,  8   c  illustrate an implementation of partial circuit F for implementing function F  61  in  FIG. 6   b  by making use of Tables 3 and 4. The binary inputs are again designated with x 1 , x 2 , x 3  in  FIG. 8   a . The binary inputs x 1 , x 2 , x 3  are directly mapped to the corresponding analog output values A and B that represent ternary values. 
         [0092]    Partial circuit F  61  of  FIG. 6   b  for implementing the function ƒ is composed of the two partial circuits F 1    814  and F 2    817 , as is illustrated in  FIG. 8   a . Partial circuit F  61  is illustrated in  FIG. 8   a  for the first three binary input values x 1 , x 2 , x 3  and for the first two ternary output values A 1  and B 1  of the circuit TrBT  51  of  FIG. 6   b.    
         [0093]    First partial circuit F 1    814  has three binary inputs at which the binary values x 1 , x 2 , x 3  are available, and one analog input at which an analog value V 1  is constantly available. V 1  is an analog value being in the interval W 1 . The partial circuit F 1    814  has a first analog output at which value A 1 =V 1  is output if this output is coupled to the analog input that carries the signal V 1 . It comprises a second analog output at which value B 1 =V 1  is output if this output is coupled to the analog input carrying analog signal V 1 . 
         [0094]    For the binary allocations x 1 , x 2 , x 3  for which T 1 =  x   1   x   3 Vx 1 x 2 x 3 =1 is valid, the analog input carrying value V 1  is coupled to the first output carrying the value V 1  then, and for the binary allocations x 1 , x 2 , x 3  for which T 3 =  x   2 (  x   1 V  x   3 )=1 is valid, the analog input carrying value V 1  is coupled to the second output that carries the value V 1  then. 
         [0095]    The second partial circuit F 2    817  exhibits two binary inputs to which the binary values x 1 , x 3  are provided, and one analog input to which an analog value V 2  is constantly provided. V 2  is an analog value in the interval W 2 . Partial circuit F 2    817  comprises a first analog output at which value A 2 =V 2  is output if this output is coupled to the analog input carrying analog signal V 2 , and a second analog output at which value B 2 =V 2  is output if this output is coupled to the analog input carrying the analog signal V 1 . 
         [0096]    For binary allocations x 1 , x 3  for which T 2 =  x   1   x   3 =1 applies, the analog input carrying value V 2  is coupled to the first output carrying value V 2  then, and for the binary assignments x 1 , x 3  for which T 4 =  x   1 x 3 =1 applies, the analog input carrying value V 2  is coupled to the second output that carries the value V 2  then. 
         [0097]    The first output of the partial circuit F 1    814  and the first output of the second partial circuit F 2    817  are coupled to the first output  815  of circuit F  61  marked with A. This output is, depending on the binary allocation x 1 , x 2 , x 3  available, coupled to the analog input of the partial circuit F 1    814  that carries the value 1/E W 1  if T 1 =1, or, if T 2 =1, to analog input of the partial circuit F 2    817  carrying the analog value V 2 εW 2 , or, if neither T 1 =1 nor T 2 =1 applies, to none of these analog inputs. For T 1 =1 there applies A=A 1 , and for T 2 =1 there applies A=A 2 . 
         [0098]    The second output, i.e. B 1 , of partial circuit F 1    814  and the second output i.e. B 2 , of the second partial circuit F 2    817  are connected with the second output of the circuit F  61  which is marked with B. This output is, depending on the binary allocation x 1 , x 2 , x 3  available, coupled to the analog input of the partial circuit F 1    814  carrying value V 1 εW 1  if T 3 =1, or if T 4 =1, to the analog input of the partial circuit F 2  carrying the analog value V 2 εW 2 , or, if neither T 3 =1 nor T 4 =1 applies, to none of these analog inputs. For T 3 =1 there applies B=B 1 , and for T 4 =1 there applies B=B 2 . 
         [0099]    Note that in  FIG. 6   a , the analog values constantly carrying the values V 1  and V 2  are not illustrated as inputs of the circuit F  61 . 
         [0100]      FIG. 8   b  illustrates an embodiment of an implementation of partial circuit F 1    814  of  FIG. 8   a . Circuit F 1  is constructed of the switches  83 ,  84 ,  85 ,  86 ,  87 ,  88 , and  810 , each comprising one input and two outputs that are referred to as lower output and upper output. These switches are controlled by the binary values x 1 , x 2 , x 3 , x 3 , x 3 , x 2 , x 1 . If the binary control value 1, here x 1 =1, is input in one of the switches, for instance in switch  83 , it couples its input to its upper output. If a binary control value 0 is input, it couples the input to its lower output. 
         [0101]    The input of partial circuit F 1    814  which carries the analog value V 1  is coupled to the input of the switch  83 , to the input of the switch  87  and to the input of the switch  810 . 
         [0102]    The upper output of the switch  83  is coupled to the input of the switch  84 . The upper output of the switch  84  is coupled to the input of the switch  85 . The lower output of the switch  83  is connected with the input of the switch  86 . The lower output of the switch  810  is connected with the lower output of the switch  87  to the line  811 , and the line  811  is guided into the input of the switch  88 . The lower output of the switch  88  is the second output of the partial circuit F 1    814  which is marked with B 1 . The lower output of the switch  86  is connected with the upper output of the switch  85  to a line  812  that forms the first output of the partial circuit F 1    89  which is marked with A 1 . 
         [0103]    The connecting lines between the switches are marked in  FIG. 8   b  with Boolean expressions, so that value V 1  is available on the respective connecting line if the corresponding Boolean expression equals 1. Thus, the connecting line between the switches  83  and  84  is marked with x 1  since the value V 1  is available on this line if x 1 =1 applies. The line  811  that implements the connection of the lower outputs of the switches  810  and  87  is marked with  x   1 V  x   3  since this expression assumes the value 1 and this line carries the value V 1  if either x 1 =0 or x 3 =0 is valid. The line coupled to the lower output of the switch  88  is marked with the expression  x   2 (  x   1 V  x   3 ). This line carries the value V 1  if T 1 =  x   2 (  x   1 V  x   3 ). 
         [0104]      FIG. 8   c  illustrates a possible implementation of partial circuit F 2    817  of  FIG. 8   a . It comprises switches  81  and  82  with one input and two outputs that are controlled by the binary values x 1  and x 3 . 
         [0105]    The input of the circuit F 2    817  carrying the analog value V 2  is coupled to the input of switch  81 . The upper output of the switch  81  is coupled to the input of the switch  82 . The lower output of switch  82  forms the first output of circuit F 2    817 , which is marked with A 2 , while the upper output of switch  82  forms the second output that is marked with B 2 . The coupling lines between the switches and the outputs are again marked with Boolean expressions. Thus, the connecting line between switches  81  and  82  is marked with x 3  since the value V 2  is available on this line if x 3 =1. Correspondingly, the first output line for A 2  is marked with  x   1 x 3  since value V 2  is output on this output line if T 2 =  x   1 x 3 =1. The second output line for B 2  is marked with x 1 x 3  since the value V 2  is available on this line if T 4 =x 1 x 3 =1. 
         [0106]    The pertinent partial circuit R  71  of  FIG. 7   b  which transforms a tuple of ternary values A′B′ which are read out from ternary memory  52  to a corresponding triple x′ 1 , x′ 2 , x′ 3  of binary values is illustrated in  FIG. 9 . 
         [0107]    The depicted circuit implements the mapping of tuples of ternary values A′B′ to triples of binary values x′ 1 x′ 2 x′ 3  as illustrated in Table 5 and which results directly from Table 4. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                 TABLE 5 
               
               
                   
                   
               
               
                   
                 A′B′ 
                 x 1 x 2 x 3   
               
               
                   
                   
               
             
             
               
                   
                 A 0 B 0   
                 110 
               
               
                   
                 A 0 B 1   
                 100 
               
               
                   
                 A 0 B 2   
                 101 
               
               
                   
                 A 1 B 0   
                 010 
               
               
                   
                 A 1 B 1   
                 000 
               
               
                   
                 A 1 B 2   
                 111 
               
               
                   
                 A 2 B 0   
                 011 
               
               
                   
                 A 2 B 1   
                 001 
               
               
                   
                 A 2 B 2   
                 000 
               
               
                   
                   
               
             
          
         
       
     
         [0108]    Thus, in the first line of Table 5 the triple 110 is assigned to tuple A 0 B 0  since the triple 110 is positioned in Table 4 in the left upper field whose column is marked with A 0  and whose row is marked with B 0 . In the last row of Table 4, the triple 000 is assigned to the tuple A 2 B 2  since the triple 000 is positioned in Table 4 in the right lower field whose column is marked with A 2  and whose row is marked with B 2 . 
         [0109]    In one embodiment circuit R  71  of  FIG. 9  comprises, for instance, a serial connection of digital-to-analog converter DAW  91  with two analog inputs to which analog values A′ and B′ are provided, and m binary outputs at which an m-component binary vector y=y 1 , . . . , y m  is output, and a downstream combinational circuit Komb  92  with m binary inputs and 3 binary outputs at which the binary values x 1 x 2 x 3  are output. There applies m≧3. 
         [0110]    The digital-to-analog converter DAW may comprise a digital-to-analog converter converting the analog values A′ to two binary values y 1 , y 2  and converting signal B′ to two binary signals y 3 , y 4 , so that in this case m=4. A person skilled in the art will often perform the digital-to-analog conversion by making use of a Gray code, as is proposed already in Steinbuch, K. and Ruprecht, W. Nachrichtentechnik [Communications Engineering], Publishing House Springer, Berlin, Heidelberg, New York, 1967, pp. 339-341. If A 0  and B 0  are each converted to 0, 0; A 1  and B 1  each to 0, 1; and A 2  and B 2  each to 1, 1 then the value table of the combinational circuit Komb  92  of Table 6 results in that in Table 5 A i  and B j  for j=0, 1, 2 are replaced by the digital tuples y 1 , y 2  and y 3 , y 4  assigned to them. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                 TABLE 6 
               
               
                   
                   
               
               
                   
                 y 1 y 2 , y 3 y 4   
                 x 1 x 2 x 3   
               
               
                   
                   
               
             
             
               
                   
                 00, 00 
                 110 
               
               
                   
                 00, 01 
                 100 
               
               
                   
                 00, 11 
                 101 
               
               
                   
                 01, 00 
                 010 
               
               
                   
                 01, 01 
                 000 
               
               
                   
                 01, 11 
                 111 
               
               
                   
                 11, 00 
                 011 
               
               
                   
                 11, 01 
                 001 
               
               
                   
                 11, 11 
                 000 
               
               
                   
                   
               
             
          
         
       
     
         [0111]    In Table 6, the output values of the combinatory circuit Komb  92  are defined for 9 input values y 1 , y 2 , y 3 , y 4 . 
         [0112]    For the remaining 7 values for y 1 , y 2 , y 3 , y 4 , which are not listed in Table 6, the output values of the combinatory circuit Komb  92  remain undetermined, and these undetermined or ‘don&#39;t-care’ values may be used for circuit optimization. 
         [0113]    The binary values y 1 , y 2 , y 3 , y 4  are auxiliary values for reading. They are generated only during reading after the output of analog values A 1 ′ B′, . . . , A m ′B m ′ stored in the corresponding memory cells of the ternary memory  52  by means of digitizing by an analog-to-digital converter DAW  91 . When writing data into memory Schspei these binary auxiliary values for reading y 1 , y 2 , y 3 , y 4  are not required. Various analog-digital converters may be used to generate m binary auxiliary values for reading y 1 , . . . , y m . 
         [0114]    Another possibility of digital-to-analog conversion of auxiliary values for reading comprises digitizing each of the analog signals A′ and B′ by making use of a 1-of-3 code. If A 0  and B 0  are each converted to 0, 0, 1; A 1  and B 1  each to 0, 1, 0; and A 2  and B 2  each to 0, 0, 1, the value table of the combinational circuit Komb  92  of Table 7 results in that in Table 5 A i  and B j  for j=0, 1, 2 are replaced by the digital triples y 1 , y 2 , y 3  and y 4 , y 5 , y 6  assigned to them. In this case, m=6 is valid. For a particular function ƒ as defined by Table 3 and for a corresponding function r as defined by Table 4, there are different possibilities of option for the auxiliary values for reading y 1 , . . . , y m  also with different values for m, and that the auxiliary values for reading y 1 , . . . , y m  are not stored in the ternary memory but have to be generated after reading the ternary values from the ternary memory  52  only. 
         [0000]    
       
         
               
               
               
             
           
               
                   
                 TABLE 7 
               
               
                   
                   
               
               
                   
                 y 1 y 2 y 3 , y 4 y 5 y 6   
                 x 1 x 2 x 3   
               
               
                   
                   
               
             
             
               
                   
                 100, 100 
                 110 
               
               
                   
                 100, 010 
                 100 
               
               
                   
                 100, 001 
                 101 
               
               
                   
                 010, 100 
                 010 
               
               
                   
                 010, 010 
                 000 
               
               
                   
                 010, 001 
                 111 
               
               
                   
                 001, 100 
                 011 
               
               
                   
                 001, 010 
                 001 
               
               
                   
                 001, 001 
                 000 
               
               
                   
                   
               
             
          
         
       
     
         [0115]    In Table 7, the output values of the combinatory circuit Komb  92  are determined for 9 input values y 1 y 2 y 3 , y 4 y 5 y 6 . 
         [0116]    For all 64−7=57 values for y 1 y 2 y 3 , y 4 y 5 y 6 , which are not listed in Table 7, the output values of the combinational circuit Komb  92  remain undetermined. These undetermined or ‘don&#39;t-care’ values may be used for circuit optimization. 
         [0117]    Since the design of a combinational circuit given as a table of values lies within the knowledge of a skilled artisan. Also the implementation of circuit R  71  as defined by the assignment of a triple x 1 , x 2 , x 3  of digital values to a tuple A′, B′ of ternary values as in Table 5 lies within the knowledge of the skilled artisan, there is no need to unnecessarily obscure this description with the details of circuit R  71 . 
         [0118]      FIG. 10  illustrates an embodiment of circuitry for error detection of 1-bit and 2-bit errors.  FIG. 10  first of all illustrates the corrector  43  of  FIG. 4 . Circuit components corresponding to the circuit components in  FIG. 4  are designated with the same reference numbers. In addition to corrector  43  described in  FIG. 4 , a q-bit line  103  carrying the values of the error syndrome s as output by syndrome generator Syndr  45  is coupled to the input of an XOR circuit  101  with q inputs and one output and an OR circuit  102  with likewise q inputs and one output. 
         [0119]    XOR circuit  101  outputs parity value P(s) of the components of the syndrome s with 
         [0000]        P ( s )= s   1   ⊕s   2   ⊕ . . . ⊕s   q    
         [0000]    OR circuit  102  outputs the OR operation of the components of the syndrome s with 
         [0000]      OR( s )= s   1   Vs   2   V . . . Vs   q    
         [0120]    Assuming that only correct values of 1-bit errors, 3-bit errors and 2-bit errors are to be distinguished from one another, there applies: 
         [0000]    If P(s)=0 and OR(s)=0, then there is no error.
 
If P(s)=1 and OR(s)=1, then there is a 1-bit error or a 3-bit error.
 
If P(s)=0 and OR(s)=1, then there is a 2-bit error.
 
         [0121]    Subsequently the error correction according to the invention is described with an embodiment comprising q=5 check bits c=c 1 , . . . , c 5  and k=7 data bits u=u 1 , . . . , u 7 , so that the code exhibits a length of n=12 bits. The columns of the H-matrix h i  with i=1, . . . , 12 all exhibit an odd number of ones. The H-matrix is indicated here in systematic form 
         [0000]        H =( I   5   ,P   5,7 ) 
         [0000]    wherein I 5  is the (5, 5) unit matrix and P 5,7  a (5, 7) is a parity matrix. 
         [0122]    The H-matrix H=h 2 , h 12 ) in one embodiment can be 
         [0000]    
       
         
           
             
               
                 
                   H 
                   = 
                   
                     ( 
                     
                       
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                       
                       
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           1 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           1 
                         
                         
                           1 
                         
                       
                       
                         
                           1 
                         
                         
                           2 
                         
                         
                           3 
                         
                         
                           4 
                         
                         
                           5 
                         
                         
                           6 
                         
                         
                           7 
                         
                         
                           8 
                         
                         
                           9 
                         
                         
                           10 
                         
                         
                           11 
                         
                         
                           12 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0123]    Every column h i , i=1, . . . , 12 consists of 5 components, so that the H-matrix consists of 5 rows. Note that for illustration purposes only each column is terminated in the sixth row by an integer number indicating the number of the column. 
         [0124]    In the following it is illustrated that there exists a partition of the columns of the H-matrix in w=n/3=12/3=4 sets M 1 ={h 1 , h 2 , h 3 }, M 2 ={h 4 , h 5 , h 6 }, M 3 ={h 7 , h 8 , h 9 }, M 4 ={h 10 , h 11 , h 12 } with 3 columns each, so that the element-wise XOR sum of the respectively three columns of the H-matrix contained in one of these sets is not a column of the H-matrix. The columns of the H-matrix are arranged such that the first three columns h 1 , h 2 , h 3  of the H-matrix are elements of the first set M 1 , the following three columns h 4 , h 5 , h 6  are elements of set M 2 , the following three columns h 7 , h 8 , h 9  are elements of set M 3 , and the following three columns h 10 , h 11 , h 12  are elements of set M 4 . 
         [0125]    In case the columns are initially arranged in some other way, the columns can be rearranged that every three consecutive columns are elements of one of these sets. 
         [0126]    Since n=12 is divisible by 3 without remainder, there are w=12/3=4 such sets without any columns remaining during the classification in sets of three elements. If the remainder of the division of n by 3 is 1, there is another set M m+1 ={h n } comprising one element. Since all columns of the H matrix are different, this additional column H n  will not occur again in the H-matrix H. If the remainder of the division of n by 3 is 2, there is another set M w+1 ={h n-1 , h n }. The H-matrix H will then have to be chosen such that the element-wise XOR sum h n-1 ⊕h n  does not form a column of the H-matrix. 
         [0127]    The element-wise XOR sum of the first three columns 
         [0000]        k   1   =h   1   ⊕h   2   ⊕h   3 =[1,1,1,0,0] T    
         [0000]    does not form a column of the H-matrix. Likewise, there applies: The element-wise XOR sum of the following three columns 
         [0000]        k   4   =h   4   ⊕h   5   ⊕h   6 =[1,1,0,0,1] T    
         [0000]    does not form a column of the H-matrix. Likewise, there applies: The element-wise XOR sum of the following three columns 
         [0000]        k   7   =h   7   ⊕h   8   ⊕h   9 =[0,0,1,1,1] T    
         [0000]    does not form a column of the H-matrix. Likewise, there applies: The element-wise XOR sum of the following three columns 
         [0000]        k   10   =h   10   ⊕h   11   ⊕h   12 =[1,0,0,1,1] T    
         [0000]    does not form a column of the H-matrix. 
         [0128]    For i=1 mod 3 there applies that the XOR sum k i =h i ⊕h i+1 ⊕h i+2  does not form a column of the H-matrix. 
         [0129]    Such H-matrix may, for instance, be determined as follows: 
         [0000]    In a first step the set of all possible columns that are basically suited as columns of the H-matrix are chosen. 
         [0130]    These are, for instance, all different columns with m elements or all columns with m elements having an odd number of ones. In the described embodiment with m=5, all 16 columns with an odd number of ones have been chosen as a set of all basically possible columns. If the H-matrix shall be determined in systematic form, the columns with exactly one 1 are chosen as the first 5 columns from the set of all possible columns. These columns no longer form part of this set now. They form the unit matrix I 5  of the H-matrix. 
         [0131]    For the first three columns there applies k 1 =h 1 ⊕h 2 ⊕h 3 =[1, 1, 1, 0, 0] T  and column k 1  is deleted from the set of possible columns. Since h 4  and h 5  are already determined, from the set of the remaining possible columns, h 6  is now chosen as the 6 th  column from the set of the remaining possible columns. IN this embodiment this is the column h 6 =[1, 1, 0, 1, 0] T . For the three columns h 4 , h 5 , h 6  following the third column there applies k 4 =h 4 ⊕h 5 ⊕h 6 =[1, 1, 0, 0, 1] T . Therefore, the column k 4 =[1, 1, 0, 0, 1] T  is deleted from the set of possible columns of the H-matrix. From the set of the remaining possible columns of the H-matrix, the three columns h 7 , h 8  and h 9  are now chosen. There applies k 7 =h 7 ⊕h 8 ⊕h 9 =[0, 0, 1, 1, 1] T , and column k 7 =[0, 0, 1, 1, 1] T  is deleted from the set of possible columns of the H-matrix. From the set of the remaining possible columns of the H-matrix, the three columns h 10 , h 11  and h 12  are now chosen. There applies k 10 =h 10 ⊕h 11 ⊕h 12 =[1, 0, 0, 1, 1] T , and column k 10 =[1, 0, 0, 1, 1] T  is deleted from the set of possible columns of the H-matrix, which is now empty. 
         [0132]    If, during the determination of the H-matrix, there results a column k j =h j ⊕h j+1 ⊕h j+2  with j=1 modulo 3=1 mod 3, which already exists as a column of the determined columns of the H matrix, one simply has to choose from the set of possible columns of the H-matrix, for instance, instead of the column h j+2  another column h′ j+2  for which this does not apply. 
         [0133]    Determining from a set of basically possible columns an H-matrix in which the XOR sums k i =h i ⊕h i+1 ⊕h i+2  for i=1 mod 3 do not form columns of the H-matrix lies within the skills of the artisan. 
         [0134]    From the H-matrix, the equations for determining the syndrome s=s 1 , s 2 , s 3 , s 4 , s 5  result as 
         [0000]    
       
      
       s 
       1 
       =c 
       1 
       ⊕u 
       1 
       ⊕u 
       2 
       ⊕u 
       3 
       ⊕u 
       7  
      
     
         [0000]    
       
      
       s 
       2 
       =c 
       2 
       ⊕u 
       1 
       ⊕u 
       2 
       ⊕u 
       4 
       ⊕u 
       5 
       ⊕u 
       6  
      
     
         [0000]    
       
      
       s 
       3 
       =c 
       3 
       ⊕u 
       2 
       ⊕u 
       3 
       ⊕u 
       4 
       ⊕u 
       5 
       ⊕u 
       7  
      
     
         [0000]    
       
      
       s 
       4 
       =c 
       4 
       ⊕u 
       1 
       ⊕u 
       2 
       ⊕u 
       3 
       ⊕u 
       4 
       ⊕u 
       6  
      
     
         [0000]        s   5   =c   5   ⊕u   2   ⊕u   5   ⊕u   6   ⊕u   7 . 
         [0135]    An implementation of these equations as a syndrome generator by making use of XOR gates with 2 inputs and one output is no problem for a skilled artesian and will therefore not be described here in detail. 
         [0136]    The function of the decoder is defined by Table 8. 
         [0000]    
       
         
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
             
           
               
                 TABLE 8 
               
               
                   
               
               
                 s 1   
                 s 2   
                 s 3   
                 s 4   
                 s 5   
                 e 1   
                 e 2   
                 e 3   
                 e 4   
                 e 5   
                 e 6   
                 e 7   
                 e 8   
                 e 9   
                 e 10   
                 e 11   
                 e 12   
               
               
                   
               
             
             
               
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 1 
                 1 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 1 
                 1 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 1 
                 0 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
               
               
                 0 
                 1 
                 1 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
               
               
                 0 
                 1 
                 0 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
               
               
                 1 
                 0 
                 1 
                 0 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
               
               
                 1 
                 1 
                 1 
                 0 
                 0 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 1 
                 1 
                 0 
                 0 
                 1 
                 0 
                 0 
                 0 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                 0 
                 0 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
               
               
                 1 
                 0 
                 0 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 1 
                 1 
                 1 
               
               
                   
               
             
          
         
       
     
         [0137]    Encoder Cod  41 , in  FIG. 4 , is defined by a generator matrix G of the contemplated code. The determination of a G-matrix in systematic form from an H-matrix in systematic form is known to the person skilled in the art, and is, for instance, described in Lin, S. and Costello, D. “Error Control Coding: Fundamentals and Applications” Prentice Hall, Englewood Cliffs, 1983, pages 54-55. 
         [0138]    A generator matrix G in systematic form results directly from the H-matrix 
         [0000]        H =( I   q   ,P   q,k )  (9)
 
         [0000]    of the code in systematic form to 
         [0000]        G ( P   k,q   T   ,I   k ),  (10)
 
         [0000]    wherein P k,q   T  is the transposed (k,q) matrix of the (q,k) matrix P q,k  in which the rows of P q,k  are the columns of P k,q   T . 
         [0139]    The G-matrix which in one embodiment can be determined from the H-matrix (8) is 
         [0000]    
       
         
           
             
               
                 
                   
                     G 
                     = 
                     
                       ( 
                       
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                         
                         
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                         
                         
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                         
                         
                           
                             0 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                         
                         
                           
                             0 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                         
                         
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                         
                         
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             1 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             0 
                           
                           
                             1 
                           
                         
                       
                       ) 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and encoder Cod  11 ,  41  determines the code words x by 
         [0000]        x=x   1   , . . . ,x   12   =u·G =( c,u )=( c   1   , . . . ,c   5   ,u   1   , . . . ,u   7 ) 
         [0140]    For the check bits c=c 1 , c 2 , c 3 , c 4 , c 5  there applies then 
         [0000]    
       
      
       c 
       1 
       =u 
       1 
       ⊕u 
       2 
       ⊕u 
       3 
       ⊕u 
       7  
      
     
         [0000]    
       
      
       c 
       2 
       =u 
       1 
       ⊕u 
       2 
       ⊕u 
       4 
       ⊕u 
       5 
       ⊕u 
       6  
      
     
         [0000]    
       
      
       c 
       3 
       =u 
       2 
       ⊕u 
       3 
       ⊕u 
       4 
       ⊕u 
       5 
       ⊕u 
       7  
      
     
         [0000]    
       
      
       c 
       4 
       =u 
       1 
       ⊕u 
       2 
       ⊕u 
       3 
       ⊕u 
       4 
       ⊕u 
       6  
      
     
         [0000]        c   5   =u   2   ⊕u   5   ⊕u   6   ⊕u   7 . 
         [0141]    An implementation of an encoder by XOR gates, for instance, with two inputs and one output lies within the knowledge of a person skilled in the art and will therefore not be described in detail here. 
         [0142]    The mode of operation of the invention will be described in the following by means of examples. In one embodiment we consider k=7 and n=12. Hence, q=n−k=5. Data bits u=u 1 , . . . , u 7 =0101111 are, for instance, written into the circuit arrangement according to the invention. The data bits u are available on 7-bit input line  47  in  FIG. 4 . They are encoded by encoder  41  by applying the G-matrix G of equation (11) to the code word 
         [0000]    
       
      
       x=u·G=c 
       1 
       ,c 
       2 
       ,c 
       3 
       ,c 
       4 
       ,c 
       5 
       ,u 
       1 
       ,u 
       2 
       ,u 
       3 
       ,u 
       4 
       ,u 
       5 
       ,u 
       6 
       ,u 
       7  
      
     
         [0000]    with u=u 1 , u 2 , u 3 , u 4 , u 5 , u 6 , u 7 =0, 1, 0, 1, 1, 1, 1 and 
         [0000]        c   1 =0⊕1⊕0⊕1=0
 
         [0000]        c   2 =0⊕1⊕1⊕1⊕1=0
 
         [0000]        c   3 =1⊕0⊕1⊕1⊕1=0
 
         [0000]        c   4 =0⊕1⊕0⊕1⊕1=1
 
         [0000]        c   5 =1⊕1⊕1⊕1=0
 
         [0000]    so that x=000100101111 and the 12 elements, i.e. the bits of x are output by encoder  41  on the 12-bit line  48 . These values are provided to the input of circuit arrangement Schspei  42  and are stored under the address a provided on line  413 . The binary values available at the input of the circuit arrangement Schspei are transformed to analog values representing ternary values, stored as conditions in 2·m=8 memory cells of m=4 pairs of memory cells. The stored conditions, i.e. the ternary values, are retransformed to binary values when reading the analog values representing the ternary values. 
         [0143]    Storing of data will now be explained in more detail by means of  FIG. 5 . As described, binary sequence x=000 100 101 111 is provided to the input of circuit arrangement Schspei. In  FIG. 5 , the input  54  corresponds to this input. 
         [0144]    By means of circuit TrBT  51  for transforming a sequence of binary values to a sequence of ternary values, binary sequence x is transformed to sequence A 1 B 1 , A 2 B 2 , A 3 B 3 , A 4 B 4  of ternary values. In one embodiment, i.e. as illustrated in  FIG. 6   b , circuit TrBT is implemented as a parallel circuit of four equal circuits F  61 , wherein circuit F  61  implements function ƒ defined by Table 3. A triple of three, here consecutive, binary values is transformed by the circuit F to a tuple of ternary values that are stored as conditions in a pair of memory cells. 
         [0145]    In the contemplated embodiment, and in correspondence with Table 3 the first triple of binary values 000 is transformed to tuple A 1 B 1 =A 1 B 1  of ternary values, the second triple 100 of binary values is transformed to the tuple A 2 B 2 =A 0 B 1  of ternary values, the third triple of binary values 101 is transformed to the tuple A 3 B 3 =A 0 B 2  of ternary values, and the fourth triple of binary values 111 to the tuple A 4 B 4 =A 1 B 2  of ternary values. 
         [0146]    Under address a, the ternary values A 1 B 1  are stored in the first pair of memory cells of the ternary memory  52 , the ternary values A 0 B 1  in the second pair of memory cells of the ternary memory  52 , the ternary values A 0 B 2  in the third pair of memory cells of the ternary memory  52 , and the ternary values A 1 B 2  in the fourth pair of memory cells of the ternary memory  52  as conditions. 
         [0147]    To begin with, we first consider the case that no error occurs. There applies then P(s)=0 and OR(s)=0. 
         [0148]    Then, during reading from ternary memory  52  at address a, the ternary values A 1 B 1 , A 9 B 1 , A 0 B 2 , A 1 B 2  are output on the 2·4=8 bit line  58 , and they are provided to the input of the circuit TrTB  53 . 
         [0149]    It is assumed that the circuit TrTB  53 , as illustrated in  FIG. 7   b , is implemented as a parallel circuit of m=4 partial circuits R  71 , each implementing the function r as defined in Table 5. Thus, the partial circuit R, for instance, transforms the tuple of ternary values A 1 , B 1  corresponding to the fifth row of Table 5 to the triple 000 of binary values. The binary values 000 100 101 111 are then output via line  56  of  FIG. 5  which corresponds to the line  48  in  FIG. 4 . This sequence of binary values is input via the line  49  of  FIG. 4  to syndrome generator Syndr  45  and simultaneously in a first input of XOR circuit  44 . 
         [0150]    Syndrome generator Syndr  45  outputs the error syndrome s=s 1 , s 2 , s 3 , s 4 , s 5  at its q=n−k=12−7=5 bit output, wherein the elements, i.e. the bits, of the error syndrome s are defined as 
         [0000]        s   1 =0⊕0⊕1⊕0⊕1=0
 
         [0000]        s   2 =0⊕0⊕1⊕1⊕1⊕1=0
 
         [0000]        s   3 =0⊕1⊕0⊕1⊕1⊕1=0
 
         [0000]        s   4 =1⊕0⊕1⊕0⊕1⊕1=0
 
         [0000]        s   5 =0⊕1⊕1⊕1⊕1=0
 
         [0151]    Since no error has occurred, the error syndrome equals 0, as expected. 
         [0152]    The values of the syndrome, here s=0, 0, 0, 0, 0, are provided to input line  410  of decoder Dec  46 . The decoder accordingly outputs, in correspondence with Table 8, the n=12 bit error vector e=0, . . . , 0. The error vector is provided to the second input of the XOR circuit  44  and is connected with x′ to form x c =x′⊕0, . . . , 0=000 100 101 111. The result is output at output line  412 . 
         [0153]    Now it is described how the circuit arrangement according to the invention behaves in case of an error in ternary memory  52 , i.e. the condition of a memory cell is falsified for whatever reason. 
         [0154]    We consider the case where a correct condition A 1  is distorted to become condition A 0  in the first memory cell. The tuple A 1 B 1 , which is stored in the first two memory cells correctly, is contiguous to the tuple of ternary values A 0 , B 1 . Upon readout, the triple 100 of binary values is, in accordance with Table 4, assigned to this incorrect tuple A 0 , A 1 , so that the sequence x′=100 100 101 111 is output at output  49  of circuit arrangement Schspei  42 . The incorrect sequence x′ differs in one bit from the correct sequence x. This sequence is mapped by the syndrome generator Syndr  45  to the error syndrome 1, 0, 0, 0, 0 that is available the line  410  and hence also at the input of decoder Dec  46 . The error syndrome is here equal to the first column of the H-matrix H. For the parity P(s) and for OR(s) there applies now 
         [0000]        P ( s )=1 and OR( s )=1 
         [0155]    These values are output on lines  104  and  105  in  FIG. 10 . Decoder Dec  46  outputs at its output  411  in correspondence with the 2 nd  line of Table 8 an error vector e=1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 that is connected in the XOR circuit  44  with the sequence x′ to x c =x′⊕e=(1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1)⊕(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)=(0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1)=x, so the error distorting A 1  to A 0  and resulting in an error in the binary sequence x′ is corrected properly. 
         [0156]    In another example, the case is considered that condition B 2  of the 8 th  memory cell is distorted to B 1 . The tuple of ternary values A 1 B 1  stored in the 7th and 8th memory cells of ternary memory  52  is contiguous to the corresponding correct tuple A 1 B 2 . The triple of binary values 000 is assigned according to table 4 to the incorrect tuple A 1 , B 1 , so this error results in the change of three consecutive bits of the binary sequence x′. For the parity P(s) and for OR(s) there applies now 
         [0000]        P ( s )=1 and OR( s )=1 
         [0157]    These values are output via lines  104  and  105  in  FIG. 10 . An error distorting a tuple of ternary values to a tuple of contiguous ternary values is detected from the fact that P(s)=1 and =OR(s)=1. 
         [0158]    At output  49  of circuit arrangement  42 , the bit sequence x′=000100101000 is now output, from which the error syndrome s=s 1 , s 2 , s 3 , s 4 , s 5 =1, 00, 1, 1 is derived which equals the XOR sum of the last three columns of the H-matrix H. This error syndrome does not form a column of the H-matrix H. 
         [0159]    By means of decoder  46 , the error vector e=0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 is, in accordance with the last line of Table 8, assigned to this syndrome, said error vector being XORed in the XOR circuit element-wise with x′=0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0 to x c =x′⊕e=x, so this error is detected and corrected properly. 
         [0160]    An error, that distorts two tuples of ternary values to two respectively contiguous tuples of ternary values results in P(s)=0 and OR(s)=1, which are output on lines  104  and  105  in  FIG. 10 . 
         [0161]    Now, there will be explained for one embodiment how the pertinent tuple of ternary values can be determined directly from a triple of binary values. 
         [0162]    A triple 111 of binary values is directly mapped to the tuple of ternary values A 1 B 2  in correspondence with the last line of Table 3. The triple of binary values is described by variables x 1 , x 2 , x 3 , irrespective of the fact for which pair of memory cells the tuple of ternary values is determined. 
         [0163]    We first consider circuit of  FIG. 8   b , which implements the circuit F 1    814  of  FIG. 8   a . Although in the instant case it is a matter of the 7 th  and 8 th  memory cells, the corresponding binary variables are, as mentioned, designated with x 1 , x 2 , x 3 , so that x 1 =1, x 2 =1, and x 3 =1 applies. Switches  83 ,  84 , and  85  each connect their input with their upper output, so that the input carrying the analog value V 1  is directly connected with the output  812  and A 1 =Since V 1  belongs to the interval W 1 , A 1 εW 1  correctly applies. The switches  86 ,  87 ,  88 , and  810  also connect their input with their upper output, so that no further connection of the input carrying the value V 1  exists with an output. 
         [0164]    Now, the circuit of  FIG. 8   c  which implements the circuit F 2  of  FIG. 8   a  will be considered. Since x 1 =x 3 =1, the switches  81  and  82  each connect their input with their upper output, so that B 2 =V 2  and B 2 εW 2  applies, since V 2 εW 2 . As illustrated in  FIG. 8   a , the output of circuit F 1 , which is marked with A 1 , and the output of circuit F 2 , which is marked with A 2 , are coupled to line  815  carrying value A=A 1 εW 1 , since this output is only coupled to the input of circuit F 1  carrying the analog signal V 1 . The output of circuit F 1 , which is marked with B 1 , and the output of circuit F 2 , which is marked with B 2 , are coupled to line  816  carrying value B=B 2 εW 2 , since this output for x 1 =x 3 =1 is only coupled to the input of circuit F 2  which carries the analog signal V 2 .