Goto Chapter: Top 1 2 3 4 5 6 A B C D E F Bib Ind

### C Logic Subpackages

#### C.4 COLEM: Clever Operations for Lazy Evaluated Matrices

Most of the matrix tool operations listed in Appendix B.1 which return a new matrix are lazy evaluated. The value of a homalg matrix is stored in the attribute Eval. Below is the list of the installed methods for the attribute Eval.

##### C.4-1 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix C was created using HomalgInitialMatrix (5.2-1) then the filter IsInitialMatrix for C is set to true and the homalgTable function (--> InitialMatrix (B.1-1)) will be used to set the attribute Eval and resets the filter IsInitialMatrix.

InstallMethod( Eval,
"for homalg matrices (IsInitialMatrix)",
[ IsHomalgMatrix and IsInitialMatrix and
HasNumberRows and HasNumberColumns ],

function( C )
local R, RP, z, zz;

R := HomalgRing( C );

RP := homalgTable( R );

if IsBound( RP!.InitialMatrix ) then
ResetFilterObj( C, IsInitialMatrix );
SetEval( C, RP!.InitialMatrix( C ) );
return Eval( C );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called InitialMatrix in the ",
"homalgTable to evaluate a non-internal initial matrix\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

z := Zero( HomalgRing( C ) );

ResetFilterObj( C, IsInitialMatrix );

zz := ListWithIdenticalEntries( NumberColumns( C ), z );

SetEval( C, homalgInternalMatrixHull( List( [ 1 .. NumberRows( C ) ], i -> ShallowCopy( zz ) ) ) );

return Eval( C );

end );


##### C.4-2 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix C was created using HomalgInitialIdentityMatrix (5.2-2) then the filter IsInitialIdentityMatrix for C is set to true and the homalgTable function (--> InitialIdentityMatrix (B.1-2)) will be used to set the attribute Eval and resets the filter IsInitialIdentityMatrix.

InstallMethod( Eval,
"for homalg matrices (IsInitialIdentityMatrix)",
[ IsHomalgMatrix and IsInitialIdentityMatrix and
HasNumberRows and HasNumberColumns ],

function( C )
local R, RP, o, z, zz, id;

R := HomalgRing( C );

RP := homalgTable( R );

if IsBound( RP!.InitialIdentityMatrix ) then
ResetFilterObj( C, IsInitialIdentityMatrix );
SetEval( C, RP!.InitialIdentityMatrix( C ) );
return Eval( C );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called InitialIdentityMatrix in the ",
"homalgTable to evaluate a non-internal initial identity matrix\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

z := Zero( HomalgRing( C ) );
o := One( HomalgRing( C ) );

ResetFilterObj( C, IsInitialIdentityMatrix );

zz := ListWithIdenticalEntries( NumberColumns( C ), z );

id := List( [ 1 .. NumberRows( C ) ],
function(i)
local z;
z := ShallowCopy( zz ); z[i] := o; return z;
end );

SetEval( C, homalgInternalMatrixHull( id ) );

return Eval( C );

end );


##### C.4-3 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix C was created using HomalgZeroMatrix (5.2-3) then the filter IsZeroMatrix for C is set to true and the homalgTable function (--> ZeroMatrix (B.1-3)) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (IsZero)",
[ IsHomalgMatrix and IsZero and HasNumberRows and HasNumberColumns ], 40,

function( C )
local R, RP, z;

R := HomalgRing( C );

RP := homalgTable( R );

if ( NumberRows( C ) = 0 or NumberColumns( C ) = 0 ) and
not ( IsBound( R!.SafeToEvaluateEmptyMatrices ) and
R!.SafeToEvaluateEmptyMatrices = true ) then
Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
"an empty matrix is about to get evaluated!",
"\033[0m" );
fi;

if IsBound( RP!.ZeroMatrix ) then
return RP!.ZeroMatrix( C );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called ZeroMatrix ",
"homalgTable to evaluate a non-internal zero matrix\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

z := Zero( HomalgRing( C ) );

## copying the rows saves memory;
## we assume that the entries are never modified!!!
return homalgInternalMatrixHull(
ListWithIdenticalEntries( NumberRows( C ),
ListWithIdenticalEntries( NumberColumns( C ), z ) ) );

end );


##### C.4-4 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix C was created using HomalgIdentityMatrix (5.2-4) then the filter IsOne for C is set to true and the homalgTable function (--> IdentityMatrix (B.1-4)) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (IsOne)",
[ IsHomalgMatrix and IsOne and HasNumberRows and HasNumberColumns ], 10,

function( C )
local R, id, RP, o, z, zz;

R := HomalgRing( C );

if IsBound( R!.IdentityMatrices ) then
id := ElmWPObj( R!.IdentityMatrices!.weak_pointers, NumberColumns( C ) );
if id <> fail then
R!.IdentityMatrices!.cache_hits := R!.IdentityMatrices!.cache_hits + 1;
return id;
fi;
## we do not count cache_misses as it is equivalent to counter
fi;

RP := homalgTable( R );

if IsBound( RP!.IdentityMatrix ) then
id := RP!.IdentityMatrix( C );
SetElmWPObj( R!.IdentityMatrices!.weak_pointers, NumberColumns( C ), id );
R!.IdentityMatrices!.counter := R!.IdentityMatrices!.counter + 1;
return id;
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called IdentityMatrix ",
"homalgTable to evaluate a non-internal identity matrix\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

z := Zero( HomalgRing( C ) );
o := One( HomalgRing( C ) );

zz := ListWithIdenticalEntries( NumberColumns( C ), z );

id := List( [ 1 .. NumberRows( C ) ],
function(i)
local z;
z := ShallowCopy( zz ); z[i] := o; return z;
end );

id := homalgInternalMatrixHull( id );

SetElmWPObj( R!.IdentityMatrices!.weak_pointers, NumberColumns( C ), id );

return id;

end );


##### C.4-5 Eval
 ‣ Eval( LI ) ( method )

Returns: see below

In case the matrix LI was created using LeftInverseLazy (5.5-4) then the filter HasEvalLeftInverse for LI is set to true and the method listed below will be used to set the attribute Eval. (--> LeftInverse (5.5-2))

InstallMethod( Eval,
"for homalg matrices",
[ IsHomalgMatrix and HasEvalLeftInverse ],

function( LI )
local left_inv;

left_inv := LeftInverse( EvalLeftInverse( LI ) );

if IsBool( left_inv ) then
return false;
fi;

return Eval( left_inv );

end );


##### C.4-6 Eval
 ‣ Eval( RI ) ( method )

Returns: see below

In case the matrix RI was created using RightInverseLazy (5.5-5) then the filter HasEvalRightInverse for RI is set to true and the method listed below will be used to set the attribute Eval. (--> RightInverse (5.5-3))

InstallMethod( Eval,
"for homalg matrices",
[ IsHomalgMatrix and HasEvalRightInverse ],

function( RI )
local right_inv;

right_inv := RightInverse( EvalRightInverse( RI ) );

if IsBool( right_inv ) then
return false;
fi;

return Eval( right_inv );

end );


##### C.4-7 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using Involution (5.5-6) then the filter HasEvalInvolution for C is set to true and the homalgTable function Involution (B.1-5) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalInvolution)",
[ IsHomalgMatrix and HasEvalInvolution ],

function( C )
local R, RP, M;

R := HomalgRing( C );

RP := homalgTable( R );

M :=  EvalInvolution( C );

if IsBound(RP!.Involution) then
return RP!.Involution( M );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called Involution ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return homalgInternalMatrixHull( TransposedMat( Eval( M )!.matrix ) );

end );


##### C.4-8 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using TransposedMatrix (5.5-7) then the filter HasEvalTransposedMatrix for C is set to true and the homalgTable function TransposedMatrix (B.1-6) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalTransposedMatrix)",
[ IsHomalgMatrix and HasEvalTransposedMatrix ],

function( C )
local R, RP, M;

R := HomalgRing( C );

RP := homalgTable( R );

M :=  EvalTransposedMatrix( C );

if IsBound(RP!.TransposedMatrix) then
return RP!.TransposedMatrix( M );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called TransposedMatrix ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return homalgInternalMatrixHull( TransposedMat( Eval( M )!.matrix ) );

end );


##### C.4-9 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using CoercedMatrix (5.2-12) then the filter HasEvalCoercedMatrix for C is set to true and the Eval value of a copy of EvalCoercedMatrix(C) in HomalgRing(C) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalCoercedMatrix)",
[ IsHomalgMatrix and HasEvalCoercedMatrix ],

function( C )
local R, RP, m;

R := HomalgRing( C );

RP := homalgTable( R );

m := EvalCoercedMatrix( C );

# delegate to the non-lazy coercening
return Eval( R * m );

end );


##### C.4-10 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using CertainRows (5.5-8) then the filter HasEvalCertainRows for C is set to true and the homalgTable function CertainRows (B.1-7) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalCertainRows)",
[ IsHomalgMatrix and HasEvalCertainRows ],

function( C )
local R, RP, e, M, plist;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalCertainRows( C );

M := e[1];
plist := e[2];

ResetFilterObj( C, HasEvalCertainRows );

## delete the component which was left over by GAP
Unbind( C!.EvalCertainRows );

if IsBound(RP!.CertainRows) then
return RP!.CertainRows( M, plist );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called CertainRows ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return homalgInternalMatrixHull( Eval( M )!.matrix{ plist } );

end );


##### C.4-11 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using CertainColumns (5.5-9) then the filter HasEvalCertainColumns for C is set to true and the homalgTable function CertainColumns (B.1-8) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalCertainColumns)",
[ IsHomalgMatrix and HasEvalCertainColumns ],

function( C )
local R, RP, e, M, plist;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalCertainColumns( C );

M := e[1];
plist := e[2];

ResetFilterObj( C, HasEvalCertainColumns );

## delete the component which was left over by GAP
Unbind( C!.EvalCertainColumns );

if IsBound(RP!.CertainColumns) then
return RP!.CertainColumns( M, plist );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called CertainColumns ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return homalgInternalMatrixHull(
Eval( M )!.matrix{[ 1 .. NumberRows( M ) ]}{plist} );

end );


##### C.4-12 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using UnionOfRows (5.5-10) then the filter HasEvalUnionOfRows for C is set to true and the homalgTable function UnionOfRows (B.1-9) or the homalgTable function UnionOfRowsPair (B.1-10) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalUnionOfRows)",
[ IsHomalgMatrix and HasEvalUnionOfRows ],

function( C )
local R, RP, e, i, combine;

R := HomalgRing( C );

RP := homalgTable( R );

# Make it mutable
e := ShallowCopy( EvalUnionOfRows( C ) );

# In case of nested UnionOfRows, we try to avoid
# recursion, since the gap stack is rather small
i := 1;
while i <= Length( e ) do

if HasPreEval( e[i] ) and not HasEval( e[i] ) then

e[i] := PreEval( e[i] );

elif HasEvalUnionOfRows( e[i] ) and not HasEval( e[i] ) then

e := Concatenation( e{[ 1 .. (i-1) ]}, EvalUnionOfRows( e[i] ), e{[ (i+1) .. Length( e ) ]}  );

else

i := i + 1;

fi;

od;

# Combine zero matrices
i := 1;
while i + 1 <= Length( e ) do

if HasIsZero( e[i] ) and IsZero( e[i] ) and HasIsZero( e[i+1] ) and IsZero( e[i+1] ) then

e[i] := HomalgZeroMatrix( NumberRows( e[i] ) + NumberRows( e[i+1] ), NumberColumns( e[i] ), HomalgRing( e[i] ) );

Remove( e, i + 1 );

else

i := i + 1;

fi;

od;

# After combining zero matrices only a single one might be left
if Length( e ) = 1 then

return e[1];

fi;

# Use RP!.UnionOfRows if available
if IsBound(RP!.UnionOfRows) then

return RP!.UnionOfRows( e );

fi;

# Fall back to RP!.UnionOfRowsPair or manual fallback for internal matrices
# Combine the matrices
# Use a balanced binary tree to keep the sizes small (heuristically)
# to avoid a huge memory footprint

if not IsBound(RP!.UnionOfRowsPair) and not IsHomalgInternalMatrixRep( C ) then
Error( "could neither find a procedure called UnionOfRows ",
"nor a procedure called UnionOfRowsPair ",
"in the homalgTable of the non-internal ring\n" );
fi;

combine := function( A, B )
local result, U;

if IsBound(RP!.UnionOfRowsPair) then

result := RP!.UnionOfRowsPair( A, B );

else

#=====# can only work for homalg internal matrices #=====#

U := ShallowCopy( Eval( A )!.matrix );

U{ [ NumberRows( A ) + 1 .. NumberRows( A ) + NumberRows( B ) ] } := Eval( B )!.matrix;

result := homalgInternalMatrixHull( U );

fi;

return HomalgMatrixWithAttributes( [
Eval, result,
EvalUnionOfRows, [ A, B ],
NumberRows, NumberRows( A ) + NumberRows( B ),
NumberColumns, NumberColumns( A ),
], R );

end;

while Length( e ) > 1 do

for i in [ 1 .. Int( Length( e ) / 2 ) ] do

e[ 2 * i - 1 ] := combine( e[ 2 * i - 1 ], e[ 2 * i ] );
Unbind( e[ 2 * i ] );

od;

e := Compacted( e );

od;

return Eval( e[1] );

end );


##### C.4-13 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using UnionOfColumns (5.5-11) then the filter HasEvalUnionOfColumns for C is set to true and the homalgTable function UnionOfColumns (B.1-11) or the homalgTable function UnionOfColumnsPair (B.1-12) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalUnionOfColumns)",
[ IsHomalgMatrix and HasEvalUnionOfColumns ],

function( C )
local R, RP, e, i, combine;

R := HomalgRing( C );

RP := homalgTable( R );

# Make it mutable
e := ShallowCopy( EvalUnionOfColumns( C ) );

# In case of nested UnionOfColumns, we try to avoid
# recursion, since the gap stack is rather small
i := 1;
while i <= Length( e ) do

if HasPreEval( e[i] ) and not HasEval( e[i] ) then

e[i] := PreEval( e[i] );

elif HasEvalUnionOfColumns( e[i] ) and not HasEval( e[i] ) then

e := Concatenation( e{[ 1 .. (i-1) ]}, EvalUnionOfColumns( e[i] ), e{[ (i+1) .. Length( e ) ]}  );

else

i := i + 1;

fi;

od;

# Combine zero matrices
i := 1;
while i + 1 <= Length( e ) do

if HasIsZero( e[i] ) and IsZero( e[i] ) and HasIsZero( e[i+1] ) and IsZero( e[i+1] ) then

e[i] := HomalgZeroMatrix( NumberRows( e[i] ), NumberColumns( e[i] ) + NumberColumns( e[i+1] ), HomalgRing( e[i] ) );

Remove( e, i + 1 );

else

i := i + 1;

fi;

od;

# After combining zero matrices only a single one might be left
if Length( e ) = 1 then

return e[1];

fi;

# Use RP!.UnionOfColumns if available
if IsBound(RP!.UnionOfColumns) then

return RP!.UnionOfColumns( e );

fi;

# Fall back to RP!.UnionOfColumnsPair or manual fallback for internal matrices
# Combine the matrices
# Use a balanced binary tree to keep the sizes small (heuristically)
# to avoid a huge memory footprint

if not IsBound(RP!.UnionOfColumnsPair) and not IsHomalgInternalMatrixRep( C ) then
Error( "could neither find a procedure called UnionOfColumns ",
"nor a procedure called UnionOfColumnsPair ",
"in the homalgTable of the non-internal ring\n" );
fi;

combine := function( A, B )
local result, U;

if IsBound(RP!.UnionOfColumnsPair) then

result := RP!.UnionOfColumnsPair( A, B );

else

#=====# can only work for homalg internal matrices #=====#

U := List( Eval( A )!.matrix, ShallowCopy );

U{ [ 1 .. NumberRows( A ) ] }
{ [ NumberColumns( A ) + 1 .. NumberColumns( A ) + NumberColumns( B ) ] }
:= Eval( B )!.matrix;

result := homalgInternalMatrixHull( U );

fi;

return HomalgMatrixWithAttributes( [
Eval, result,
EvalUnionOfColumns, [ A, B ],
NumberRows, NumberRows( A ),
NumberColumns, NumberColumns( A ) + NumberColumns( B )
], R );

end;

while Length( e ) > 1 do

for i in [ 1 .. Int( Length( e ) / 2 ) ] do

e[ 2 * i - 1 ] := combine( e[ 2 * i - 1 ], e[ 2 * i ] );
Unbind( e[ 2 * i ] );

od;

e := Compacted( e );

od;

return Eval( e[1] );

end );


##### C.4-14 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using DiagMat (5.5-16) then the filter HasEvalDiagMat for C is set to true and the homalgTable function DiagMat (B.1-13) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalDiagMat)",
[ IsHomalgMatrix and HasEvalDiagMat ],

function( C )
local R, RP, e, l, z, m, n, diag, mat;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalDiagMat( C );

if IsBound(RP!.DiagMat) then
return RP!.DiagMat( e );
fi;

l := Length( e );

if not IsHomalgInternalMatrixRep( C ) then
return UnionOfRows(
List( [ 1 .. l ],
i -> UnionOfColumns(
List( [ 1 .. l ],
function( j )
if i = j then
return e[i];
fi;
return HomalgZeroMatrix( NumberRows( e[i] ), NumberColumns( e[j] ), R );
end )
)
)
);
fi;

#=====# can only work for homalg internal matrices #=====#

z := Zero( R );

m := Sum( List( e, NumberRows ) );
n := Sum( List( e, NumberColumns ) );

diag := List( [ 1 .. m ], a -> List( [ 1 .. n ], b -> z ) );

m := 0;
n := 0;

for mat in e do
diag{ [ m + 1 .. m + NumberRows( mat ) ] }{ [ n + 1 .. n + NumberColumns( mat ) ] }
:= Eval( mat )!.matrix;

m := m + NumberRows( mat );
n := n + NumberColumns( mat );
od;

return homalgInternalMatrixHull( diag );

end );


##### C.4-15 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using KroneckerMat (5.5-17) then the filter HasEvalKroneckerMat for C is set to true and the homalgTable function KroneckerMat (B.1-14) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalKroneckerMat)",
[ IsHomalgMatrix and HasEvalKroneckerMat ],

function( C )
local R, RP, A, B;

R := HomalgRing( C );

if ( HasIsCommutative( R ) and not IsCommutative( R ) ) and
( HasIsSuperCommutative( R ) and not IsSuperCommutative( R ) ) then
Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
"the Kronecker product is only defined for (super) commutative rings!",
"\033[0m" );
fi;

RP := homalgTable( R );

A :=  EvalKroneckerMat( C )[1];
B :=  EvalKroneckerMat( C )[2];

if IsBound(RP!.KroneckerMat) then
return RP!.KroneckerMat( A, B );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called KroneckerMat ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return homalgInternalMatrixHull(
KroneckerProduct( Eval( A )!.matrix, Eval( B )!.matrix ) );
## this was easy, thanks GAP :)

end );


##### C.4-16 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using DualKroneckerMat (5.5-18) then the filter HasEvalDualKroneckerMat for C is set to true and the homalgTable function DualKroneckerMat (B.1-15) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalDualKroneckerMat)",
[ IsHomalgMatrix and HasEvalDualKroneckerMat ],

function( C )
local R, RP, A, B;

R := HomalgRing( C );

if ( HasIsCommutative( R ) and not IsCommutative( R ) ) and
( HasIsSuperCommutative( R ) and not IsSuperCommutative( R ) ) then
Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
"the dual Kronecker product is only defined for (super) commutative rings!",
"\033[0m" );
fi;

RP := homalgTable( R );

A :=  EvalDualKroneckerMat( C )[1];
B :=  EvalDualKroneckerMat( C )[2];

# work around errors in Singular when taking the opposite ring of a ring with ordering lp
# https://github.com/Singular/Singular/issues/1011
# fixed in version 4.2.0
if IsBound(RP!.DualKroneckerMat) and not (
IsBound( R!.ring ) and
IsBound( R!.ring!.stream ) and
IsBound( R!.ring!.stream.cas ) and R!.ring!.stream.cas = "singular" and
( not IsBound( R!.ring!.stream.version ) or R!.ring!.stream.version < 4200 ) and
IsBound( R!.order ) and IsString( R!.order ) and StartsWith( R!.order, "lex" )
) then

return RP!.DualKroneckerMat( A, B );

fi;

if HasIsCommutative( R ) and IsCommutative( R ) then

return Eval( KroneckerMat( B, A ) );

else

return Eval(
TransposedMatrix( Involution(
KroneckerMat( TransposedMatrix( Involution( B ) ), TransposedMatrix( Involution( A ) ) )
) )
);

fi;

end );


##### C.4-17 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using \* (5.5-19) then the filter HasEvalMulMat for C is set to true and the homalgTable function MulMat (B.1-16) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalMulMat)",
[ IsHomalgMatrix and HasEvalMulMat ],

function( C )
local R, RP, e, a, A;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalMulMat( C );

a := e[1];
A := e[2];

if IsBound(RP!.MulMat) then
return RP!.MulMat( a, A );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called MulMat ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return a * Eval( A );

end );

InstallMethod( Eval,
"for homalg matrices (HasEvalMulMatRight)",
[ IsHomalgMatrix and HasEvalMulMatRight ],

function( C )
local R, RP, e, A, a;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalMulMatRight( C );

A := e[1];
a := e[2];

if IsBound(RP!.MulMatRight) then
return RP!.MulMatRight( A, a );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called MulMatRight ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return Eval( A ) * a;

end );


##### C.4-18 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using \+ (5.5-20) then the filter HasEvalAddMat for C is set to true and the homalgTable function AddMat (B.1-17) will be used to set the attribute Eval.

InstallMethod( Eval,

function( C )
local R, RP, e, A, B;

R := HomalgRing( C );

RP := homalgTable( R );

A := e[1];
B := e[2];

## delete the component which was left over by GAP

fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called AddMat ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return Eval( A ) + Eval( B );

end );


##### C.4-19 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using \- (5.5-21) then the filter HasEvalSubMat for C is set to true and the homalgTable function SubMat (B.1-18) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalSubMat)",
[ IsHomalgMatrix and HasEvalSubMat ],

function( C )
local R, RP, e, A, B;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalSubMat( C );

A := e[1];
B := e[2];

ResetFilterObj( C, HasEvalSubMat );

## delete the component which was left over by GAP
Unbind( C!.EvalSubMat );

if IsBound(RP!.SubMat) then
return RP!.SubMat( A, B );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called SubMat ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return Eval( A ) - Eval( B );

end );


##### C.4-20 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using \* (5.5-22) then the filter HasEvalCompose for C is set to true and the homalgTable function Compose (B.1-19) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalCompose)",
[ IsHomalgMatrix and HasEvalCompose ],

function( C )
local R, RP, e, A, B;

R := HomalgRing( C );

RP := homalgTable( R );

e :=  EvalCompose( C );

A := e[1];
B := e[2];

ResetFilterObj( C, HasEvalCompose );

## delete the component which was left over by GAP
Unbind( C!.EvalCompose );

if IsBound(RP!.Compose) then
return RP!.Compose( A, B );
fi;

if not IsHomalgInternalMatrixRep( C ) then
Error( "could not find a procedure called Compose ",
"in the homalgTable of the non-internal ring\n" );
fi;

#=====# can only work for homalg internal matrices #=====#

return Eval( A ) * Eval( B );

end );


##### C.4-21 Eval
 ‣ Eval( C ) ( method )

Returns: the Eval value of a homalg matrix C

In case the matrix was created using CoefficientsWithGivenMonomials (5.5-64) then the filter HasEvalCoefficientsWithGivenMonomials for C is set to true and the homalgTable function CoefficientsWithGivenMonomials (B.1-24) will be used to set the attribute Eval.

InstallMethod( Eval,
"for homalg matrices (HasEvalCoefficientsWithGivenMonomials)",
[ IsHomalgMatrix and HasEvalCoefficientsWithGivenMonomials ],

function( C )
local R, RP, pair, M, monomials;

R := HomalgRing( C );

RP := homalgTable( R );

pair := EvalCoefficientsWithGivenMonomials( C );

M := pair[1];
monomials := pair[2];

if IsBound( RP!.CoefficientsWithGivenMonomials ) then

return RP!.CoefficientsWithGivenMonomials( M, monomials );

fi;

Error( "could not find a procedure called CoefficientsWithGivenMonomials ",
"in the homalgTable of the ring\n" );

end );

Goto Chapter: Top 1 2 3 4 5 6 A B C D E F Bib Ind

generated by GAPDoc2HTML