Changeset 09b38e in git

Timestamp:

Mar 30, 2011, 6:35:05 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

2caede44bc1e423ef32297874f5a15517729e721

Parents:

a796fbdaa0242a20ef39e60d40c2d02dba2c9eb4

Message:

*Lars Kastner: Added return documentation to multiDegTensor. Bug fixed.

From: Oleksandr Motsak <motsak@mathematik.uni-kl.de>

git-svn-id: file:///usr/local/Singular/svn/trunk@14086 2c84dea3-7e68-4137-9b89-c4e89433aadc

File:

• Singular/LIB/multigrading.lib (modified) (22 diffs)

Singular/LIB/multigrading.lib

@@ -37 +37 @@
 printGroup(G);             print a group
 
-areIsomorphicGroups(G,H);     test wheter G an H are isomorphic groups
 isGroup(G);                   test whether G is a valid group
 isGroupHomomorphism(L1,L2,A); test wheter A defines a group homomrphism from L1 to L2
@@ -58 +57 @@
 isPrimitiveSublattice(A); test whether A generates a primitive sublattice.
 intInverse(A);            computes the integral inverse matrix of the intmat A
-intAdjoint(A,i,j);        delete row i and column j of the intmat A.
 integralSection(P);       for a given linear surjective map P of lattices this procedure returns an integral section of P.
 primitiveSpan(A);         computes a basis for the minimal primitive sublattice that contains the given vectors (by A).
@@ -522 +520 @@
 static proc areIsomorphicGroups(def G, def H)
 "USAGE: areIsomorphicGroups(G, H); G and H are groups
-PURPOSE: ?
+PURPOSE: Check whether G and H define isomorphic groups.
 RETURN: int, 1 for TRUE, 0 otherwise
 EXAMPLE: example areIsomorphicGroups; shows an example
@@ -1267 +1265 @@
 
 
-proc multiDegTensor(module m, module n){
+proc multiDegTensor(module m, module n)
+"
+USAGE: multiDegTensor(m, n), m,n  modules or matrices.
+PURPOSE: Computes the multigraded tensor product of to multigraded modules.
+RETURN: A module.
+EXAMPLE: example multiDegTensor; shows an example
+"
+{
   matrix M = m;
   matrix N = n;
@@ -1442 +1447 @@
 /******************************************************/
 proc isGroupHomomorphism(def L1, def L2, intmat A)
-"USAGE: gisGoupHomomorphism(L1,L2,A); L1 and L2 are groups, A is an integer matrix
+"USAGE: isGoupHomomorphism(L1,L2,A); L1 and L2 are groups, A is an integer matrix
 PURPOSE: checks whether A defines a group homomorphism phi: L1 --> L2
 RETURN: int, 1 if A defines the homomorphism and 0 otherwise
@@ -4573 +4578 @@
 example
 {
+  "EXAMPLE:"; echo=2;
 
   intmat A[3][4] =
@@ -4584 +4590 @@
   print(r); // Should be 2
 
-  kill A;
+  // another example
+  intmat B[2][2] =
+    1,2,
+    1,2;
+
+  int d = intRank(B);
+
+  print(B);
+  print(d); // Should be 1
+
+  kill A, B, r, d;
 
 }
@@ -4596 +4612 @@
 The procedure checks whether each generator of L is
 contained in S.
-RETURN: 0 if false, 1 if true
+RETURN: integer, 0 if false, 1 if true
 EXAMPLE: example isSublattice; shows an example
 "
@@ -4747 +4763 @@
 
   intmat B = latticeBasis(L); 
-  print(B); // should be a matrix with columns [1,2,3] and [0,3,6]
+  print(B); // should result in a matrix whose columns generate the same lattice as  [1,2,3] and [0,3,6]:
+
+   // another example
+  intmat C[2][4] =
+    1,1,2,0,
+    2,3,4,0;
+
+  // should result in a matrix whose
+  // colums create the same  lattice as
+  // [0,1],[1,0]
+  intmat D = latticeBasis(C);
+
+  print(D);
 
   kill B,L;
@@ -4812 +4840 @@
     3,6,9,12;
 
-  // should be a 4x2 matrix with colums
-  // [-1,2,-1,0],[2,-3,0,1]
+  // should be a 4x2 matrix whose columns
+  // generate the same lattice as [-1,2,-1,0],[2,-3,0,1]
   intmat B = kernelLattice(LL);
-
+  
   print(B);
+
+  // another example
+  intmat C[2][4] =
+    1,0,2,0,
+    0,1,2,0;
+
+  // should result in a matrix whose
+  // colums create the same  lattice as
+  // [-2,-2,1,0], [0,0,0,1]
+  intmat D = kernelLattice(C);
+
+  print(D);
 
   kill B;
@@ -4854 +4894 @@
   }
 
-
-//  print(Con);
-
   intmat L = kernelLattice(Con);
-/*
-  print(L);
-  print(ncols(P));
-  print(ncols(L));
-*/
+
   // delete rows ncols(P)+1 to nrows(L) out of L
   intmat Del[ncols(P)][ncols(L)];
@@ -4895 +4928 @@
   // should be a (3x2)-matrix with columns e.g. [1,1,-1] and [0,3,-2] (the generated lattice should be identical)
   print(preimageLattice(P,B));
+
+  // another example
+  intmat W[3][3] =
+    1,0,0,
+    0,1,1,
+    0,2,0;
+
+  intmat Z[3][2] =
+    1,0,
+    0,1,
+    0,0;
+
+  // should be a (3x2)-matrix with columns e.g. [1,0,0] and [0,0,-1] (the generated lattice should be identical)
+  print(preimageLattice(W,Z));
+
 }
 
@@ -4933 +4981 @@
   // should be 0
   int b = isPrimitiveSublattice(A);
-  b;
-
-  if( b != 0 ){ ERROR("Sorry, something went wrong..."); }
-
-  kill A,b;
+  print(b);
+
+  // another example
+
+  intmat B[2][2] =
+    1,0,
+    0,1;
+
+  // should be 1
+  int c = isPrimitiveSublattice(B);
+  print(c);
+
+  kill A, b, B, c;
 }
 
@@ -4956 +5012 @@
   }
 
-  if ( isPrimitiveSublattice(A) == 1 )
+
+  if ( isPrimitiveSublattice(P) == 1 )
   {
     return(1);
@@ -4967 +5024 @@
   "EXAMPLE"; echo = 2;
 
-  intmat A[3][2] =
+  intmat A[2][3] =
     1,3,5,
     2,4,6;
@@ -4975 +5032 @@
   print(b);
 
-  kill A,b;
+  // another example
+  intmat B[2][3] =
+    1,1,5,
+    2,3,6;
+
+  // should be 1
+  int c = isIntegralSurjective(B);
+  print(c);
+
+  kill A, b, B, c;
 }
 
@@ -5055 +5121 @@
   print(projectLattice(BB));
 
-  // one more example
+  // another example
 
   intmat BBB[3][4] =
@@ -5154 +5220 @@
 
   // should result in a (3x2)-matrix with columns
-  //  e.g. [3, 3, 3], [-3, 0, 3] (the lattice should be the same)
+  //  e.g. [0, 3, 6], [-3, 0, 3] (the lattice should be the same)
   print(intersectLattices(A,B));
-}
+
+  // another example
+  intmat C[2][3] =
+    1,0,0,
+    3,2,5;
+
+  intmat D[2][3] =
+    4,5,0,
+    0,5,0;
+
+  // should result in a (3x2)-matrix whose columns generate the
+  // same lattice as [1,5], [0, 20]
+  print(intersectLattices(C,D));
+}
+
+////////////////////////////////////
 
 proc intInverse(intmat A);
@@ -5213 +5294 @@
   print(A * B);
 
-  kill A,B;
+  // another example
+  intmat C[2][2] =
+    2,1,
+    3,2;
+  
+  intmat D  = intInverse(C);
+
+  // should be the unit matrix
+  print(C * D);
+
+  kill A, B, C, D;
 }
 
 
 /******************************************************/
-proc intAdjoint(intmat A, int indrow, int indcol)
+static proc intAdjoint(intmat A, int indrow, int indcol)
 "USAGE: intAdjoint(A); intmat A
 PURPOSE: return the matrix where the given row and column are deleted.
@@ -5392 +5483 @@
 proc productgroup(G,H)
 "USAGE: productgroup(G,H); list G, list H
-PURPOSE: returns a representation of the G x H
+PURPOSE: Returns a representation of the group G x H
 RETURNS: list
 EXAMPLE: example productgroup(G,H); shows an example
@@ -5457 +5548 @@
 /******************************************************/
 proc primitiveSpan(intmat V);
-"USAGE: isIntegralSurjective(V); intmat V
+"USAGE: primitiveSpan(V); intmat V
 PURPOSE: compute an integral basis for the minimal primitive
 sublattice that contains the given vectors, i.e. the columns of V.
 RETURNS: int, where 0 is false and 1 is true.
-EXAMPLE: example isIntegralSurjective; shows an example
+EXAMPLE: example primitiveSpan; shows an example
 "
 {
@@ -5504 +5595 @@
   "EXAMPLE"; echo = 2;
 
-  intmat V[2][4] =
+  intmat V[3][2] =
     1,4,
     2,5,
     3,6;
 
-  // should return a (4x2)-matrix with columns
-  // [1, 2, 3] and [1, 1, 1] (or similar)
+  // should return a (3x2)-matrix whose columns
+  // generate the same lattice as [1, 2, 3] and [0, 1, 2] 
   intmat R = primitiveSpan(V);
   print(R);
 
-  kill V,R;
+  // another example
+  intmat W[2][2] =
+    1,0,
+    0,1;
+
+  // should return a (2x2)-matrix whose columns
+  // generate the same lattice as [1, 0] and [0, 1] 
+  intmat S = primitiveSpan(W);
+  print(S);
+
+  kill V, R, S, W;
 }