########################################################################
##
#F  AmalgatedDirectSumCode( <C>, <D>, [, <check> ] )
##
##  Return the amalgated 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 amalgated 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("AmalgatedDirectSumCode", 
							[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"); 


