1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
#############################################################################
##
#A codecstr.gd GUAVA library Reinald Baart
#A Jasper Cramwinckel
#A Erik Roijackers
#A Eric Minkes
#A David Joyner
##
## This file contains functions for constructing codes
##
########################################################################
##
#F AmalgamatedDirectSumCode( <C>, <D>, [, <check> ] )
##
## Return the amalgamated direct sum code of C en D.
##
## This construction is derived from the direct sum construction,
## but it saves one coordinate over the direct sum.
##
## The amalgamated direct sum construction goes as follows:
##
## Put the generator matrices G and H of C respectively D
## in standard form as follows:
##
## G => [ G' | I ] and H => [ I | H' ]
##
## The generator matrix of the new code then has the following form:
##
## [ 1 0 ... 0 0 | 0 0 ............ 0 ]
## [ 0 1 ... 0 0 | 0 0 ............ 0 ]
## [ ......... . | .................. ]
## [ G' 0 0 ... 1 0 | 0 0 ............ 0 ]
## [ |---------------|--------]
## [ 0 0 ... 0 | 1 | 0 ... 0 0 ]
## [--------|-----------|---| ]
## [ 0 0 ............ 0 | 0 1 ... 0 0 H' ]
## [ .................. | 0 ......... ]
## [ 0 0 ............ 0 | 0 0 ... 1 0 ]
## [ 0 0 ............ 0 | 0 0 ... 0 1 ]
##
## The codes resulting from [ G' | I ] and [ I | H' ] must
## be acceptable in the last resp. the first coordinate.
## Checking whether this is true takes a lot of time, however,
## and is only performed when the boolean variable check is true.
##
DeclareOperation("AmalgamatedDirectSumCode",
[IsCode, IsCode, IsBool]);
########################################################################
##
#F BlockwiseDirectSumCode( <C1>, <L1>, <C2>, <L2> )
##
## Return the blockwise direct sum of C1 and C2 with respect to
## the cosets defined by the codewords in L1 and L2.
##
DeclareOperation("BlockwiseDirectSumCode",
[IsCode, IsList, IsCode, IsList]);
########################################################################
##
#F ExtendedDirectSumCode( <L>, <B>, m )
##
## The construction as described in the article of Graham and Sloane,
## section V.
## ("On the Covering Radius of Codes", R.L. Graham and N.J.A. Sloane,
## IEEE Information Theory, 1985 pp 385-401)
##
DeclareOperation("ExtendedDirectSumCode",
[IsCode, IsCode, IsInt]);
########################################################################
##
#F PiecewiseConstantCode( <partition>, <constraints> [, <field> ] )
##
DeclareGlobalFunction("PiecewiseConstantCode");
########################################################################
##
#F GabidulinCode( );
##
DeclareOperation("GabidulinCode", [IsInt, IsFFE, IsFFE, IsBool]);
########################################################################
##
#F EnlargedGabidulinCode( );
##
DeclareOperation("EnlargedGabidulinCode",
[IsInt, IsFFE, IsFFE, IsFFE]);
########################################################################
##
#F DavydovCode( );
##
DeclareOperation("DavydovCode", [IsInt, IsInt, IsFFE, IsFFE]);
########################################################################
##
#F TombakCode( );
##
DeclareGlobalFunction("TombakCode");
########################################################################
##
#F EnlargedTombakCode( );
##
DeclareGlobalFunction("EnlargedTombakCode");
|
