Added AddMatrixLeft, MultMatrixLeft functions as well as their "right" counterparts

lib/listcoef.gd

@@ -107,10 +107,13 @@ DeclareOperation(
 ##  <ManSection>
 ##  <Oper Name="MultVector" Arg='list1, mul'/>
 ##  <Oper Name="MultVectorLeft" Arg='list1, mul'/>
+##  <Oper Name="MultVectorRight" Arg='list1, mul'/>
 ##  <Returns>nothing</Returns>
 ##
 ##  <Description>
-##  This operation calculates <A>mul</A>*<A>list1</A> in-place.
+##  These operations multiply the entries of <A>list1</A> by <A>mul</A> in-place.
+##  The operation <Ref Oper="MultVectorLeft"/> calculates <A>mul \cdot list1</A> and
+##  the operation <Ref Oper="MultVectorRight"/> calculates <A>list1 \cdot mul</A>.
 ##  <P/>
 ##  Note that <C>MultVector</C> is just a synonym for
 ##  <C>MultVectorLeft</C>.
@@ -122,7 +125,10 @@ DeclareOperation(
     "MultVectorLeft",
         [ IsMutable and IsList,
           IsObject ] );
-# For VectorObj objects there also exists a MultVectorRight operation
+DeclareOperation(
+    "MultVectorRight",
+        [ IsMutable and IsList,
+          IsObject ] );
 DeclareSynonym( "MultVector", MultVectorLeft );
 
 #############################################################################

lib/listcoef.gi

@@ -304,6 +304,51 @@
     MULT_VECTOR_VECFFES );
 
 
+#############################################################################
+##
+#M  MultVectorRight( <list>, <mul> )
+##
+InstallMethod( MultVectorRight,
+    "for a mutable dense list, and an object",
+    [ IsDenseList and IsMutable,
+      IsObject ],
+function( l, m )
+    local   i;
+    for i  in [ 1 .. Length(l) ]  do
+        l[i] := l[i] * m;
+    od;
+end );
+InstallOtherMethod( MultVectorRight, "error if immutable",
+    [ IsList, IsObject ],
+    L1_IMMUTABLE_ERROR);
+
+# TODO: Check if MULT_VECTOR_RIGHT_2 exists and if not, implement it
+# InstallMethod( MultVectorRight,
+#     "kernel method for a mutable dense small list, and an object",
+#     IsCollsElms,
+#     [ IsSmallList and IsDenseList and IsMutable,
+#       IsObject ],
+#     MULT_VECTOR_LEFT_2
+# );
+
+InstallMethod( MultVectorRight,
+    "kernel method for a mutable dense plain list of \
+cyclotomics, and a cyclotomic",
+    IsCollsElms,
+    [ IsDenseList and IsMutable and IsPlistRep and IsCyclotomicCollection,
+      IsCyclotomic ],
+    MULT_VECTOR_2_FAST
+);
+# TODO: Check if MULT_VECTOR_VECFFES does the right thing for multiplying form the right
+# InstallMethod( MultVectorRight,
+#     "kernel method for a mutable row vector of ffes in \
+# plain list rep, and an ffe",
+#     IsCollsElms,
+#     [ IsRowVector and IsMutable and IsPlistRep and IsFFECollection,
+#       IsFFE],0,
+#     MULT_VECTOR_VECFFES );
+
+
 #############################################################################
 ##
 #M  RightShiftRowVector( <list>, <shift>, <fill> )

lib/matobj.gi

@@ -1877,9 +1877,151 @@
 
   end );
 
+#############################################################################
+##
+#M  AddMatrix( <mat1>, <mat2> )
+##
+
+InstallMethod( AddMatrix, "for a mutable matrix object and a matrix object",
+  [ IsMatrixOrMatrixObj and IsMutable, IsMatrixOrMatrixObj ],
+  function( dstmat, srcmat )
+    local i, j;
+    # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+    # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+    for i in [1..NrRows(dstmat)] do
+      for j in [1..NrCols(dstmat)] do
+        dstmat[i,j] := dstmat[i,j] + srcmat[i,j];
+      od;
+    od;
+  end );
+
+InstallEarlyMethod( AddMatrix,
+  function( dstmat, srcmat )
+    local i;
+    if IsPlistRep(dstmat) and IsPlistRep(srcmat) then
+      # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+      # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+      for i in [1..NrRows(dstmat)] do
+        AddRowVector(dstmat[i], srcmat[i]);
+      od;
+    else
+      TryNextMethod();
+    fi;
+  end );
+
+InstallMethod( AddMatrix, "for a mutable 8bit matrix and an 8bit matrix",
+  [ Is8BitMatrixRep and IsMutable, Is8BitMatrixRep ],
+  function( dstmat, srcmat )
+    local i, j;
+    # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+    # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+    for i in [1..NrRows(dstmat)] do
+      ADD_COEFFS_VEC8BIT_3(dstmat[i], srcmat[i]);
+    od;
+  end );
+
+#############################################################################
+##
+#M  AddMatrix( <mat1>, <mat2>, <mult> )
+##
+
+InstallMethod( AddMatrix, "for a mutable matrix object, a matrix object, and a scalar",
+  [ IsMatrixOrMatrixObj and IsMutable, IsMatrixOrMatrixObj, IsScalar ],
+  function( dstmat, srcmat, scalar )
+    local i, j;
+    # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+    # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+    for i in [1..NrRows(dstmat)] do
+      for j in [1..NrCols(dstmat)] do
+        dstmat[i,j] := dstmat[i,j] + srcmat[i,j] * scalar;
+      od;
+    od;
+  end );
+
+InstallEarlyMethod( AddMatrix,
+  function( dstmat, srcmat, scalar )
+    local i;
+    if IsPlistRep(dstmat) and IsPlistRep(srcmat) then
+      # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+      # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+      for i in [1..NrRows(dstmat)] do
+        AddRowVector(dstmat[i], srcmat[i], scalar);
+      od;
+    else
+      TryNextMethod();
+    fi;
+  end );
+
+InstallMethod( AddMatrix, "for a mutable 8bit matrix, an 8bit matrix, and a scalar",
+  [ Is8BitMatrixRep and IsMutable, Is8BitMatrixRep, IsFFE ],
+  function( dstmat, srcmat, scalar )
+    local i, j;
+    # Assert(0, NrRows(dstmat) = NrRows(srcmat));
+    # Assert(0, NrCols(dstmat) = NrCols(srcmat));
+    for i in [1..NrRows(dstmat)] do
+      ADD_COEFFS_VEC8BIT_3(dstmat[i], srcmat[i], scalar);
+    od;
+  end );
+
+#############################################################################
+##
+#M  MultMatrixRight( <mat>, <mult> )
+##
+
+InstallMethod( MultMatrixRight, "for a mutable matrix object and a scalar",
+  [ IsMatrixOrMatrixObj and IsMutable, IsScalar ],
+  function( mat, scalar )
+    local i, j;
+    for i in [1..NrRows(mat)] do
+      for j in [1..NrCols(mat)] do
+        mat[i,j] := mat[i,j] * scalar;
+      od;
+    od;
+  end );
+
+InstallEarlyMethod( MultMatrixRight,
+  function( mat, scalar )
+    local i;
+    if IsPlistRep(mat) and IsScalar(scalar) then
+      for i in [1..NrRows(mat)] do
+        MultVectorRight(mat[i], scalar);
+      od;
+    else
+      TryNextMethod();
+    fi;
+  end );
+
+#############################################################################
+##
+#M  MultMatrixLeft( <mat>, <mult> )
+##
+
+InstallMethod( MultMatrixLeft, "for a mutable matrix object and a scalar",
+  [ IsMatrixOrMatrixObj and IsMutable, IsScalar ],
+  function( mat, scalar )
+    local i, j;
+    for i in [1..NrRows(mat)] do
+      for j in [1..NrCols(mat)] do
+        mat[i,j] := scalar * mat[i,j];
+      od;
+    od;
+  end );
+
+InstallEarlyMethod( MultMatrixLeft,
+  function( mat, scalar )
+    local i;
+    if IsPlistRep(mat) and IsScalar(scalar) then
+      for i in [1..NrRows(mat)] do
+        MultVectorLeft(mat[i], scalar);
+      od;
+    else
+      TryNextMethod();
+    fi;
+  end );
 
 ############################################################################
 ##  Fallback method for DeterminantMatrix
+
 InstallMethod(DeterminantMatrix, ["IsMatrixObj"],
 function( mat )
   return DeterminantMat( Unpack( mat ) );

lib/matobj2.gd

@@ -2052,3 +2052,86 @@ DeclareOperationKernel( "SwapMatrixRows", [ IsMatrixOrMatrixObj and IsMutable, I
 ##  <#/GAPDoc>
 ##
 DeclareOperationKernel( "SwapMatrixColumns", [ IsMatrixOrMatrixObj and IsMutable, IsInt, IsInt ], SWAP_MAT_COLS );
+
+############################################################################
+##
+##  <#GAPDoc Label="AddMatrixRight">
+##  <ManSection>
+##  <Oper Name="AddMatrixRight" Arg='M, N[, c]'/>
+##
+##  <Returns>nothing</Returns>
+##
+##  <Description>
+##  <P/>
+##  Computes the calculation <M>M + c \cdot N</M> in-place, storing the result in <A>M</A>.
+##  If both of the matrices are lists-of-lists, then the program utilises <Ref Oper="AddRowVector"/>
+##  to perform the operation even faster.
+##  <Example><![CDATA[
+##  gap> mat1 := [ [ 1, 2 ], [ 3, 4 ] ];
+##  [ [ 1, 2 ], [ 3, 4 ] ]
+##  gap> mat2 := [ [ 1, 0 ], [ 3, -1 ] ];
+##  [ [ 1, 0 ], [ 3, -1 ] ]
+##  gap> AddMatrix( mat1, mat2, 2 );
+##  gap> mat1;
+##  [ [ 3, 2 ], [ 9, 2 ] ]
+##  gap> mat2;
+##  [ [ 1, 0 ], [ 3, -1 ] ]
+##  gap> AddMatrix( mat1, [ [ 1, 0], [ 3, -1] ] );
+##  gap> mat1;
+##  [ [ 4, 2 ], [ 12, 1 ] ]
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareOperation( "AddMatrix", [ IsMatrixOrMatrixObj and IsMutable, IsMatrixOrMatrixObj ] );
+DeclareOperation( "AddMatrix", [ IsMatrixOrMatrixObj and IsMutable, IsMatrixOrMatrixObj, IsScalar ] );
+
+############################################################################
+##
+##  <#GAPDoc Label="MultMatrix">
+##  <ManSection>
+##  <Oper Name="MultMatrix" Arg='mat, c'/>
+##  <Oper Name="MultMatrixLeft" Arg='mat, c'/>
+##  <Oper Name="MultMatrixRight" Arg='mat, c'/>
+##
+##  <Returns>nothing</Returns>
+##
+##  <Description>
+##  <P/>
+##  These functions multiply the entries of <A>mat</A> by <A>c</A> in-place.
+##  <Ref Oper="MultMatrixRight"/> performs the operation <M>mat \cdot c</M>,
+##  whereas <Ref Oper="MultMatrixLeft"/> performs the operation <M>c \cdot mat</M>
+##  and <Ref Oper="MultMatrix"/> is an alias for <Ref Oper="MultMatrixLeft"/>.
+##  In all of these, if the matrix <A>mat</A> is a lists-of-lists, then the program
+##  utilises the fast in-place operations <Ref Oper="MultVectorRight"/> and <Ref Oper="MultVectorLeft"/>.
+##  to perform the operation even faster.
+##  <Example><![CDATA[
+##  gap> mat1 := [ [ 1, 2 ], [ 3, 4 ] ];
+##  [ [ 1, 2 ], [ 3, 4 ] ]
+##  gap> MultMatrixRight(mat1, -2);
+##  gap> mat1;
+##  [ [ -2, -4 ], [ -6, -8 ] ]
+##  gap> MultMatrix(mat1, -2); # Note that this is the same as calling MultMatrixLeft(mat1, -2)
+##  gap> mat1;
+##  [ [ 4, 8 ], [ 12, 16 ] ]
+##  gap> A := FreeAssociativeAlgebra(Rationals, 2);
+##  <algebra over Rationals, with 2 generators>
+##  gap> mat2 := [ [ A.1, A.2 ], [ A.1 * 2, A.2 * 3 ] ];
+##  [ [ (1)*x.1, (1)*x.2 ], [ (2)*x.1, (3)*x.2 ] ]
+##  gap> MultMatrixLeft(mat2, A.1);
+##  gap> mat2;
+##  [ [ (1)*x.1^2, (1)*x.1*x.2 ], [ (2)*x.1^2, (3)*x.1*x.2 ] ]
+##  gap> mat2 := [ [ A.1, A.2 ], [ A.1 * 2, A.2 * 3 ] ];
+##  [ [ (1)*x.1, (1)*x.2 ], [ (2)*x.1, (3)*x.2 ] ]
+##  gap> MultMatrixRight(mat2, A.1);
+##  gap> mat2;
+##  [ [ (1)*x.1^2, (1)*x.2*x.1 ], [ (2)*x.1^2, (3)*x.2*x.1 ] ]
+##  ]]></Example>
+##  </Description>
+##  </ManSection>
+##  <#/GAPDoc>
+##
+DeclareOperation( "MultMatrixRight", [ IsMatrixOrMatrixObj and IsMutable, IsScalar ] );
+DeclareOperation( "MultMatrixLeft", [ IsMatrixOrMatrixObj and IsMutable, IsScalar ] );
+DeclareSynonym( "MultMatrix", MultMatrixLeft);