[GAP] - GAP – Groups, Algorithms, and Programming, Version 4.16dev, + GAP – Groups, Algorithms, and Programming, Version 4.17dev, The GAP Group (this year), https://www.gap-system.org.
BibXML: --and before theEntering break read-eval-print loop ...
line is produced -by the functionEntering break read-eval-print loop ...
+is produced by the functionyou can enter 'quit;' to ...
⪆ 3 compatibility modeis provided -(see ), -its use will disable some of the new features of ⪆ 4. -Also it certainly can only try to provide partial compatibility. - -For a detailed explanation of the new features and concepts of ⪆ 4, -see the manual
Programming in GAP. - - - -
redirectthe text -
functions areBy
no check. -When fun2 is called then it checks whether its arguments are valid, -and if so then it calls fun1. -The functions
immutableobjects. Such objects cannot be -changed, attempting to do so issues an error. Typically attribute -values are immutable, and also the results of those binary arithmetic -operations where both arguments are immutable, -see Section . -For example,
bypassing the dispatcherby -calling for example
parent(instead of
supergroup) -was chosen to indicate that the parent of an object was more than just -useful information. -In fact the main reason for the introduction of parents was to provide -a common roof for example for all groups of polycyclic words that -belonged to the same PC-presentation, or for all subgroups of a finitely -presented group (see ). -A subgroup was never a parent group, and it was possible to create -subgroups only of parent groups. - -In ⪆ 4 this common roof is provided already by the concept of -
official-workaround to set some components of the mapping record was quite -unwieldy. - -In ⪆ 4,
official wayto construct this natural homomorphism -was to create first the factor structure
operation -homomorphisms, have been replaced (just a name change) by
words in abstract generatorsof -the underlying free groups were (mis)used. This caused problems -whenever calculations with elements were involved, the most obvious -ones being wrong results of element comparisons. Also functions -that should in principle work for any group were not applicable to -finitely presented groups. In effect, a finitely presented group had -to be treated in a special way in ⪆ 3. - -⪆ 4 distinguishes free groups and their elements from finitely -presented groups and their elements. Comparing two elements of a -finitely presented group will yield either the correct result or no -result at all. - -Note that in ⪆ 4, the arithmetic and comparison operations for -group elements do not depend on a context provided by a group that -contains the elements. In particular, in ⪆ 4 it is not -meaningful to call
componentsof domains; - besides components that have no meaning for the rest of the ⪆ 4 - library, such as
oldobject and an -operations record, where the latter was a record containing the -functions applicable to the new object. After the library file -
Programming in ⪆mentioned above.) - -The next step is to write a function that creates a new object. -It may look as follows. - -
+ A WebAssembly build of GAP + running entirely in your browser — useful for trying things out + without installing. Not all packages work, working memory is + capped, and performance is reduced compared to a native build. + For real work, install GAP from + www.gap-system.org. +
++ GAP is a system for + computational discrete algebra, with particular emphasis on + computational group theory. This page is a self-contained + WebAssembly build, served as a static site and run inside a + Web Worker; you interact with it through an + xterm-pty + terminal in the page below. +
+
+ To get started, try 1+1;,
+ Factorial(20);, or SymmetricGroup(5);.
+ The full GAP
+ manuals apply, with two caveats: some packages won't load
+ (anything that needs a native compiler or system library), and
+ anything that wants the local filesystem won't work.
+
+ Files downloaded on first visit are cached in your browser's + IndexedDB, so subsequent visits start much faster. Clear the + site data to reset the cache. +
++ GAP is free software, distributed under the + GNU General Public License (version 2 or + later). See the copyright notice for + the full statement. +
+SharedArrayBuffer, which is only
+ available when the page is served with the headers
+ Cross-Origin-Opener-Policy: same-origin and
+ Cross-Origin-Embedder-Policy: require-corp. The
+ bundled service worker handles this on hosts where you can't set
+ headers (e.g. GitHub Pages); for local hosting use
+ etc/emscripten/serve.py.
+ ): not all entries ofwritten over "); - fi; - - # - # Now try and rewrite all the rows over this field - # this may fail if some rows are locked over a smaller field - # + # It may be possible to write the matrix over the field + # with 'q1' elements. + # We are not allowed to call 'ConvertToVectorRep( v, q1 )' + # in order to *test* whether the row 'v' lives over the desired + # field, but we may call it once we *know* that this is the case. + d:= Length( Factors( q1 ) ); + for v in m do + if d mod DegreeFFE( v ) <> 0 then + Error("ConvertToMatrixRep(, ): not all entries ofwritten over "); + elif q1 <> ConvertToVectorRep( v, q1 ) then + return fail; + fi; + od; + q:= q1; + else + # + # Now try and rewrite all the rows over this field + # this may fail if some rows are locked over a smaller field + # - for v in m do + for v in m do if q <> ConvertToVectorRepNC(v,q) then return fail; fi; - od; + od; + fi; fi; if q <= 256 then diff --git a/lib/matobj.gi b/lib/matobj.gi index 35ae1ccbe0..c2302ec5bf 100644 --- a/lib/matobj.gi +++ b/lib/matobj.gi @@ -885,6 +885,23 @@ end ); ## otherwise it is not specified what happens. ## If the result is a vector object then it has the same representation and ## the same base domain as the given vector object(s). +## +##v1 := Vector( Rationals, [-1,-1/2,0,1/2,1] );; Print( v1 ); +## NewVector(IsPlistVectorRep,Rationals,[ -1, -1/2, 0, 1/2, 1 ]) +## gap> v2 := Vector( [0,1,2,4,8], v1 );; Print( v2 ); +## NewVector(IsPlistVectorRep,Rationals,[ 0, 1, 2, 4, 8 ]) +## gap> Print( v1 + v2 ); +## NewVector(IsPlistVectorRep,Rationals,[ -1, 1/2, 2, 9/2, 9 ]) +## gap> Unpack( v2 - v1 ); +## [ 1, 3/2, 2, 7/2, 7 ] +## gap> Unpack( 2 * v1 ); Unpack( v1 * 4 ); Unpack( v2 / 4 ); +## [ -2, -1, 0, 1, 2 ] +## [ -4, -2, 0, 2, 4 ] +## [ 0, 1/4, 1/2, 1, 2 ] +## gap> v1 * v2; +## 19/2 +## ]]> ## ## ## <#/GAPDoc> @@ -1123,6 +1140,27 @@ InstallMethod( MultVectorRight, ## otherwise it is not specified what happens. ## If the result is a matrix object then it has the same representation and ## the same base domain as the given matrix object(s). +## +##m1 := Matrix( Rationals, [ [3,4,5], [6,7,8] ] );; +## gap> m2 := Matrix( [ [1,0,1], [0,1,0] ], m1 );; +## gap> Print( m1 + m2, "\n", m1 - m2 ); +## NewMatrix(IsPlistMatrixRep,Rationals,3,[ [ 4, 4, 6 ], [ 6, 8, 8 ] ]) +## NewMatrix(IsPlistMatrixRep,Rationals,3,[ [ 2, 4, 4 ], [ 6, 6, 8 ] ]) +## gap> Unpack( 3 * m2 ); Unpack( m2 * 5 ); Unpack( m2 / 2 ); +## [ [ 3, 0, 3 ], [ 0, 3, 0 ] ] +## [ [ 5, 0, 5 ], [ 0, 5, 0 ] ] +## [ [ 1/2, 0, 1/2 ], [ 0, 1/2, 0 ] ] +## gap> m3 := Matrix( Integers, [ [1,1], [0,1] ] );; +## gap> m4 := Matrix( Integers, [ [3,5], [4,7] ] );; +## gap> Print( m3 * m4 ); +## NewMatrix(IsPlistMatrixRep,Integers,2,[ [ 7, 12 ], [ 4, 7 ] ]) +## gap> Unpack( m3 * m4 ); +## [ [ 7, 12 ], [ 4, 7 ] ] +## gap> Unpack( m3^6 ); Unpack( m4^-1 ); +## [ [ 1, 6 ], [ 0, 1 ] ] +## [ [ 7, -5 ], [ -4, 3 ] ] +## ]]> ## ## ## <#/GAPDoc> @@ -1404,7 +1442,7 @@ InstallMethod( Characteristic, ## ##a matrix object ##-## For a vector object M, +## For a matrix object M, ## the operations for computing the additive inverse with prescribed ## mutability return a matrix object with the same ## and @@ -1476,7 +1514,14 @@ InstallMethod( ZeroSameMutability, InstallMethod( OneMutable, [ IsMatrixObj ], - M -> IdentityMatrix( NumberRows( M ), M ) ); + function( M ) + local nrows; + nrows:= NrRows( M ); + if nrows <> NrCols( M ) then + Error( " ## @@ -246,7 +242,7 @@ DeclareCategory( "IsMatrixObj", IsMatrixOrMatrixObj ); ## themust be square (not ", nrows, " by ", NrCols( M ), ")" ); + fi; + return IdentityMatrix( nrows, M ); + end ); InstallMethod( OneSameMutability, [ IsMatrixOrMatrixObj ], diff --git a/lib/matobj1.gd b/lib/matobj1.gd index ff53201b9c..c19130890f 100644 --- a/lib/matobj1.gd +++ b/lib/matobj1.gd @@ -110,16 +110,12 @@ DeclareCategory( "IsVectorObj", IsVector and IsVecOrMatObj and IsRowVectorOrVect ## argument. ## ## m:= IdentityMat( 2, GF(2) );; -## gap> IsMatrix( m ); IsMatrixObj( m ); IsMatrixOrMatrixObj( m ); -## true -## false -## true -## gap> m:= NewIdentityMatrix( IsPlistMatrixRep, GF(2), 2 );; -## gap> IsMatrix( m ); IsMatrixObj( m ); IsMatrixOrMatrixObj( m ); -## false -## true -## true +## gap> m := [ [1,2,3,4], [6,7,8,9] ];; +## gap> [ IsMatrix( m ), IsMatrixObj( m ), IsMatrixOrMatrixObj( m ) ]; +## [ true, false, true ] +## gap> m1 := Matrix( Integers, [ [1,2,3,4], [6,7,8,9] ] );; +## gap> [ IsMatrix( m1 ), IsMatrixObj( m1 ), IsMatrixOrMatrixObj( m1 ) ]; +## [ false, true, true ] ## ]]> ##i -th row ofM , ## for1 \leq i \leq NumberRows( M ) . ## -## All rows are objects in the same +## All rows are objects in the compatible ## representation. ## Several rows of a row list matrix object can be identical objects, ## and different row list matrices may share rows. @@ -256,6 +252,14 @@ DeclareCategory( "IsMatrixObj", IsMatrixOrMatrixObj ); ## Matrix objects in arenot ## necessarily in , ## and then they need not obey the general rules for lists. +## +##m1 := Matrix( Integers, [ [1,2,3,4], [6,7,8,9] ] );; +## gap> IsRowListMatrix( m1 ); +## true +## gap> Print( m1[2] ); +## NewVector(IsPlistVectorRep,Integers,[ 6, 7, 8, 9 ]) +## ]]> ## ## ## <#/GAPDoc> @@ -283,6 +287,12 @@ DeclareCategory( "IsRowListMatrix", IsMatrixObj ); ## its base domain with respect to ## , see Section ## . +## +##v := Vector( Rationals, [ 3, 4, 7, 8 ] );; +## gap> BaseDomain( v ); +## Rationals +## ]]> ## ## ## <#/GAPDoc> @@ -292,44 +302,6 @@ DeclareAttribute( "BaseDomain", IsVecOrMatObj ); #DeclareAttribute( "BaseDomain", IsMatrixOrMatrixObj ); -############################################################################# -## -#A NumberRows() -#A NrRows( ) -#A NumberColumns( ) -#A NrCols( ) -## -## <#GAPDoc Label="NumberRowsNumberColumns"> -## -## -## <#/GAPDoc> -## -DeclareAttributeKernel( "NumberRows", IsMatrixOrMatrixObj, NUMBER_ROWS ); -DeclareSynonymAttr( "NrRows", NumberRows ); -InstallTrueMethod( HasNumberRows, IsMatrixOrMatrixObj and IsPlistRep); - -DeclareAttributeKernel( "NumberColumns", IsMatrixOrMatrixObj, NUMBER_COLUMNS ); -DeclareSynonymAttr( "NrCols", NumberColumns ); -InstallTrueMethod( HasNumberColumns, IsMatrixOrMatrixObj and IsPlistRep ); - - ############################################################################# ## #A OneOfBaseDomain(NumberRows and NumberColumns -##-## -## -## -## -## -## For a matrix object M, -## and -## store the -## number of rows and columns of M, respectively. -## -## and -## are synonyms of -## and -## , respectively. -## -##) @@ -374,6 +346,52 @@ DeclareAttribute( "ZeroOfBaseDomain", IsVecOrMatObj ); #DeclareAttribute( "ZeroOfBaseDomain", IsMatrixOrMatrixObj ); +############################################################################# +## +#A NumberRows( ) +#A NrRows( ) +#A NumberColumns( ) +#A NrCols( ) +## +## <#GAPDoc Label="NumberRowsNumberColumns"> +## +## +## <#/GAPDoc> +## +DeclareAttributeKernel( "NumberRows", IsMatrixOrMatrixObj, NUMBER_ROWS ); +DeclareSynonymAttr( "NrRows", NumberRows ); +InstallTrueMethod( HasNumberRows, IsMatrixOrMatrixObj and IsPlistRep); + +DeclareAttributeKernel( "NumberColumns", IsMatrixOrMatrixObj, NUMBER_COLUMNS ); +DeclareSynonymAttr( "NrCols", NumberColumns ); +InstallTrueMethod( HasNumberColumns, IsMatrixOrMatrixObj and IsPlistRep ); + + ############################################################################# ## #V ConstructingFiltersForMatrixGroupElements diff --git a/lib/matobj2.gd b/lib/matobj2.gd index e2f457d734..6ff3dee12f 100644 --- a/lib/matobj2.gd +++ b/lib/matobj2.gd @@ -155,24 +155,6 @@ ## -############################################################################# -## -#A Length(NumberRows and NumberColumns +##+## +## +## +## +## +## For a matrix object M, +## and +## store the +## number of rows and columns of M, respectively. +## +## and +## are synonyms of +## and +## , respectively. +## +## +##m1 := Matrix( Integers, [ [1,2,3,4], [6,7,8,9] ] );; +## gap> NumberRows( m1 ); +## 2 +## gap> NrCols( m1 ); +## 4 +## ]]> +##) -## -## <#GAPDoc Label="Length_IsVectorObj"> -## -## -## <#/GAPDoc> -## -DeclareAttribute( "Length", IsVectorObj ); - - ############################################################################# ## #A ConstructingFilter(-## -## -## returns the length of the vector object v, -## which is defined to be the number of entries of v. -## -##) @@ -198,6 +180,12 @@ DeclareAttribute( "Length", IsVectorObj ); ## value of v or M implies then ## mutable versions of v or M can be created, ## otherwise all vector or matrix objects with this filter are immutable. +## +## v := Vector( Rationals, [3,4,7,8] );; +## gap> ConstructingFilter( v ); +## ## ## ## <#/GAPDoc> @@ -222,6 +210,14 @@ DeclareAttribute( "ConstructingFilter", IsVecOrMatObj ); ## value ##+## ]]> f are compatible in the sense that M can be multiplied with ## these vector objects, offail if no such filter is known. +## +##m1 := Matrix( Integers, [ [1,2,3,4], [6,7,8,9] ] );; +## gap> ConstructingFilter( m1 ); +## ## ## ## <#/GAPDoc> @@ -231,211 +227,886 @@ DeclareAttribute( "CompatibleVectorFilter", IsMatrixOrMatrixObj ); ############################################################################# ## -## List Like Operations for Vector Objects +#A Length(+## gap> CompatibleVectorFilter( m1 ); +## +## ]]> ) +## +## <#GAPDoc Label="Length_IsVectorObj"> +## +## +## <#/GAPDoc> ## +DeclareAttribute( "Length", IsVectorObj ); ############################################################################# ## -#O \[\](+## +## +## returns the length of the vector object v, +## which is defined to be the number of entries of v. +## +##, ) -#O \[\]\:\=( , , ) -#O \{\}( , ) +#O Vector(
, , ) +#O Vector(
, ) +#O Vector(
, , ) +#O Vector( , ) +#O Vector( ,
) +#O Vector( , ) ## -## <#GAPDoc Label="ElementAccessVectorObj"> +## <#GAPDoc Label="Vector"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "[]", [ IsVectorObj, IsPosInt ] ); - -DeclareOperation( "[]:=", [ IsVectorObj, IsPosInt, IsObject ] ); - -DeclareOperation( "{}", [ IsVectorObj, IsList ] ); +DeclareOperation( "Vector", [ IsOperation, IsSemiring, IsList ] ); +DeclareOperation( "Vector", [ IsSemiring, IsList ] ); +DeclareOperation( "Vector", [ IsOperation, IsSemiring, IsVectorObj ] ); +DeclareOperation( "Vector", [ IsSemiring, IsVectorObj ] ); +DeclareOperation( "Vector", [ IsList, IsVectorObj ] ); +DeclareOperation( "Vector", [ IsVectorObj, IsVectorObj ] ); +DeclareOperation( "Vector", [ IsList ] ); ############################################################################# ## -## <#GAPDoc Label="MatObj_PositionNonZero"> +#O ZeroVector(Element Access and Assignment for Vector Objects -## -##-## -## +## Vector +##+## +## +## +## ## +## a vector object ##-## For a vector object v and a positive integer i that is -## not larger than the length of v -## (see ), -## v ##[ i] is the entry at position i. +## If a filter filt is given as the first argument then +## a vector object is returned that has +## +## value filt, is defined over the base domain R, +## and has the entries given by the list list or the vector object +## vecobj, respectively. ## -## If v is mutable, i is as above, and obj is an object -## from the base domain of v then -## v[ i]:= obj assigns obj to the -## i-th position of v. +## If a semiring R is given as the first argument then +## a vector object is returned whose +## +## value is guessed from R, again with base domain R +## and entries given by the last argument. ## -## If list is a list of positive integers that are not larger than -## the length of v then -## v{ list} returns a new mutable vector object -## in the same representation as v -## (see ) -## that contains the list[ k ] -th entry of v at -## positionk . +## In the remaining cases with two arguments, +## the first argument is a list or a vector object +## that defines the entries of the result, +## and the second argument is a vector object whose +## and +## are taken for the +## result. +## +## The variant +##Vector( vecobj, vecobj_example) +## is supported also for the case that vecobj is a row vector +## but not a vector object. +## In this situation, the result is a row vector that is equal to +## vecobj and whose +## and +## +## are taken from the example. +## +## If only a list list is given then both the +## and the +## are guessed from +## this list. ## ## If the global optioncheck is set tofalse then -## +## ## need not perform consistency checks. ## -## Note that the sublist assignment operation -## is left out here since it tempts the programmer to use constructions like -##v{ [ 1 .. 3 ] }:= w{ [ 4 .. 6 ] } -## which produces an unnecessary intermediate object; -## one should use instead. +## If the +## value of the result implies then the result is +## mutable if and only if the argument that determines the entries of the +## result (list, v, v1) is mutable. +## +## In the case of a mutable result, it isnot guaranteed that +## the given list of entries is copied. +## +## Default methods for +## +## delegate to . +## +##v1 := Vector( Integers, [3,4,7,8] );; Print( v1 ); +## NewVector(IsPlistVectorRep,Integers,[ 3, 4, 7, 8 ]) +## gap> v2 := Vector( Rationals, v1 );; Print( v2 ); +## NewVector(IsPlistVectorRep,Rationals,[ 3, 4, 7, 8 ]) +## gap> v3 := Vector( [ 11..13], v1) ;; Print( v3 ); +## NewVector(IsPlistVectorRep,Integers,[ 11, 12, 13 ]) +## gap> v0 := [6..9];; IsVector( v0 ); +## true +## gap> Print( Vector( v0, v1 ) ); +## NewVector(IsPlistVectorRep,Integers,[ 6, 7, 8, 9 ]) +## gap> v4 := Vector( [ 2, 5/2, 7/3, 3 ] );; Print( v4 ); +## NewVector(IsPlistVectorRep,Rationals,[ 2, 5/2, 7/3, 3 ]) +## gap> v5 := Vector( IsGF2VectorRep, GF(2), [ 0, 1, 2 ]*Z(2)^0 );; +## gap> Print( v5 ); +## [ 0*Z(2), Z(2)^0, 0*Z(2) ] +## gap> v6 := Vector( IsZmodnZVectorRep, ZmodnZ(8), v1 ); +## ##+## gap> BaseDomain( v6 ); +## (Integers mod 8) +## gap> v7 := Vector( IsZmodnZVectorRep, ZmodnZ(12), v0 ); +## +## ]]> , ) +#O ZeroVector( , ) +#O ZeroVector( , ) +#O ZeroVector( , , ) +## +## <#GAPDoc Label="VectorObj_ZeroVector"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "PositionNonZero", [ IsVectorObj ] ); +DeclareOperation( "ZeroVector", [ IsSemiring, IsInt ] ); +DeclareOperation( "ZeroVector", [ IsInt, IsVecOrMatObj ] ); +DeclareOperation( "ZeroVector", [ IsOperation, IsSemiring, IsInt ] ); +#DeclareOperation( "ZeroVector", [ IsInt, IsVectorObj ] ); +#DeclareOperation( "ZeroVector", [ IsInt, IsMatrixOrMatrixObj ] ); ############################################################################# ## -## <#GAPDoc Label="MatObj_PositionLastNonZero"> +#O NewVector(+## ZeroVector +##+## +## +## ## -## An integer +##a vector object ##-## Returns the index of the first entry in the vector object v -## that is not zero. -## If all entries are zero, -## the function returns ##Length(v) + 1 . +## For a semiring R and a nonnegative integer len, +## this operation returns a new vector object of length len +## over R in the representation filt containing only zeros. +## &GAP; guesses a suitable representation. +## +## For a vector object v and a nonnegative integer len, +## this operation returns a new vector object of length len +## in the same representation as v containing only zeros. +## +## For a matrix object M and a nonnegative integer len, +## this operation returns a new zero vector object of length +## len in the representation given by the +## value +## of M, provided that such a representation exists. +## +## For a filter filt, a semiring R and a nonnegative integer +## len, this operation returns a new vector object of length +## len over R in the representation filt +## containing only zeros. +## +## If the +## value of the result implies then the result is +## mutable. +## +## Default methods for +## +## delegate to . +## +##z1 := ZeroVector( Rationals, 4 );; Print( z1 ); +## NewVector(IsPlistVectorRep,Rationals,[ 0, 0, 0, 0 ]) +## gap> v5 := Vector( GF(5), [3,4]*Z(5) );; z5 := ZeroVector(3,v5);; Print(z5); +## [ 0*Z(5), 0*Z(5), 0*Z(5) ] +## gap> m6:=Matrix(Integers,[[1,3],[5,7]]);; z6:=ZeroVector(6,m6);; Print(z6); +## NewVector(IsPlistVectorRep,Integers,[ 0, 0, 0, 0, 0, 0 ]) +## gap> z8 := ZeroVector( IsZmodnZVectorRep, ZmodnZ(8), 4 );; Print( z8 ); +## NewVector(IsZmodnZVectorRep,Monoid( ... ),[ 0, 0, 0, 0 ]) +## ]]> ##, , ) +#O NewZeroVector(
, , ) +## +## <#GAPDoc Label="NewVector"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "PositionLastNonZero", [ IsVectorObj ] ); +DeclareTagBasedOperation( "NewVector", [ IsOperation, IsSemiring, IsList ] ); + +DeclareTagBasedOperation( "NewZeroVector", + [ IsOperation, IsSemiring, IsInt ] ); ############################################################################# ## -#O ListOp(+## NewVector and NewZeroVector +##+## ## -## An integer ##-## Returns the index of the last entry in the vector object v -## that is not zero. -## If all entries are zero, the function returns ##0 . +## These two operations areconstructors , and should only be used +## when or +## +## do not give the desired result. +## +## For a filter filt, a semiring R, and a list list +## of elements that belong to R, +## returns a vector object which has +## the +## filt, +## the R, +## and the entries in list. +## The list list is guaranteed not to be changed by this operation. +## +## If the global optioncheck is set tofalse then +## need not perform consistency checks. +## +## Similarly, returns a vector object +## of length n which has filt and R as +## and +## values, +## and contains the zero of R in each position. +## +## The returned object is mutable if and only if filt implies +## . +## +##v := NewVector( IsGF2VectorRep, GF(2), [1,0,1,0,1]*Z(2) ); +## +## gap> Print(v); +## [ Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ] +## gap> NewZeroVector( IsZmodnZVectorRep, ZmodnZ(7), 5 ); +## ##+## ]]> [, ] ) +#O Matrix( , , ,
) +#O Matrix( , , ) +#O Matrix(
, ,
) +#O Matrix( , ) +#O Matrix(
, , ) +#O Matrix( , ) +#O Matrix( ,
, ) +#O Matrix( ,
) +#O Matrix( , ) +#O Matrix( ,
) +#O Matrix( ) ## -## <#GAPDoc Label="MatObj_ListOp"> +## <#GAPDoc Label="MatObj_Matrix"> ##
-## +## <#/GAPDoc> +## +DeclareOperation( "Matrix", [ IsOperation, IsSemiring, IsList, IsInt ] ); +DeclareOperation( "Matrix", [ IsOperation, IsSemiring, IsList ] ); +DeclareOperation( "Matrix", [ IsOperation, IsSemiring, IsMatrixOrMatrixObj ] ); +DeclareOperation( "Matrix", [ IsSemiring, IsList, IsInt ] ); +DeclareOperation( "Matrix", [ IsSemiring, IsList ] ); +DeclareOperation( "Matrix", [ IsSemiring, IsMatrixOrMatrixObj ] ); +DeclareOperation( "Matrix", [ IsList, IsInt, IsMatrixOrMatrixObj ] ); +DeclareOperation( "Matrix", [ IsList, IsMatrixOrMatrixObj ] ); +DeclareOperation( "Matrix", [ IsMatrixOrMatrixObj, IsMatrixOrMatrixObj ] ); +DeclareOperation( "Matrix", [ IsList, IsInt ] ); +DeclareOperation( "Matrix", [ IsList ]); + + +############################################################################# +## +#O ZeroMatrix(+## Matrix +##+## +## +## +## ## -## A plain list +##a matrix object ##-## Applies the function func to each entry of the vector object -## v and returns the results as a mutable plain list. -## This allows for calling -## on vector objects. +## If a filter filt is given as the first argument +## then a matrix object is returned that has +## +## value filt, is defined over the base domain R, +## and has the entries given by the list list +## or the matrix object matobj, respectively. +## Here list can be either a list of plain lists that describe the +## entries of the rows, or a flat list of the entries in row major order, +## where ncols defines the number of columns. +## +## If a semiring R is given as the first argument then +## a matrix object is returned whose +## +## value filt is guessed from R, +## again with base domain R and entries given by the last argument. +## +## In those cases where the last argument is a matrix object, +## the first argument is a list or a matrix object +## that defines the entries of the result, then the +## and +## +## of the last argument are taken for the result. +## +## Finally, if only a list list and perhaps ncols is given +## then both the +## and the +## are guessed from +## the list. +## +## If the global option +##check is set tofalse then +## +## need not perform consistency checks. +## +## If the +## value of the result implies then the result is +## mutable if and only if the argument that determines the entries of the +## result (list or matobj) is mutable. +## +## In the case of a mutable result, it is guaranteed that the given list +## list is copied in the sense of , +## and if list is a nested list then it isnot guaranteed +## that also the entries of list are copied. +## +## Default methods for +## +## delegate to . +## +##m1 := Matrix( Integers, [ [3,4,5], [6,7,8] ] );; Print( m1 ); +## NewMatrix(IsPlistMatrixRep,Integers,3,[ [ 3, 4, 5 ], [ 6, 7, 8 ] ]) +## gap> m2 := Matrix( Rationals, [10..30], 7 );; Display( m2 ); +## <3x7-matrix over Rationals: +## [[ 10 .. 16 ] +## [ 17 .. 23 ] +## [ 24 .. 30 ] +## ]> +## gap> Print( Matrix( Integers, m2 ) ); +## NewMatrix(IsPlistMatrixRep,Integers,7, +## [ [ 10 .. 16 ], [ 17 .. 23 ], [ 24 .. 30 ] ]) +## gap> m3 := Matrix( [[7,6],[4,3]], m2 );; Print(m3); +## NewMatrix(IsPlistMatrixRep,Rationals,2,[ [ 7, 6 ], [ 4, 3 ] ]) +## gap> m4 := Matrix( [-7..-2], 3, m2 );; Print(m4); +## NewMatrix(IsPlistMatrixRep,Rationals,3,[ [ -7, -6, -5 ], [ -4, -3, -2 ] ]) +## gap> m0 := [[-1,-2],[-3,-4]];; IsMatrix(m0); +## true +## gap> Print( Matrix( m0, m1 ) ); +## NewMatrix(IsPlistMatrixRep,Integers,2,[ [ -1, -2 ], [ -3, -4 ] ]) +## gap> m5 := Matrix( [ [0,1,2], [7,8,9] ] );; Print( m5 ); +## NewMatrix(IsPlistMatrixRep,Rationals,3,[ [ 0, 1, 2 ], [ 7, 8, 9 ] ]) +## gap> Print( Matrix( [-9..-4], 3, m1 ) ); +## NewMatrix(IsPlistMatrixRep,Integers,3,[ [ -9, -8, -7 ], [ -6, -5, -4 ] ]) +## gap> m6 := Matrix( IsGF2MatrixRep, GF(2), [[1,0,1],[0,1,0]]*Z(2)^0 );; +## gap> Display( m6 ); +## 1 . 1 +## . 1 . +## gap> m7 := Matrix( IsZmodnZMatrixRep, ZmodnZ(8), [1..6], 3 ); +## +##+## gap> m8 := Matrix( IsZmodnZMatrixRep, ZmodnZ(12), m0 ); +## +## ]]> , , ) +#O ZeroMatrix( , , ) +#O ZeroMatrix( , , , ) +## +## <#GAPDoc Label="MatObj_ZeroMatrix"> +## +## +## <#/GAPDoc> +## +DeclareOperation( "ZeroMatrix", [ IsInt, IsInt, IsMatrixOrMatrixObj ] ); +DeclareOperation( "ZeroMatrix", [ IsSemiring, IsInt, IsInt ] ); +DeclareOperation( "ZeroMatrix", [ IsOperation, IsSemiring, IsInt, IsInt ] ); + + +############################################################################# +## +#O IdentityMatrix(ZeroMatrix +##+## +## +## +## a matrix object +##+## For a matrix object M and two nonnegative integers m +## and n, this operation returns a new matrix object +## with m rows and n columns +## in the same representation and over the same base domain as M +## containing only zeros. +## +## If a semiring R and two nonnegative integers m and +## n are given, +## the representation of the result is guessed from R. +## +## If a filter filt and a semiring R are given as the first +## and second argument, they are taken as the values of +## and +## of the result. +## +## If the +## value of the result implies then the result is +## fully mutable. +## +## Default methods for +## +## delegate to . +## +## +##m7 := Matrix( IsZmodnZMatrixRep, ZmodnZ(8), [1..6], 3 );; +## gap> z7 := ZeroMatrix( 2, 2, m7 );; Print( z7 ); +## NewMatrix(IsZmodnZMatrixRep,Monoid( ... ),2, +## [ [ ZmodnZObj( 0, 8 ), ZmodnZObj( 0, 8 ) ], +## [ ZmodnZObj( 0, 8 ), ZmodnZObj( 0, 8 ) ] ]) +## gap> z23 := ZeroMatrix( Rationals, 2, 3 );; Print( z23 ); +## NewMatrix(IsPlistMatrixRep,Rationals,3,[ [ 0, 0, 0 ], [ 0, 0, 0 ] ]) +## gap> z5 := ZeroMatrix( IsGF2MatrixRep, GF(2), 2, 5 );; Display( z5 ); +## . . . . . +## . . . . . +## ]]> +##, ) +#O IdentityMatrix( , ) +#O IdentityMatrix( , , ) +## +## <#GAPDoc Label="MatObj_IdentityMatrix"> +## +## +## <#/GAPDoc> +## +DeclareOperation( "IdentityMatrix", [ IsInt, IsMatrixOrMatrixObj ] ); +DeclareOperation( "IdentityMatrix", [ IsSemiring, IsInt ] ); +DeclareOperation( "IdentityMatrix", [ IsOperation, IsSemiring, IsInt ] ); + + +############################################################################# +## +#O NewMatrix(IdentityMatrix +##+## +## +## +## a matrix object +##+## For a matrix object M and a nonnegative integer n, +## this operation returns a new identity matrix object +## with n rows and columns +## in the same representation and over the same base domain as M. +## +## If a semiring R and a nonnegative integer n is given, +## the representation of the result is guessed from R. +## +## If a filter filt and a semiring R are given as the first +## and second argument, they are taken as the values of +## and +## of the result. +## +## If the +## value of the result implies then the result is +## fully mutable. +## +## Default methods for +## +## delegate to . +## +## +##m7 := Matrix( IsZmodnZMatrixRep, ZmodnZ(8), [1..6], 3 );; +## gap> id7 := IdentityMatrix( 2, m7 );; Print( id7 ); +## NewMatrix(IsZmodnZMatrixRep,Monoid( ... ),2, +## [ [ ZmodnZObj( 1, 8 ), ZmodnZObj( 0, 8 ) ], +## [ ZmodnZObj( 0, 8 ), ZmodnZObj( 1, 8 ) ] ]) +## gap> id2 := IdentityMatrix( Rationals, 2 );; Print( id2 ); +## NewMatrix(IsPlistMatrixRep,Rationals,2,[ [ 1, 0 ], [ 0, 1 ] ]) +## gap> id3 := IdentityMatrix( IsGF2MatrixRep, GF(2), 3 );; Display( id3 ); +## 1 . . +## . 1 . +## . . 1 +## ]]> +##, , , ) +#O NewMatrix(
, , ,
) +#O NewMatrix( , , ) +#O NewZeroMatrix(
, , , ) +#O NewIdentityMatrix( , , ) +## +## <#GAPDoc Label="NewMatrix"> +## +## +## <#/GAPDoc> +## +DeclareTagBasedOperation( "NewMatrix", + [ IsOperation, IsSemiring, IsInt, IsList] ); + +DeclareOperation( "NewMatrix", + [ IsOperation, IsSemiring, IsList, IsInt] ); + +DeclareOperation( "NewMatrix", + [ IsOperation, IsSemiring, IsList] ); + +DeclareTagBasedOperation( "NewZeroMatrix", + [ IsOperation, IsSemiring, IsInt, IsInt ] ); + +DeclareTagBasedOperation( "NewIdentityMatrix", + [ IsOperation, IsSemiring, IsInt ] ); + + +############################################################################# +## +## Operations for Vector and Matrix Objects +## + + +############################################################################# +## +#O Unpack(NewMatrix, NewZeroMatrix, NewIdentityMatrix +##+## +## +## +## +## +## +## These three operations are +##constructors , and should only be used +## by those implementing new material for matrix objects. +## Most users should find +## , +## or +## +## sufficient for their requirements. +## +## For a filter filt, a semiring R, +## a positive integer ncols, and a list list, +## returns a matrix object which has +## the +## filt, +## the R, +## n columns +## (see ), +## and the entries described by list, +## which can be either a plain list of vector objects of length ncols +## or a plain list of plain lists of length ncols +## or a plain list of length a multiple of ncols containing the +## entries in row major order. +## The list list is guaranteed not to be changed by this operation. +## +## The corresponding entries must be in or compatible with R. +## If list already contains vector objects, they are copied. +## +## The second and third alternatives forNewMatrix have been added +## for consistency with the corresponding versions ofMatrix . +## They just call the first version. +## +## If the global optioncheck is set tofalse then +## need not perform consistency checks. +## +## Similarly, returns a zero matrix +## object with m rows and n columns +## which has filt and R as +## and +## values. +## +## Similarly, returns an identity +## matrix object with n rows and columns +## which has filt and R as +## and +## values, +## and contains the identity element of R in the diagonal +## and the zero of R in each off-diagonal position. +## +## The returned object is mutable if and only if filt implies +## . +## +##m1 := NewMatrix( IsPlistMatrixRep, Integers, 3, [ [4,5,6], [7,8,9] ] );; +## gap> Display( m1 ); +## <2x3-matrix over Integers: +## [[ 4, 5, 6 ] +## [ 7, 8, 9 ] +## ]> +## gap> NewZeroMatrix( IsPlistMatrixRep, Rationals, 5, 3 ); +## <5x3-matrix over Rationals> +## gap> NewIdentityMatrix( IsGF2MatrixRep, GF(2), 4 ); +## +## ]]> +##) +#O Unpack( ) +## +## <#GAPDoc Label="Unpack"> +## +## +## <#/GAPDoc> +## +## Note that 'AsList' would not be suitable in the case of vector objects +## because its result would be immutable. +## +DeclareOperation( "Unpack", [ IsVecOrMatObj ] ); +#DeclareOperation( "Unpack", [ IsVectorObj ] ); +#DeclareOperation( "Unpack", [ IsMatrixOrMatrixObj ] ); + + +############################################################################# +## +#O ChangedBaseDomain(Unpack +##+## +## +## A plain list +##+## Returns a new mutable plain list (see ) +## containing the entries of the vector object v or the matrix object +## M, respectively. +## In the case of a matrix object, +## the result is a plain list of plain lists. +## +## Changing the result does not change v or M, respectively. +## The entries themselves are not copied. +## +## +##m1 := Matrix( Integers, [ [1,2,3,4], [6,7,8,9] ] );; +## gap> Unpack( m1 ); +## [ [ 1, 2, 3, 4 ], [ 6, 7, 8, 9 ] ] +## ]]> +##, ) +#O ChangedBaseDomain( , ) +## +## <#GAPDoc Label="ChangedBaseDomain"> +## +## +## <#/GAPDoc> +## +DeclareOperation( "ChangedBaseDomain", [ IsVecOrMatObj, IsSemiring ] ); +#DeclareOperation( "ChangedBaseDomain", [ IsVectorObj, IsSemiring ] ); +#DeclareOperation( "ChangedBaseDomain", [ IsMatrixOrMatrixObj, IsSemiring ] ); + + +############################################################################ +## +#O Randomize( [Rs, ]v ) +#O Randomize( [Rs, ]M ) +## +## <#GAPDoc Label="Randomize"> +##ChangedBaseDomain +##+## +## +## +## For a vector object v (a matrix object M) +## and a semiring R, +## returns +## a new vector object (matrix object) +## with value R, +## value +## equal to that of v (M), +## and the same entries as v (M). +## +## The result is mutable if and only if v (M) is mutable. +## +## For example, one can create a vector defined over +##GF(4) +## from a vector defined overGF(2) with this operation. +## +##v1 := Vector( Integers, [ 3, 5, 7, 9 ] );; +## gap> ChangedBaseDomain( v1, Rationals ); +## +##+## gap> m6 := Matrix( IsGF2MatrixRep, GF(2), [[1,0,1],[0,1,0]]*Z(2)^0 );; +## gap> m64 := ChangedBaseDomain( m6, GF(4) ); +## [ [ Z(2)^0, 0*Z(2), Z(2)^0 ], [ 0*Z(2), Z(2)^0, 0*Z(2) ] ] +## gap> ConstructingFilter( m64 ); +## +## ]]> +## ## <#/GAPDoc> ## -DeclareOperation( "ListOp", [ IsVectorObj ] ); -DeclareOperation( "ListOp", [ IsVectorObj, IsFunction ] ); +DeclareOperation( "Randomize", [ IsVectorObj and IsMutable ] ); +DeclareOperation( "Randomize", [ IsRandomSource, IsVectorObj and IsMutable ] ); +DeclareOperation( "Randomize", [ IsMatrixOrMatrixObj and IsMutable ] ); +DeclareOperation( "Randomize", [ IsRandomSource, IsMatrixOrMatrixObj and IsMutable ] ); ############################################################################# ## -#O Unpack(Randomize +##+## +## +## Replaces every entry in the mutable vector object v +## or matrix object M, respectively, with +## a random one from the base domain of v or M, +## respectively, and returns the argument. ## -## If the argument func is not given, -## applies to all entries. +## If given, the random source Rs is used to compute the +## random elements. +## Note that in this case, +## a +## method must be available that takes a random source as its first +## argument and the base domain as its second argument. +## ##m6 := ZeroMatrix( IsGF2MatrixRep, GF(2), 2, 10 );; +## gap> Randomize( m6 ); Display( m6 ); +## +## . 1 . . 1 . 1 . . . +## . . 1 . . . 1 1 . 1 +## ]]> ##) -#O Unpack( ) +## List Like Operations for Vector Objects ## -## <#GAPDoc Label="Unpack"> + + +############################################################################# +## +#O \[\]( , ) +#O \[\]\:\=( , , ) +#O \{\}( , ) +## +## <#GAPDoc Label="ElementAccessVectorObj"> ##
-## ## <#/GAPDoc> ## -## Note that 'AsList' would not be suitable in the case of vector objects -## because its result would be immutable. -## -DeclareOperation( "Unpack", [ IsVecOrMatObj ] ); -#DeclareOperation( "Unpack", [ IsVectorObj ] ); -#DeclareOperation( "Unpack", [ IsMatrixOrMatrixObj ] ); +DeclareOperation( "[]", [ IsVectorObj, IsPosInt ] ); + +DeclareOperation( "[]:=", [ IsVectorObj, IsPosInt, IsObject ] ); + +DeclareOperation( "{}", [ IsVectorObj, IsList ] ); ############################################################################# ## -## <#GAPDoc Label="MatObj_ConcatenationOfVectors"> +## <#GAPDoc Label="MatObj_PositionNonZero"> ##Unpack -##-## +## Element Access and Assignment for Vector Objects +## +##+## +## ## -## A plain list ##-## Returns a new mutable plain list (see ) -## containing the entries of the vector object v or the matrix object -## M, respectively. -## In the case of a matrix object, -## the result is a plain list of plain lists. +## For a vector object v and a positive integer i that is +## not larger than the length of v +## (see ), +## v ##[ i] is the entry at position i. ## -## Changing the result does not change v or M, respectively. -## The entries themselves are not copied. +## If v is mutable, i is as above, and obj is an object +## from the base domain of v then +## v[ i]:= obj assigns obj to the +## i-th position of v. +## +## If list is a list of positive integers that are not larger than +## the length of v then +## v{ list} returns a new mutable vector object +## in the same representation as v +## (see ) +## that contains the list[ k ] -th entry of v at +## positionk . +## +## If the global optioncheck is set tofalse then +## +## need not perform consistency checks. +## +## Note that the sublist assignment operation +## is left out here since it tempts the programmer to use constructions like +##v{ [ 1 .. 3 ] }:= w{ [ 4 .. 6 ] } +## which produces an unnecessary intermediate object; +## one should use instead. +## +##v1 := Vector( Integers, [3,4,7,8] );; +## gap> v1[4]; +## 8 +## gap> v1[2] := 6;; Print( v1 ); +## NewVector(IsPlistVectorRep,Integers,[ 3, 6, 7, 8 ]) +## gap> Print( v1{[2..3]} ); +## NewVector(IsPlistVectorRep,Integers,[ 6, 7 ]) +## ]]> ##-## ## <#/GAPDoc> ## -DeclareGlobalFunction( "ConcatenationOfVectors" ); +DeclareOperation( "PositionNonZero", [ IsVectorObj ] ); ############################################################################# ## -## <#GAPDoc Label="MatObj_ExtractSubVector"> +## <#GAPDoc Label="MatObj_PositionLastNonZero"> ##ConcatenationOfVectors -##-## -## -## a vector object +#### +## An integer ##-## Returns a new mutable vector object in the representation of v1 -## or the first entry of the nonempty list vlist of vector objects, -## respectively, -## such that the entries are the concatenation of the given vector objects. +## Returns the index of the first entry in the vector object v +## that is not zero. +## If all entries are zero, +## the function returns ##Length(v) + 1 . ## -## (Note that -## is a function for which no methods can be installed.) +##v := Vector( Integers, [0,0,1,1,2,2,0,0,0] );; Unpack( v ); +## [ 0, 0, 1, 1, 2, 2, 0, 0, 0 ] +## gap> PositionNonZero( v ); +## 3 +## ]]> ##-## +## <#/GAPDoc> +## +DeclareOperation( "PositionLastNonZero", [ IsVectorObj ] ); + + +############################################################################# +## +#O ListOp(+## ## -## a vector object +##An integer +##+## Returns the index of the last entry in the vector object v +## that is not zero. +## If all entries are zero, the function returns +##0 . +## +##v := Vector( Integers, [0,0,1,1,2,2,0,0,0] );; Unpack( v ); +## [ 0, 0, 1, 1, 2, 2, 0, 0, 0 ] +## gap> PositionLastNonZero( v ); +## 6 +## ]]> +##[, ] ) +## +## <#GAPDoc Label="MatObj_ListOp"> +## +## ## <#/GAPDoc> ## -DeclareOperationKernel( "ExtractSubVector", - [ IsRowVectorOrVectorObj, IsList ], EXTRACT_SUB_VECTOR ); +DeclareOperation( "ListOp", [ IsVectorObj ] ); +DeclareOperation( "ListOp", [ IsVectorObj, IsFunction ] ); ############################################################################# @@ -443,7 +1114,6 @@ DeclareOperationKernel( "ExtractSubVector", ## Arithmetical operations for vector objects ## - ############################################################################# ## #O AddVector(## +## A plain list ##-## Returns a new mutable vector object of the same vector representation -## as v, containing the entries of v at the positions in -## the list l. +## Applies the function func to each entry of the vector object +## v and returns the results as a mutable plain list. +## This allows for calling +## on vector objects. ## -## This is the same as v ##{ l} , -## the name was introduced in analogy to -## , for which no equivalent syntax using -## curly brackets is available. +## If the argument func is not given, +## applies to all entries. +## +##v := Vector( Integers, [0,0,1,1,2,2,0,0,0] );; Unpack( v ); +## [ 0, 0, 1, 1, 2, 2, 0, 0, 0 ] +## gap> List( v, x -> x-1 ); +## [ -1, -1, 0, 0, 1, 1, -1, -1, -1 ] +## ]]> ##, [, [, , ]] ) @@ -475,6 +1145,17 @@ DeclareOperationKernel( "ExtractSubVector", ## This can be helpful if entries of src are known to be zero. ## ## If from is bigger than to, the operation does nothing. +## +## v1 := Vector( Integers, [0,1,2,4,8] );; Print( v1 ); +## NewVector(IsPlistVectorRep,Integers,[ 0, 1, 2, 4, 8 ]) +## gap> v2 := Vector( [1,0,1,0,1], v1 );; Print( v2 ); +## NewVector(IsPlistVectorRep,Integers,[ 1, 0, 1, 0, 1 ]) +## gap> AddVector( v1, v2 ); Unpack( v1 ); +## [ 1, 1, 3, 4, 9 ] +## gap> AddVector( v1, v2, -2 ); Unpack( v1 ); +## [ -1, 1, 1, 4, 7 ] +## ]]> ## ## ## <#/GAPDoc> @@ -530,6 +1211,11 @@ DeclareOperation( "AddVector", ## This can be helpful if entries of v are known to be zero. ## If from is bigger than to, the operation does nothing. ## +##v1 := Vector( Integers, [0,1,2,4,8] );; +## gap> MultVector( v1, 2 ); Unpack( v1 ); +## [ 0, 2, 4, 8, 16 ] +## ]]> ## ## ## <#/GAPDoc> @@ -544,7 +1230,6 @@ DeclareOperation( "MultVectorRight", DeclareOperation( "MultVectorRight", [ IsVectorObj and IsMutable, IsObject, IsInt, IsInt ] ); - # This is defined for two vectors of equal length, # it returns the standard scalar product. # (The documentation is in the section about arithm. operations.) @@ -553,97 +1238,70 @@ DeclareOperation( "ScalarProduct", [ IsVectorObj, IsVectorObj ] ); ############################################################################# ## -#O ZeroVector(, , ) -#O ZeroVector( , ) -#O ZeroVector( , ) -#O ZeroVector( , ) +## Operations for Vector Objects ## -## <#GAPDoc Label="VectorObj_ZeroVector"> + +############################################################################# +## +## <#GAPDoc Label="MatObj_ConcatenationOfVectors"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "ZeroVector", [ IsOperation, IsSemiring, IsInt ] ); -DeclareOperation( "ZeroVector", [ IsSemiring, IsInt ] ); -DeclareOperation( "ZeroVector", [ IsInt, IsVecOrMatObj ] ); -#DeclareOperation( "ZeroVector", [ IsInt, IsVectorObj ] ); -#DeclareOperation( "ZeroVector", [ IsInt, IsMatrixOrMatrixObj ] ); +DeclareGlobalFunction( "ConcatenationOfVectors" ); ############################################################################# ## -#O Vector(ZeroVector -##-## -## -## +## ConcatenationOfVectors +##+## ## ## a vector object +## ##-## For a filter filt, a semiring R and a nonnegative integer len, -## this operation returns a new vector object of length len over R -## in the representation filt containing only zeros. -## -## If only R and len are given, -## then &GAP; guesses a suitable representation. -## -## For a vector object v and a nonnegative integer len, -## this operation returns a new vector object of length len -## in the same representation as v containing only zeros. -## -## For a matrix object M and a nonnegative integer len, -## this operation returns a new zero vector object of length -## len in the representation given by the -## value -## of M, provided that such a representation exists. +## Returns a new mutable vector object in the representation of v1 +## or the first entry of the nonempty list vlist of vector objects, +## respectively, +## such that the entries are the concatenation of the given vector objects. ## -## If the -## value of the result implies then the result is -## mutable. +## (Note that +## is a function for which no methods can be installed.) ## -## Default methods for -## -## delegate to . +## ##v1 := Vector( Integers, [1,2,3] );; +## gap> v2 := Vector( Integers, [6,7,8,9] );; +## gap> Print( ConcatenationOfVectors( v1, v2 ) ); +## NewVector(IsPlistVectorRep,Integers,[ 1, 2, 3, 6, 7, 8, 9 ]) +## gap> Print( ConcatenationOfVectors( v2, [0,1] ) ); +## NewVector(IsPlistVectorRep,Integers,[ 6, 7, 8, 9, 0, 1 ]) +## gap> Print( ConcatenationOfVectors( [ v1, [0,0,0], v2 ] ) ); +## NewVector(IsPlistVectorRep,Integers,[ 1, 2, 3, 0, 0, 0, 6, 7, 8, 9 ]) +## ]]> ##, , ) -#O Vector(
, , ) -#O Vector( , ) -#O Vector(
, ) -#O Vector( ,
) -#O Vector( , ) -## -## <#GAPDoc Label="Vector"> -## -## ## <#/GAPDoc> @@ -1003,6 +1631,16 @@ DeclareOperation( "MutableCopyMatrix", [ IsMatrixOrMatrixObj ] ); ## ## If the global optionVector -##-## -## -## -## -## -## +## <#GAPDoc Label="MatObj_ExtractSubVector"> +## +## -## <#/GAPDoc> -## -DeclareOperation( "Vector", [ IsOperation, IsSemiring, IsList ] ); -DeclareOperation( "Vector", [ IsOperation, IsSemiring, IsVectorObj ] ); -DeclareOperation( "Vector", [ IsSemiring, IsList ] ); -DeclareOperation( "Vector", [ IsSemiring, IsVectorObj ] ); -DeclareOperation( "Vector", [ IsList, IsVectorObj ] ); -DeclareOperation( "Vector", [ IsVectorObj, IsVectorObj ] ); -DeclareOperation( "Vector", [ IsList ] ); - - -############################################################################# -## -#O NewVector(## ## a vector object +## ##-## If a filter filt is given as the first argument then -## a vector object is returned that has -## -## value filt, is defined over the base domain R, -## and has the entries given by the list list or the vector object -## v, respectively. +## Returns a new mutable vector object of the same vector representation +## as v, containing the entries of v at the positions in +## the list l. ## -## If a semiring R is given as the first argument then -## a vector object is returned whose -## -## value is guessed from R, again with base domain R -## and entries given by the last argument. +## This is the same as v -##{ l} , +## the name was introduced in analogy to +## , for which no equivalent syntax using +## curly brackets is available. +## +##v1 := Vector( Rationals, [-5..5] );; +## gap> v2 := ExtractSubVector( v1, [1,3,5,7,9,11] );; Print( v2 ); +## NewVector(IsPlistVectorRep,Rationals,[ -5, -3, -1, 1, 3, 5 ]) +## ]]> ## ## In the remaining cases with two arguments, ## the first argument is a list or a vector object @@ -653,17 +1311,24 @@ DeclareOperation( "ZeroVector", [ IsInt, IsVecOrMatObj ] ); ## are taken for the ## result. ## -## If only a list list is given then both the -## and the -## are guessed from -## this list. -## ## The variantVector( v1, v2) ## is supported also for the case that v2 is a row vector but not ## a vector object. ## In this situation, the result is a row vector that is equal to ## v1 and whose internal representation fits to that of v2. ## +## If only a list list is given then both the +## and the +## are guessed from +## this list. +## +## If a filter filt is given as the first argument then +## a vector object is returned that has +## +## value filt, is defined over the base domain R, +## and has the entries given by the list list or the vector object +## v, respectively. +## ## If the global optioncheck is set tofalse then ## ## need not perform consistency checks. @@ -679,261 +1344,215 @@ DeclareOperation( "ZeroVector", [ IsInt, IsVecOrMatObj ] ); ## Default methods for ## ## delegate to . -##, , ) -#O NewZeroVector(
, , ) -## -## <#GAPDoc Label="NewVector"> -## -## ## <#/GAPDoc> ## -DeclareTagBasedOperation( "NewVector", [ IsOperation, IsSemiring, IsList ] ); - -DeclareTagBasedOperation( "NewZeroVector", - [ IsOperation, IsSemiring, IsInt ] ); +DeclareOperationKernel( "ExtractSubVector", + [ IsRowVectorOrVectorObj, IsList ], EXTRACT_SUB_VECTOR ); ############################################################################# ## -#O NewMatrix(NewVector and NewZeroVector -##-## -## -## -## For a filter filt, a semiring R, and a list list -## of elements that belong to R, -## returns a vector object which has -## the -## filt, -## the R, -## and the entries in list. -## The list list is guaranteed not to be changed by this operation. -## -## If the global option ##check is set tofalse then -## need not perform consistency checks. -## -## Similarly, returns a vector object -## of length n which has filt and R as -## and -## values, -## and contains the zero of R in each position. ## -## The returned object is mutable if and only if filt implies -## . +##v1 := Vector( Integers, [3,4,7,8] );; Print( v1 ); +## NewVector(IsPlistVectorRep,Integers,[ 3, 4, 7, 8 ]) +## gap> v2 := Vector( Rationals, v1 );; Print( v2 ); +## NewVector(IsPlistVectorRep,Rationals,[ 3, 4, 7, 8 ]) +## gap> v3 := Vector( [ 11..13], v1) ;; Print( v3 ); +## NewVector(IsPlistVectorRep,Integers,[ 11, 12, 13 ]) +## gap> v0 := [6..9];; IsVector( v0 ); +## true +## gap> Print( Vector( v0, v1 ) ); +## NewVector(IsPlistVectorRep,Integers,[ 6, 7, 8, 9 ]) +## gap> v4 := Vector( [ 2, 5/2, 7/3, 3 ] );; Print( v4 ); +## NewVector(IsPlistVectorRep,Rationals,[ 2, 5/2, 7/3, 3 ]) +## gap> v5 := Vector( IsGF2VectorRep, GF(2), [ 0, 1, 2 ]*Z(2)^0 );; +## gap> Print( v5 ); +## [ 0*Z(2), Z(2)^0, 0*Z(2) ] +## gap> v6 := Vector( IsZmodnZVectorRep, ZmodnZ(8), v1 ); +## ##+## gap> BaseDomain( v6 ); +## (Integers mod 8) +## gap> v7 := Vector( IsZmodnZVectorRep, ZmodnZ(12), v0 ); +## +## ]]> , , , ) -#O NewZeroMatrix(
, , , ) -#O NewIdentityMatrix( , , ) +#O CopySubVector( , , , ) ## -## <#GAPDoc Label="NewMatrix"> +## <#GAPDoc Label="CopySubVector"> ## -## ## <#/GAPDoc> ## -DeclareTagBasedOperation( "NewMatrix", - [ IsOperation, IsSemiring, IsInt, IsList] ); - -DeclareTagBasedOperation( "NewZeroMatrix", - [ IsOperation, IsSemiring, IsInt, IsInt ] ); - -DeclareTagBasedOperation( "NewIdentityMatrix", - [ IsOperation, IsSemiring, IsInt ] ); +DeclareOperationKernel( "CopySubVector", + [ IsRowVectorOrVectorObj, IsRowVectorOrVectorObj and IsMutable, + IsList, IsList ], COPY_SUB_VECTOR ); ############################################################################# ## -#O ChangedBaseDomain(NewMatrix, NewZeroMatrix, NewIdentityMatrix -##-## -## +## +## +## nothing ## ##-## For a filter filt, a semiring R, -## a positive integer ncols, and a list list, -## returns a matrix object which has -## the -## filt, -## the R, -## n columns -## (see ), -## and the entries described by list, -## which can be either a plain list of vector objects of length ncols -## or a plain list of plain lists of length ncols -## or a plain list of length a multiple of ncols containing the -## entries in row major order. -## The list list is guaranteed not to be changed by this operation. +## For two row vectors or vector objects src and dst, +## such that dst is mutable, +## and two lists scols and dcols of positions, +## assigns the entries +## src ##{ scols} +## (see ) +## to the positions dcols in dst, +## but without creating an intermediate object and thus +## –at least in special cases– +## much more efficiently. ## -## The corresponding entries must be in or compatible with R. -## If list already contains vector objects, they are copied. +## For certain objects like compressed vectors this might be significantly +## more efficient if scols and dcols are ranges +## with increment 1. ## ## If the global optioncheck is set tofalse then -## need not perform consistency checks. -## -## Similarly, returns a zero matrix -## object with m rows and n columns -## which has filt and R as -## and -## values. -## -## Similarly, returns an identity -## matrix object with n rows and columns -## which has filt and R as -## and -## values, -## and contains the identity element of R in the diagonal -## and the zero of R in each off-diagonal position. +## need not perform consistency checks. ## -## The returned object is mutable if and only if filt implies -## . +##v1 := Vector( Integers, [ 2,3,5,6,8,9 ] );; +## gap> v2 := Vector( Integers, [ 9,8,6,5,3,2 ] );; +## gap> CopySubVector( v1, v2, [2..4], [3..5] ); Print( v2 ); +## NewVector(IsPlistVectorRep,Integers,[ 9, 8, 3, 5, 6, 2 ]) +## ]]> ##, ) -#O ChangedBaseDomain( , ) -## -## <#GAPDoc Label="ChangedBaseDomain"> -## -## -## <#/GAPDoc> -## -DeclareOperation( "ChangedBaseDomain", [ IsVecOrMatObj, IsSemiring ] ); -#DeclareOperation( "ChangedBaseDomain", [ IsVectorObj, IsSemiring ] ); -#DeclareOperation( "ChangedBaseDomain", [ IsMatrixOrMatrixObj, IsSemiring ] ); - - -############################################################################ -## -#O Randomize( [Rs, ]v ) -#O Randomize( [Rs, ]M ) -## -## <#GAPDoc Label="Randomize"> +## <#GAPDoc Label="MatObj_WeightOfVector"> ##ChangedBaseDomain -##-## -## -## -## For a vector object v (a matrix object M) -## and a semiring R, -## returns -## a new vector object (matrix object) -## with value R, -## value -## equal to that of v (M), -## and the same entries as v (M). -## -## The result is mutable if and only if v (M) is mutable. -## -## For example, one can create a vector defined over -##GF(4) -## from a vector defined overGF(2) with this operation. -##-## ## <#/GAPDoc> ## -DeclareOperation( "Randomize", [ IsVectorObj and IsMutable ] ); -DeclareOperation( "Randomize", [ IsRandomSource, IsVectorObj and IsMutable ] ); -DeclareOperation( "Randomize", [ IsMatrixOrMatrixObj and IsMutable ] ); -DeclareOperation( "Randomize", [ IsRandomSource, IsMatrixOrMatrixObj and IsMutable ] ); +DeclareOperation( "WeightOfVector", [ IsVectorObj ] ); ############################################################################# ## -#O CopySubVector(Randomize -##-## +## +## an integer ##-## Replaces every entry in the mutable vector object v -## or matrix object M, respectively, with -## a random one from the base domain of v or M, -## respectively, and returns the argument. +## returns the Hamming weight of the vector object v, +## i.e., the number of nonzero entries in v. ## -## If given, the random source Rs is used to compute the -## random elements. -## Note that in this case, -## a -## method must be available that takes a random source as its first -## argument and the base domain as its second argument. +## ##v1 := Vector( Integers, [2,3,5,6,8,9] );; +## gap> v2 := Vector( Integers, [2,3,0,0,8,9] );; +## gap> v3 := ZeroVector( Integers, 6 );; +## gap> [ WeightOfVector(v1), WeightOfVector(v2), WeightOfVector(v3) ]; +## [ 6, 4, 0 ] +## ]]> ##, , , ) -## -## <#GAPDoc Label="CopySubVector"> +## <#GAPDoc Label="MatObj_DistanceOfVectors"> ## -## ## <#/GAPDoc> ## -DeclareOperationKernel( "CopySubVector", - [ IsRowVectorOrVectorObj, IsRowVectorOrVectorObj and IsMutable, - IsList, IsList ], COPY_SUB_VECTOR ); +DeclareOperation( "DistanceOfVectors", [ IsVectorObj, IsVectorObj ] ); ############################################################################# ## -## <#GAPDoc Label="MatObj_WeightOfVector"> +#O MatElm(-## -## nothing -## +##+## an integer ##-## For two row vectors or vector objects src and dst, -## such that dst is mutable, -## and two lists scols and dcols of positions, -## assigns the entries -## src ##{ scols} -## (see ) -## to the positions dcols in dst, -## but without creating an intermediate object and thus -## –at least in special cases– -## much more efficiently. -## -## For certain objects like compressed vectors this might be significantly -## more efficient if scols and dcols are ranges -## with increment 1. +## returns the Hamming distance of the vector objects v1 and +## v2, i.e., the number of entries in which the vectors differ. +## The vectors must have equal length. ## -## If the global optioncheck is set tofalse then -## need not perform consistency checks. +##v1 := Vector( Integers, [2,3,5,6,8,9] );; +## gap> v2 := Vector( Integers, [2,3,0,0,8,9] );; +## gap> v3 := ZeroVector( Integers, 6 );; +## gap> [ DistanceOfVectors( v1, v2 ), DistanceOfVectors( v2, v3 ) ]; +## [ 2, 4 ] +## ]]> ##, ,
) . . . . . . select an entry from a matrix +#O [ ,
] . . . . . . . . . . select an entry from a matrix +## +## <#GAPDoc Label="MatObj_MatElm"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "WeightOfVector", [ IsVectorObj ] ); +DeclareOperationKernel( "[,]", [ IsMatrixOrMatrixObj, IS_INT, IS_INT ], ELM_MAT ); +DeclareSynonym( "MatElm", ELM_MAT ); ############################################################################# ## -## <#GAPDoc Label="MatObj_DistanceOfVectors"> +#O SetMatElm(-## an integer +##+## +## an entry of the matrix object +## ##-## returns the Hamming weight of the vector object v, -## i.e., the number of nonzero entries in v. +## For a matrix object M, this operation returns the entry in +## row row and column col. +## +## Also the syntax M ##[ row, col] +## is supported. +## +## Note that this isnot equivalent to +## M[ row][ col] , +## which would first try to access M[ row] , +## and this is in general not possible. +## +##m1 := Matrix( Rationals, [ [3,4,5], [6,7,8] ] );; +## gap> [ MatElm( m1, 2, 2 ), m1[2,3] ]; +## [ 7, 8 ] +## ]]> ##, ,
, ) . . . . set an entry in a matrix +#O [ ,
]:= . . . . . . . . . set an entry in a matrix +## +## <#GAPDoc Label="MatObj_SetMatElm"> ## -## ## <#/GAPDoc> ## -DeclareOperation( "DistanceOfVectors", [ IsVectorObj, IsVectorObj ] ); +DeclareOperationKernel( "[,]:=", [ IsMatrixOrMatrixObj, IsInt, IsInt, IsObject ], + ASS_MAT ); +#T We want to require also 'IsMutable' for the first argument, +#T but some package may have installed methods without this requirement. +#T Note that if we declare the operation twice, once with requirement +#T 'IsMutable' and once without, each method installation will show +#T a complaint that it matches more than one declaration. +DeclareSynonym( "SetMatElm", ASS_MAT ); ############################################################################# @@ -953,6 +1572,15 @@ DeclareOperation( "DistanceOfVectors", [ IsVectorObj, IsVectorObj ] ); ## If the ## value of the result implies then the result is ## fully mutable. +## +##-## an integer +##+## +## nothing +## ##-## returns the Hamming distance of the vector objects v1 and -## v2, i.e., the number of entries in which the vectors differ. -## The vectors must have equal length. +## For a mutable matrix object M, this operation assigns the object +## obj to the position in row row and column col, +## provided that obj is compatible with the +## value of M. +## +## Also the syntax +## M ##[ row, col]:= obj +## is supported. +## +## Note that this isnot equivalent to +## M[ row][ col]:= obj, +## which would first try to access M[ row] , +## and this is in general not possible. +## +## If the global optioncheck is set tofalse then +## need not perform consistency checks. +## +##m1 := Matrix( Rationals, [ [3,4,5], [6,7,8] ] );; +## gap> SetMatElm( m1, 1, 3, 0 ); +## gap> m1[2,1] := 0;; Unpack( m1 ); +## [ [ 3, 4, 0 ], [ 0, 7, 8 ] ] +## ]]> ##m1 := Matrix( Integers, [1..20], 5 );; Unpack( m1 ); +## [ [ 1 .. 5 ], [ 6 .. 10 ], [ 11 .. 15 ], [ 16 .. 20 ] ] +## gap> m2 := ExtractSubMatrix( m1, [2,3], [2..4] );; Unpack( m2 ); +## [ [ 7 .. 9 ], [ 12 .. 14 ] ] +## gap> m3 := ExtractSubMatrix( m1, [4,1], [5,1] );; Unpack( m3 ); +## [ [ 20, 16 ], [ 5, 1 ] ] +## ]]> ## ##check is set tofalse then ## need not perform consistency checks. +## +##m1 := Matrix( Integers, [1..20], 5 );; Unpack( m1 ); +## [ [ 1 .. 5 ], [ 6 .. 10 ], [ 11 .. 15 ], [ 16 .. 20 ] ] +## gap> m0 := ZeroMatrix( Integers, 2, 9 );; +## gap> CopySubMatrix( m1, m0, [2,3], [1,2], [2..4], [3..5] ); Unpack( m0 ); +## [ [ 0, 0, 7, 8, 9, 0, 0, 0, 0 ], [ 0, 0, 12, 13, 14, 0, 0, 0, 0 ] ] +## gap> CopySubMatrix( m1, m0, [4,1], [1,2], [5,1], [7,8] ); Unpack( m0 ); +## [ [ 0, 0, 7, 8, 9, 0, 20, 16, 0 ], [ 0, 0, 12, 13, 14, 0, 5, 1, 0 ] ] +## ]]> ## ## ## <#/GAPDoc> @@ -1014,172 +1652,79 @@ DeclareOperationKernel( "CopySubMatrix", #T the pre-existing operation declaration for compatibility with packages. -############################################################################# +############################################################################ ## -#O MatElm(, ,
) . . . . . . select an entry from a matrix -#O [ ,
] . . . . . . . . . . select an entry from a matrix +#A CompatibleVector( ) ## -## <#GAPDoc Label="MatObj_MatElm"> +## <#GAPDoc Label="CompatibleVector"> ## -## ## <#/GAPDoc> ## -DeclareOperationKernel( "[,]", [ IsMatrixOrMatrixObj, IS_INT, IS_INT ], ELM_MAT ); -DeclareSynonym( "MatElm", ELM_MAT ); +DeclareOperation( "CompatibleVector", [ IsMatrixOrMatrixObj ] ); -############################################################################# +############################################################################ ## -#O SetMatElm(+## ## -## an entry of the matrix object +##a vector object ## ##-## For a matrix object M, this operation returns the entry in -## row row and column col. +## Called with a matrix object M with ##m rows, +## this operation returns a mutable zero vector objectv of length +##m and in the representation given by the +## value +## of M (provided that such a representation exists). ## -## Also the syntax M[ row, col] -## is supported. +## The idea is that there should be an efficient way to +## form the productv M. ## -## Note that this isnot equivalent to -## M[ row][ col] , -## which would first try to access M[ row] , -## and this is in general not possible. +##m1 := Matrix( Integers, [ [2,3], [5,6], [8,9] ] );; +## gap> v1 := CompatibleVector( m1 );; Unpack( v1 ); +## [ 0, 0, 0 ] +## gap> v1[1] := -1;; v1[3] := -1;; Unpack( v1 ); +## [ -1, 0, -1 ] +## gap> Print( v1 * m1 ); +## NewVector(IsPlistVectorRep,Integers,[ -10, -12 ]) +## ]]> ##, ,
, ) . . . . set an entry in a matrix -#O [ ,
]:= . . . . . . . . . set an entry in a matrix +#A RowsOfMatrix( ) ## -## <#GAPDoc Label="MatObj_SetMatElm"> +## <#GAPDoc Label="RowsOfMatrix"> ## -## -## <#/GAPDoc> -## -DeclareOperationKernel( "[,]:=", [ IsMatrixOrMatrixObj, IsInt, IsInt, IsObject ], - ASS_MAT ); -#T We want to require also 'IsMutable' for the first argument, -#T but some package may have installed methods without this requirement. -#T Note that if we declare the operation twice, once with requirement -#T 'IsMutable' and once without, each method installation will show -#T a complaint that it matches more than one declaration. -DeclareSynonym( "SetMatElm", ASS_MAT ); - - -############################################################################# -## -#O ZeroMatrix(-## -## nothing -## -##-## For a mutable matrix object M, this operation assigns the object -## obj to the position in row row and column col, -## provided that obj is compatible with the -## value of M. -## -## Also the syntax -## M -##[ row, col]:= obj -## is supported. -## -## Note that this isnot equivalent to -## M[ row][ col]:= obj, -## which would first try to access M[ row] , -## and this is in general not possible. -## -## If the global optioncheck is set tofalse then -## need not perform consistency checks. -##, , ) -#O ZeroMatrix( , , ) -#O ZeroMatrix( , , , ) +## ## -## <#GAPDoc Label="MatObj_ZeroMatrix"> -## -## ## <#/GAPDoc> ## -DeclareOperation( "ZeroMatrix", [ IsInt, IsInt, IsMatrixOrMatrixObj ] ); -DeclareOperation( "ZeroMatrix", [ IsSemiring, IsInt, IsInt ] ); -DeclareOperation( "ZeroMatrix", [ IsOperation, IsSemiring, IsInt, IsInt ] ); - - -############################################################################# -## -#O IdentityMatrix(ZeroMatrix -##-## -## +## a plain list ## -##a matrix object ##-## For a matrix object M and two nonnegative integers m -## and n, this operation returns a new matrix object -## with m rows and n columns -## in the same representation and over the same base domain as M -## containing only zeros. -## -## If a semiring R and two nonnegative integers m and -## n are given, -## the representation of the result is guessed from R. -## -## If a filter filt and a semiring R are given as the first -## and second argument, they are taken as the values of -## and -## of the result. -## -## If the -## value of the result implies then the result is -## fully mutable. +## Called with a matrix object M, this operation +## returns a plain list of objects in the representation given by the +## value +## of M (provided that such a representation exists), +## where the ##i -th entry describes thei -th row of the input. ## -## Default methods for -## -## delegate to . +##m1 := Matrix( Integers, [ [3,4,5], [7,8,9] ] );; +## gap> Print( RowsOfMatrix( m1 ) ); +## [ NewVector(IsPlistVectorRep,Integers,[ 3, 4, 5 ]), +## NewVector(IsPlistVectorRep,Integers,[ 7, 8, 9 ]) ] +## ]]> ##, ) -#O IdentityMatrix( , ) -#O IdentityMatrix( , , ) -## -## <#GAPDoc Label="MatObj_IdentityMatrix"> -## -## -## <#/GAPDoc> +## We assume that the matrix knows how to create suitable vector objects; +## entering a template vector as the second argument is not an option +## in this situation. ## -DeclareOperation( "IdentityMatrix", [ IsInt, IsMatrixOrMatrixObj ] ); -DeclareOperation( "IdentityMatrix", [ IsSemiring, IsInt ] ); -DeclareOperation( "IdentityMatrix", [ IsOperation, IsSemiring, IsInt ] ); +DeclareAttribute( "RowsOfMatrix", IsMatrixOrMatrixObj ); ############################################################################# @@ -1247,17 +1792,17 @@ DeclareOperation( "CompanionMatrix", ############################################################################# ## -#O Matrix(IdentityMatrix -##-## -## +## This function is used for creating an isomorphic permutation group +## of a matrix group that consists of matrix objects. +## ## -## a matrix object -##-## For a matrix object M and a nonnegative integer n, -## this operation returns a new identity matrix object -## with n rows and columns -## in the same representation and over the same base domain as M. -## -## If a semiring R and a nonnegative integer n is given, -## the representation of the result is guessed from R. -## -## If a filter filt and a semiring R are given as the first -## and second argument, they are taken as the values of -## and -## of the result. -## -## If the -## value of the result implies then the result is -## fully mutable. -## -## Default methods for -## -## delegate to . -## -##, , ,
) -#O Matrix( , , ) -#O Matrix(
, , ) -#O Matrix( , ,
) #O Matrix( , ) +#O Matrix(
, ,
) #O Matrix( , ) -#O Matrix( ,
, ) #O Matrix( ,
) +#O Matrix( ,
, ) #O Matrix( , ) -#O Matrix( ,
) #O Matrix( ) +#O Matrix(
,
) +#O Matrix( , , ) +#O Matrix(
, , ,
) +#O Matrix( , , ) ## ## <#GAPDoc Label="MatObj_Matrix"> ## @@ -1270,8 +1815,8 @@ DeclareOperation( "CompanionMatrix", ## ## a matrix object ##-## If a filter