Changeset c51e4a in git


Ignore:
Timestamp:
Aug 21, 2008, 4:06:56 PM (15 years ago)
Author:
Stanislav Bulygin <bulygin@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')
Children:
cdd38f3f5b6e0b7c443cc25476967388554dd82c
Parents:
1e8b8ea84b28157e5a3a88c6f332aed799c46a84
Message:
grammatical errors are corrected. output of solveForRandom and solveForCode is changed. FLSolveForRandom is now solveForRandomFL


git-svn-id: file:///usr/local/Singular/svn/trunk@11022 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/decodegb.lib

    r1e8b8e rc51e4a  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: decodegb.lib,v 1.1 2008-08-13 15:44:20 bulygin Exp $";
     2version="$Id: decodegb.lib,v 1.2 2008-08-21 14:06:56 bulygin Exp $";
    33category="Coding theory";
    44info="
     
    77
    88OVERVIEW:
    9  In this library we generate several systems used for decoding cyclic codes. And finding the minimum distance
     9 In this library we generate several systems used for decoding cyclic codes and finding their minimum distance.
    1010 Namely, we work with the Cooper's philosophy and generalized Newton identities.
    1111 The original method of quadratic equations is worked out here as well.
    1212 We also (for comparison) enable to work with the system of Fitzgerald-Lax.
    13  We provide also some auxiliary functions for further manipulations and decoding.
     13 We provide some auxiliary functions for further manipulations and decoding.
    1414 For an overview of the methods mentioned above, cf. Stanislav Bulygin, Ruud Pellikaan: 'Decoding and finding the minimum distance with
    1515 Groebner bases: history and new insights', in 'Selected Topics in Information and Coding Theory', World Scientific (2008) (to appear) (*).
     
    1919 sysCRHTMindistBinary(n,defset,w); generates the ideal from Cooper's philosophy to find the minimum distance in the binary case
    2020 sysNewton(n,defset,t,q,m,#); generates the ideal with the Generalized Newton identities
    21  sysBin(v,Q,n,#);  generates Bin system as in the work of Augot et.al, cf. [*] for a reference
    22  encode(x,g);  encodes given message with a given generator matrix
    23  syndrome(h, c);  computes a syndroem w.r.t. a given check matrix
     21 sysBin(v,Q,n,#);  generates Bin system as in the work of Augot et.al, cf. [*] for the reference
     22 encode(x,g);  encodes given message with the given generator matrix
     23 syndrome(h, c);  computes a syndrome w.r.t. the given check matrix
    2424 sysQE(check,y,t,fieldeq,formal); generates the system of quadratic equations as in the method of Pellikaan and Bulygin
    2525 error(y,pos,val);  inserts errors in a word
     
    2727 randomCheck(m,n,e);  generates a random check matrix
    2828 genMDSMat(n,a);  generates an MDS (actually an RS) matrix
    29  mindist(check);   computes the minimum distance of the code via solving systems of quadratic equations
    30  decode(rec);  decoding of a word using the systems of quadratic equations
     29 mindist(check);   computes the minimum distance of the code via solving the system of quadratic equations
     30 decode(rec);  decoding of a word using the system of quadratic equations
    3131 solveForRandom(redun,ncodes,ntrials,#);  a procedure for manipulation with random codes
    32  solveForCode(check,ntrials,#); a procedure for manipulation with a given codes
     32 solveForCode(check,ntrials,#); a procedure for manipulation with the given codes
    3333 vanishId(points); computes the vanishing ideal for the given set of points. The algorithm of Farr and Gao is implemented
    3434 sysFL(check,y,t,e,s); generates the Fitzgerald-Lax system
    35  FLSolveForRandom(n,redun,p,e,t,ncodes,ntrials,minpol); a procedure for manipulation with random codes via Fitzgerald-Lax
     35 solveForRandomFL(n,redun,p,e,t,ncodes,ntrials,minpol); a procedure for manipulation with random codes via Fitzgerald-Lax
    3636 
    3737
     
    105105          e the error-correcting capacity, m degree extension of the splitting field, if #>0 additional equations
    106106          representing the fact that every two error positions are either different or at least one of them is zero
    107 RETURN:   a ring to work with the CRHT-ideal (with Sala's additions), the ideal itself is exported with the name 'crht'
     107RETURN:   the ring to work with the CRHT-ideal (with Sala's additions), the ideal itself is exported with the name 'crht'
    108108EXAMPLE:  example sysCRHT; shows an example
    109109"
     
    193193"USAGE:  sysCRHTMindistBinary(n,defset,w);  n length of the cyclic code, defset is a list representing the defining set,
    194194         w is a candidate for the minimum distance
    195 RETURN:  a ring to work with the Sala's ideal for mindist, the ideal itself is exported with the name 'crht_md'
     195RETURN:  the ring to work with the Sala's ideal for the minimum distance, the ideal itself is exported with the name 'crht_md'
    196196EXAMPLE: example sysCRHTMindistBinary; shows an example
    197197"
     
    262262          t is the number of errors, q is basefield size, m is degree extension of the splitting field
    263263          if triangular>0 it indicates that Newton identities in triangular form should be constructed
    264 RETURN:   a ring to work with the generalized Newton identities (in triangular form if applicable),
     264RETURN:   the ring to work with the generalized Newton identities (in triangular form if applicable),
    265265          the ideal itself is exported with the name 'newton'
    266266EXAMPLE:  example sysNewton; shows an example
     
    417417
    418418proc sysBin (int v, list Q, int n, int#)
    419 "USAGE:    sysBin (v, Q, n, #);  v a number if errors, Q is a generating set of the code, n the length, # is additional parameter is
     419"USAGE:    sysBin (v, Q, n, #);  v a number if errors, Q is a generating set of the code, n the length, # is an additional parameter: if
    420420           set to 1, then the generating set is enlarged by odd elements, which are 2^(some power)*(some elment in the gen.set) mod n
    421 RETURN:    keeps a ring with the resulting system, which ideal is called 'bin'
     421RETURN:    keeps the ring with the resulting system, which ideal is called 'bin'
    422422EXAMPLE:   example sysBin; shows an example
    423423"
     
    576576"USAGE:   sysQE(check, y, t, fieldeq, formal); check is the check matrix of the code   
    577577          y is a received word, t the number of errors to be corrected,
    578           if fieldeq=1, then field equations are added; if formal=0, fields equations on (known) syndrome variables
     578          if fieldeq=1, then field equations are added; if formal=0, field equations on (known) syndrome variables
    579579          are not added, in order to add them (note that the exponent should be as a number of elements in the INITIAL alphabet) one
    580580          needs to set formal>0 for the exponent
     
    776776proc errorRand(matrix y, int num, int e)
    777777"USAGE:    errorRand(y, num, e); y is a (code) word, num is the number of errors, e is an extension degree (if one wants values to
    778            be from GF(p^e)
     778           be from GF(p^e))
    779779RETURN:    corresponding received word
    780780EXAMPLE:   example errorRand; shows an example
     
    836836proc randomCheck(int m, int n, int e, int #)
    837837"USAGE:    randomCheck(m, n, e); m x n are dimensions of the matrix, e is an extension degree (if one wants values to
    838            be from GF(p^e)
     838           be from GF(p^e))
    839839RETURN:    random check matrix
    840840EXAMPLE:   example randomCheck; shows an example
     
    871871
    872872proc genMDSMat(int n, number a)
    873 "USAGE:   genMDSMat(n, a); n x n are dimensions of the matrix, a is a primitive element of the field
     873"USAGE:   genMDSMat(n, a); n x n are dimensions of the matrix, a is a primitive element of the field.
    874874          An MDS matrix is constructed in the following way. We take a to be a generator of the multiplicative group of the field.
    875875          Then we construct the Vandermonde matrix with this a.
     
    10461046proc solveForRandom(int n, int redun, int ncodes, int ntrials, int #)
    10471047"USAGE:    solveForRandom(redun, q, ncodes, ntrials); redun is a redundabcy of a (random) code,
    1048            q = field size, ncodes = number of random codes to be processed
    1049            ntrials = number of received vectors per code to be corrected
    1050            if # is given it sets the correction capacity explicitly. It should be used in case one expexts some lower bound,
     1048           q = field size, ncodes = number of random codes to be processed,
     1049           ntrials = number of received vectors per code to be corrected.
     1050           If # is given it sets the correction capacity explicitly. It should be used in case one expexts some lower bound,
    10511051           otherwise the procedure tries to compute the real minimum distance to find out the error-correction capacity
    10521052RETURN:    nothing;
     
    11011101 
    11021102   tim=rtimer;
    1103    sys3=std(sys2);         
    1104    sys3;
     1103   sys3=std(sys2);   
    11051104   timdec=timdec+rtimer-tim;   
    11061105  }
    1107   timdec2=timdec2+rtimer-tim2; 
     1106  timdec2=timdec2+rtimer-tim2;
     1107  kill A;
    11081108 }
    11091109 printf("Time for mindist: %p", timdist);
     
    11251125proc solveForCode(matrix check, int ntrials, int #)
    11261126"USAGE:     solveForCode(check, ntrials);
    1127             check is a check matrix for the code, ntrials = number of received vectors per code to be corrected
    1128             if # is given it sets the correction cpacity explicitly. It should be used in case one expexts some lower bound
     1127            check is a check matrix for the code, ntrials = number of received vectors per code to be corrected.
     1128            If # is given it sets the correction capacity explicitly. It should be used in case one expects some lower bound,
    11291129            otherwise the procedure tries to compute the real minimum distance to find out the error-correction capacity
    11301130RETURN:     nothing; 
     
    11791179   
    11801180   tim=rtimer;
    1181    sys3=std(sys2);         
    1182    sys3;
     1181   sys3=std(sys2);   
    11831182   timdec=timdec+rtimer-tim;   
    11841183 }
     
    12801279
    12811280proc vanishId (list points)
    1282 "USAGE:  vanishId (points,e); points is a list of point that define, where polynomials from the vanishing ideal will vanish,
     1281"USAGE:  vanishId (points,e); points is a list of points, for which the vanishing ideal is to be constructed.
    12831282RETURN:  Vanishing ideal corresponding to the given set of points
    12841283EXAMPLE: example vanishId; shows an example
     
    17171716}
    17181717
    1719 proc FLSolveForRandom(int n, int redun, int p, int e, int t, int ncodes, int ntrials, string minpol)
    1720 "USAGE:    FLSolveForRandom(redun,p,e,n,t,ncodes,ntrials,minpol); n = length of codes generated, redun = redundancy of codes generated,
     1718proc solveForRandomFL(int n, int redun, int p, int e, int t, int ncodes, int ntrials, string minpol)
     1719"USAGE:    solveForRandomFL(redun,p,e,n,t,ncodes,ntrials,minpol); n = length of codes generated, redun = redundancy of codes generated,
    17211720           p = characteristics, e is the extension degree,
    1722            q = number of errors to correct, ncodes = number of random codes to be processed
     1721           t = number of errors to correct, ncodes = number of random codes to be processed
    17231722           ntrials = number of received vectors per code to be corrected
    17241723           due to some pecularities of SINGULAR one needs to provide minimal polynomial for the extension explicitly
    17251724RETURN:    nothing
    1726 EXAMPLE:   example FLSolveForRandom; shows an example
     1725EXAMPLE:   example solveForRandomFL; shows an example
    17271726{
    17281727 list l=FLpreprocess(p,e,n,t,minpol);
     
    17721771     "EXAMPLE:";  echo = 2;
    17731772     
    1774      // decoding for one random binary code of length 25, redundancy 14; 300 words are processed
    1775      FLSolveForRandom(25,14,2,1,1,1,300,"");
     1773     // correcting one error for one random binary code of length 25, redundancy 14; 300 words are processed
     1774     solveForRandomFL(25,14,2,1,1,1,300,"");
    17761775}
    17771776
Note: See TracChangeset for help on using the changeset viewer.