Changeset 4b6c75 in git

Timestamp:

Aug 1, 2001, 3:02:20 PM (23 years ago)

Author:

Mathias Schulze <mschulze@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

c71123eda14e4dc7793b9ff4bb5310155d39dd16

Parents:

1418c4ecec6f1dda76f77dca9a541a4f29998c7e

Message:

*mschulze: jordan output format and jordanmatrix input format changed; jordanbasis computes weight filtration


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

File:

• Singular/LIB/linalg.lib (modified) (12 diffs)

Singular/LIB/linalg.lib

@@ -1 +1 @@
 //GMG last modified: 04/25/2000
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: linalg.lib,v 1.15 2001-07-30 16:38:12 mschulze Exp $";
+version="$Id: linalg.lib,v 1.16 2001-08-01 13:02:20 mschulze Exp $";
 category="Linear Algebra";
 info="
@@ -1445 +1445 @@
 ///////////////////////////////////////////////////////////////////////////////
 
-proc jordan(matrix M,list #)
+proc jordan(matrix M)
 "USAGE:   jordan(M); matrix M
 ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
@@ -1451 +1451 @@
 @format
 list l:
-  ideal l[1]: eigenvalues of M
-  list l[2]:
-    intvec l[2][i]:
-      int l[2][i][j]: size of Jordan block j of M with eigenvalue l[1][i]
+  ideal l[1]: eigenvalues of M in increasing order
+  intvec l[2]: corresponding Jordan block sizes
+  intvec l[3]: corresponding multiplicities 
 @end format
 EXAMPLE: example jordan; shows examples
@@ -1471 +1470 @@
 
   list l=eigenval(M);
-  def e,m=l[1..2];
+  def e0,m0=l[1..2];
+  kill l;
 
   int i;
-  for(i=1;i<=ncols(e);i++)
-  {
-    if(deg(e[i]>0))
+  for(i=1;i<=ncols(e0);i++)
+  {
+    if(deg(e0[i]>0))
     {
       ERROR("eigenvalues in coefficient field expected");
@@ -1484 +1484 @@
 
   int j,k;
-  matrix N,NN;
+  matrix N0,N1;
   module K0;
   list K;
-  intvec b0;
-  list b;
-
-  for(i=ncols(e);i>0;i--)
-  {
-    N=M-e[i]*freemodule(ncols(M));
-
+  ideal e;
+  intvec s,m;
+
+  for(i=1;i<=ncols(e0);i++)
+  {
+    N0=M-e0[i]*freemodule(ncols(M));
+
+    N1=N0;
     K0=0;
-    NN=N;
     K=module();
-    while(size(K0)<m[i])
+    while(size(K0)<m0[i])
     {
-      K0=syz(NN);
+      K0=syz(N1);
       K=K+list(K0);
-      NN=NN*N;
-    }
-
-    b0=0;
-    b0[size(K[2])]=0;
-    for(j=size(K);j>1;j--)
+      N1=N1*N0;
+    }
+
+    for(j=2;j<size(K);j++)
     {
-      for(k=size(b0);k>size(b0)+size(K[j-1])-size(K[j]);k--)
+      if(2*size(K[j])-size(K[j-1])-size(K[j+1])>0)
       {
-        b0[k]=b0[k]+1;
-      }
-    }
-    b=list(b0)+b;
-  }
-
-  l[2]=b;
-  return(l);
+        k++;
+        e[k]=e0[i];
+        s[k]=j-1;
+        m[k]=2*size(K[j])-size(K[j-1])-size(K[j+1]);
+      }
+    }
+    if(size(K[j])-size(K[j-1])>0)
+    {
+      k++;
+      e[k]=e0[i];
+      s[k]=j-1;
+      m[k]=size(K[j])-size(K[j-1]);
+    }
+  }
+
+  return(list(e,s,m));
 }
 example
@@ -1531 +1537 @@
 "USAGE:   jordanbasis(M); matrix M
 ASSUME:  M constant square matrix, eigenvalues of M in coefficient field
-RETURN:  matrix U with inverse(U)*M*U in Jordan normal form
+RETURN:
+@format
+list l:
+  module l[1]: inverse(l[1])*M*l[1] has Jordan normal form
+  intvec l[2]: weight filtration indices of l[1] with center 0
+@end format
 EXAMPLE: example jordanbasis; shows examples
 "
@@ -1566 +1577 @@
   matrix u[ncols(M)][1];
   module U;
-
-  for(i=ncols(e);i>0;i--)
+  intvec w;
+
+  for(i=ncols(e);i>=1;i--)
   {
     N0=M-e[i]*freemodule(ncols(M));
 
+    N1=N0;
     K0=0;
-    N1=N0;
-    K=module();
+    K=list();
     while(size(K0)<m[i])
     {
@@ -1582 +1594 @@
 
     K1=0;
-    for(j=2;j<size(K);j++)
+    for(j=1;j<size(K);j++)
     {
       K0=K[j];
@@ -1590 +1602 @@
     K[j]=interred(reduce(K[j],std(K1)));
 
-    for(j=size(K);j>1;j--)
+    for(l=size(K);l>=1;l--)
     {
-      for(k=size(K[j]);k>0;k--)
+      for(k=size(K[l]);k>0;k--)
       {
-        u=K[j][k];
-        for(l=j;l>0;l--)
+        u=K[l][k];
+        for(j=l;j>=1;j--)
         {
           U=module(u)+U;
+          w=2*j-l-1,w;
           u=N0*u;
         }
@@ -1603 +1616 @@
     }
   }
-
-  return(U);
+  w=w[1..size(w)-1];
+  return(list(U,w));
 }
 example
@@ -1611 +1624 @@
   matrix M[3][3]=3,2,1,0,2,1,0,0,3;
   print(M);
-  matrix U=jordanbasis(M);
-  print(U);
-  print(inverse(U)*M*U);
+  list l=jordanbasis(M);
+  print(l[1]);
+  print(l[2]);
+  print(inverse(l[1])*M*l[1]);
 }
 ///////////////////////////////////////////////////////////////////////////////
 
-proc jordanmatrix(ideal e,list b)
-"USAGE:   jordanmatrix(e,b); ideal e, list b
-RETURN:  matrix J in Jordan normal form 
-         with eigenvalues e and Jordan block sizes b
+proc jordanmatrix(ideal e,intvec s,intvec m)
+"USAGE:   jordanmatrix(e,s,m); ideal e, intvec s, intvec m
+RETURN:
+@format
+matrix J: Jordan normal form with eigenvalues e and Jordan block sizes s
+          with multiplicities m
+@end format
 EXAMPLE: example jordanmatrix; shows examples
 "
 {
-  if(ncols(e)!=size(b))
+  if(ncols(e)!=size(s)||size(e)!=size(m))
   {
     ERROR("arguments of equal size expected");
   }
 
-  int i,j,k,n;
-  for(i=ncols(e);i>=1;i--)
-  {
-    if(typeof(b[i])!="intvec")
+  int i,j,k,l;
+  int n=int((transpose(matrix(s))*matrix(m))[1,1]);
+  matrix J[n][n];
+  for(k=1;k<=ncols(e);k++)
+  {
+    for(l=1;l<=m[k];l++)
     {
-      ERROR("second argument of type list of intvec expected");
-    }
-    else
-    {
-      for(j=size(b[i]);j>=1;j--)
+      j++;
+      J[j,j]=e[k];
+      for(i=s[k];i>=2;i--)
       {
-        k=b[i][j];
-        if(k>0)
-        {
-          n=n+k;
-        }
-      }
-    }
-  }
-  matrix J[n][n];
-
-  int l=1;
-  for(i=1;i<=ncols(e);i++)
-  {
-    for(j=1;j<=size(b[i]);j++)
-    {
-      k=b[i][j];
-      if(k>0)
-      {
-        while(k>=2)
-        {
-          J[l,l]=e[i];
-          J[l,l+1]=1;
-          k--;
-          l++;
-        }
-        J[l,l]=e[i];
-        l++;
+        J[j,j+1]=1;
+        j++;
+        J[j,j]=e[k];
       }
     }
@@ -1677 +1670 @@
   ring R=0,x,dp;
   ideal e=ideal(2,3);
-  list b=list(intvec(1),intvec(2));
-  print(jordanmatrix(e,b));
+  intvec s=1,2;
+  intvec m=1,1;
+  print(jordanmatrix(e,s,m));
 }
 ///////////////////////////////////////////////////////////////////////////////