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
110
111
|
#############################################################################
##
#A matrices.gd GUAVA library Reinald Baart
#A &Jasper Cramwinckel
#A &Erik Roijackers
##
## This file contains functions for generating matrices
##
#H @(#)$Id: matrices.gd,v 1.2 2003/02/12 03:49:19 gap Exp $
##
Revision.("guava/lib/matrices_gd") :=
"@(#)$Id: matrices.gd,v 1.2 2003/02/12 03:49:19 gap Exp $";
#############################################################################
##
#F KrawtchoukMat( <n> [, <q>] ) . . . . . . . matrix of Krawtchouk numbers
##
DeclareOperation("KrawtchoukMat", [IsInt, IsInt]);
#############################################################################
##
#F GrayMat( <n> [, <F>] ) . . . . . . . . . matrix of Gray-ordered vectors
##
## GrayMat(n [, F]) returns a matrix in which rows a(i) have the property
## d( a(i), a(i+1) ) = 1 and a(1) = 0.
##
DeclareOperation("GrayMat", [IsInt, IsField]);
#############################################################################
##
#F SylvesterMat( <n> ) . . . . . . . . . . . . Sylvester matrix of order <n>
##
DeclareOperation("SylvesterMat", [IsInt]);
#############################################################################
##
#F HadamardMat( <n> ) . . . . . . . . . . . . Hadamard matrix of order <n>
##
DeclareOperation("HadamardMat", [IsInt]);
#############################################################################
##
#F IsLatinSquare( <M> ) . . . . . . . determines if matrix is latin square
##
## IsLatinSquare determines if M is a latin square, that is a q*q array whose
## entries are from a set of q distinct symbols such that each row and each
## column of the array contains each symbol exactly once
##
DeclareOperation("IsLatinSquare", [IsMatrix]);
#############################################################################
##
#F AreMOLS( <matlist> ) . . . . . . . . . determines if arguments are MOLS
##
## AreMOLS(M1, M2, ...) determines if the arguments are mutually orthogonal
## latin squares.
##
DeclareGlobalFunction("AreMOLS");
#############################################################################
##
#F MOLS( <q> [, <n>] ) . . . . . . . . . . list of <n> MOLS of size <q>*<q>
##
## MOLS( q [, n]) returns a list of n Mutually Orthogonal Latin
## Squares of size q * q. If n is omitted, MOLS will return a list
## of two MOLS. If it is not possible to return n MOLS of size q,
## MOLS will return a boolean false.
##
DeclareOperation("MOLS", [IsInt, IsInt]);
#############################################################################
##
#F VerticalConversionFieldMat( <M> ) . . . . . . . converts matrix to GF(q)
##
## VerticalConversionFieldMat (M) converts a matrix over GF(q^m) to a matrix
## over GF(q) with vertical orientation of the tuples
##
DeclareOperation("VerticalConversionFieldMat",
[IsMatrix, IsField]);
#############################################################################
##
#F HorizontalConversionFieldMat( <M>, <F> ) . . . converts matrix to GF(q)
##
## HorizontalConversionFieldMat (M, F) converts a matrix over GF(q^m) to a
## matrix over GF(q) with horizontal orientation of the tuples
##
DeclareOperation("HorizontalConversionFieldMat",
[IsMatrix, IsField]);
#############################################################################
##
#F IsInStandardForm( <M> [, <boolean>] ) . . . . is matrix in standard form?
##
## IsInStandardForm(M [, identityleft]) determines if M is in standard form;
## if identityleft = false, the identitymatrix must be at the right side
## of M; otherwise at the left side.
##
DeclareOperation("IsInStandardForm", [IsMatrix, IsBool]);
#############################################################################
##
#F PutStandardForm( <M> [, <boolean>] [, <F>] ) . put <M> in standard form
##
## PutStandardForm(Mat [, idleft] [, F]) puts matrix Mat in standard form,
## the size of Mat being (n x m). If idleft is true or is omitted, the
## the identity matrix is put left, else right. The permutation is returned.
##
DeclareOperation("PutStandardForm",
[IsMatrix, IsBool, IsField]);
|
