Changeset d5f9d98 in git

Timestamp:

Feb 25, 2005, 11:45:27 AM (19 years ago)

Author:

Viktor Levandovskyy <levandov@…>

Branches:

(u'spielwiese', 'ec94ef7a30b928574c0c3daf41f6804dff5f6b69')

Children:

dc6b576eab156ea960b83a3ed8a822d14adab0b7

Parents:

cbea7991f06987b6fda55b7d0836fa40b140110d

Message:

*levandov: docu rewritten, tex functions by Markus added, revised examples, RightInverse etc


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

File:

• Singular/LIB/control.lib (modified) (25 diffs)

Singular/LIB/control.lib

@@ -1 @@
-version="$Id: control.lib,v 1.21 2005-02-18 17:38:45 levandov Exp $";
+version="$Id: control.lib,v 1.22 2005-02-25 10:45:27 levandov Exp $";
 category="Applications";
 info="
@@ -13 +13 @@
 
 PROCEDURES:
-control(module R);            analysis of controllability-related properties of R,
-autonom(module R);            analysis of autonomy-related properties of R (using Ext modules),
-autonom2(module R);           analysis of autonomy-related properties of R (using dimension),
-
-LeftKernel(module R);         a left kernel of R,
-RightKernel(module R);        a right kernel of R,
-LeftInverse(module R)         a left inverse of matrix (module),
-
-smith(module M);              a Smith form of a module M,
-
-genericity(module M);         analysis of the genericity of parameters,
-
-canonize(list L);             Groebnerification for modules in the output of control/autonomy procs. 
+control  (R);           analysis of controllability-related properties of R,
+autonom  (R);           analysis of autonomy-related properties of R (using Ext modules),
+autonom2 (R);           analysis of autonomy-related properties of R (using dimension),
+LeftKernel  (R);        a left kernel of R,
+RightKernel (R);        a right kernel of R,
+LeftInverse (R)         a left inverse of R,
+smith (M);              a Smith form of a module M,
+genericity (M);         analysis of the genericity of parameters,
+canonize (L);           Groebnerification for modules in the output of control/autonomy procs. 
 
 AUXILIARY PROCEDURES:
-declare(string NameOfRing, Variables[,string  Parameters, Ordering]);     defines the ring, optional parametes are strings of parameters and ordering,
-view();                      Well-formatted output of lists, modules and matrices
+declare(NameOfRing,Variables [,Parameters, Ordering]);    define the ring easily
+view();                      well-formatted output of lists, modules and matrices
 
 NOTE (EXAMPLES): In order to use examples below, execute the commands
 @* def A = exAntenna(); setring A; 
-@* Thus A will become a basering from the example with the predefined module R (transposed), corresponding to the system. 
-After that you can just type in 
+@* Thus A will become a basering from the example with the predefined module R (transposed), corresponding to the system. After that you can just type in 
 @* control(R); //respectively autonom(R); 
 and check the result.
@@ -40 +35 @@
 
 EXAMPLES (AUTONOMY):
-
 exCauchy();                  example of 1-dimensional Cauchy equation,
 exCauchy2();                 example of 2-dimensional Cauchy equation,
@@ -46 +40 @@
 
 EXAMPLES (CONTROLLABILITY):
-
 ex1();                       example of noncontrollable system,   
 ex2();                       example of controllable system ,
@@ -52 +45 @@
 exEinstein();                Einstein equations,
 exFlexibleRod();             Flexible Rod,
-exTwoPendula();              Two Pendula,
+exTwoPendula();              Two Pendula mounted on a cart,
 exWindTunnel();              Wind Tunnel. 
 ";
@@ -88 +81 @@
 proc declare(string NameOfRing, string Variables, list #)
 "USAGE: declare(NameOfRing, Variables,[Parameters, Ordering]);
-          NameOfRing:  string with name of ring,
-          Variables:   string with names of variables separated by commas(e.g. "x,y,z"),
-          [Parameters, Ordering]: optional, strings:
-            Parameters: string of parameters in the ring separated by commas(e.g. "a,b,c"),
-            Ordering:   string with name of ordering(by default the ordering "dp,C" is used)
+@*          NameOfRing:  string with name of ring,
+@*          Variables:   string with names of variables separated by commas(e.g. \"x,y,z\"),
+@*          Parameters: string of parameters in the ring separated by commas(e.g. \"a,b,c\"),
+@*          Ordering:   string with name of ordering (by default, the ordering \"dp,C\" is used)
+PURPOSE: define the ring easily
 RETURN:  no return value
 EXAMPLE:  example declare; shows an example 
@@ -183 +176 @@
 "
 {
+  // to be replaced with something more feasible
   if ( (typeof(M)=="module")||(typeof(M)=="matrix") )
   {
@@ -254 +248 @@
 proc RightKernel(matrix M)
 "USAGE:  RightKernel(M);   M a matrix
-RETURN:  right kernel of matrix M, i.e., the module of all elements v such that Mv=0
+PURPOSE: computes the right kernel of matrix M (a module of all elements v such that Mv=0)
+RETURN:  module
 NOTE:    in the noncommutative case RightKernel is a right module
-EXAMPLE:  example RightKernel; shows an example
+EXAMPLE: example RightKernel; shows an example
 "
 { 
@@ -274 +269 @@
 proc LeftKernel(matrix M)
 "USAGE:  LeftKernel(M);   M a matrix
-RETURN:  left kernel of matrix M, i.e. the module of all elements v such that vM=0
+PURPOSE: computes left kernel of matrix M (a module of all elements v such that vM=0)
+RETURN:  module
 EXAMPLE:  example LeftKernel; shows an example
 "
@@ -293 +289 @@
 proc LeftInverse(module M)
 "USAGE:  LeftInverse(M);  M a module
-RETURN:  matrix L such that LM == Id;
+PURPOSE: computes such a matrix L, that LM == Id;
+RETURN:  module
 EXAMPLE: example LeftInverse; shows an example
 NOTE: exists only in the case when Id \subseteq M!
@@ -350 +347 @@
 //-----------------------------------------------------------------------
 proc RightInverse(module R)
+"USAGE:  RightInverse(M);  M a module
+PURPOSE: computes such a matrix L, that ML == Id;
+RETURN:  module
+EXAMPLE: example RightInverse; shows an example
+NOTE: exists only in the case when Id \subseteq M!
+"
 {
   return(transpose(LeftInverse(transpose(R))));
 }
+example
+{ // trivial example:
+"EXAMPLE:";echo =2;
+  ring r = 0,(x,z),dp;
+  matrix M[1][2] = 1,x2+z;
+  print(M);
+  print( RightInverse(M) );  
+  kill r;
+  // derived from the exTwoPendula
+  ring r=(0,m1,m2,M,g,L1,L2),Dt,dp;
+  matrix U[1][3];
+  U[1,1]=(-L2)*Dt^4+(g)*Dt^2;
+  U[1,2]=(-L1)*Dt^4+(g)*Dt^2;
+  U[1,3]=(L1*L2)*Dt^4+(-g*L1-g*L2)*Dt^2+(g^2);
+  module M = module(U);
+  module L = RightInverse(M);
+  print(L);
+};
 //-----------------------------------------------------------------------
 static proc dim_Our(module R)
@@ -420 +441 @@
 "USAGE:  control_output(i, NVars, R, Ext_1), where
            i:  integer, number of first nonzero Ext or 
-               just number of variables in a base ring + 1 in case that all the Exts are zero,
+             just a number of variables in a base ring + 1 in case that all the Exts are zero,
            NVars:  integer, number of variables in a base ring,
            R:  module R (cokernel representation),
@@ -503 +524 @@
 
 proc control(module R)
-"USAGE:  control(R); R a module (R is the matrix of the system of equations which is to be investigated)
-RETURN:  list of all the properties concerning controllability of the system (behavior) represented by the  matrix R
+"USAGE:  control(R);  R a module (R is the matrix of the system of equations to be investigated)
+PURPOSE: compute the list of all the properties concerning controllability of the system (behavior), represented by the matrix R
+RETURN:  list
 EXAMPLE:  example control; shows an example
 "
@@ -546 +568 @@
 //------------------------------------------------------------------------------------------
 proc control2(module R)
-"USAGE:  control2(R); R a module (R is the matrix of the system of equations which is to be investigated)
-RETURN:  list of all the properties concerning controllability of the system (behavior) represented by the  matrix R
+"USAGE:  control2(R); R a module (R is the matrix of the system of equations to be investigated)
+PURPOSE: computes list of all the properties concerning controllability of the system (behavior), represented by the  matrix R
+RETURN: list
 EXAMPLE:  example control; shows an example
 NOTE: same as control(R); but using dimensions
@@ -657 +680 @@
 proc autonom2(module R)
 "USAGE:  autonom2(R);   R a module (R is a matrix of the system of equations which is to be investigated)
-RETURN:  list of all the properties concerning autonomy of the system (behavior) represented by the matrix R
-NOTE:  this procedure is an analogue to 'autonom' using dimension calculations
+PURPOSE: computes the list of all the properties concerning autonomy of the system (behavior), represented by the matrix R
+RETURN: list
+NOTE:  this procedure is analogous to 'autonom' but uses dimension calculations
 EXAMPLE:  example autonom2; shows an example
 "
@@ -872 +896 @@
 proc genericity(matrix M)
 "USAGE:  genericity(M), M is a module/matrix
-RETURN:  list of strings with expressions, which have been assumed to be non-zero in the process of computing the Groebner basis
+PURPOSE: determine parametric expressions which have been assumed to be non-zero in the process of computing the Groebner basis
+RETURN:  list (of strings)
 NOTE: we strongly recommend to switch on the redSB and redTail options; 
-the procedure is effective with the lift procedure for modules with parameters
+@*    the procedure is effective with the lift procedure for modules with parameters
 EXAMPLE:  example genericity; shows an example
 "
 {
+  // returns nothing, if there are no parameters!
+  if (npars(basering)==0)
+  {
+    return("");
+  }
+  int plevel = printlevel-voice+2;
   // M is a matrix over a ring with params and vars;
   ideal I = ideal(M); // a list of entries
@@ -890 +921 @@
   intvec ZeroVec; ZeroVec[nvars(basering)] = 0;
   intvec W;
+  ideal Numero, Denomiro;
+  int cNu=0; int cDe=0;
   for (i=1; i<=s; i++)
   {
@@ -898 +931 @@
     {
       num    = denominator(leadcoef(p)); // from poly.lib
-      p      = p*num;
-      NM[cl] = p;
+      NM[cl] = numerator(leadcoef(p));
+      dbprint(p,"numerator:");
+      dbprint(p, string(NM[cl]));
+      cNu++; Numero[cNu]= NM[cl];
       cl++;
-      NM[cl] = num;
+      NM[cl] = num; // denominator
+      dbprint(p,"denominator:");
+      dbprint(p, string(NM[cl]));
+      cDe++; Denomiro[cDe]= NM[cl];
       cl++;
       p = p - lead(p); // for the next cycle
@@ -910 +948 @@
       p   = p/num;
       NM[cl] = denominator(num);
+      dbprint(p,"content denominator:");
+      dbprint(p, string(NM[cl]));
+      cNu++; Numero[cNu]= NM[cl];
       cl++;
       NM[cl] = numerator(num);
+      dbprint(p,"content numerator:");
+      dbprint(p, string(NM[cl]));
+      cDe++; Denomiro[cDe]= NM[cl];
       cl++;
     }
+    // it seems that the next elements will not have real influence
     while( p != 0)
     {
-      NM[cl] = leadcoef(p); // should be all integer
+      NM[cl] = leadcoef(p); // should be all integer, i.e. non-rational
+      dbprint(p,"coef:");
+      dbprint(p, string(NM[cl]));
       cl++;
       p = p - lead(p);
@@ -944 +991 @@
       cf = 1;
       // factorize every polynomial
-      // throw away every non-monomial
+      // throw away every monomial from factorization (also constants from above ring)
       for (j=1; j<=size(F);j++)
       {
@@ -957 +1004 @@
   }
   // return the result [in string-format]
-  @L = simplify(@L,2+4); // skip zeroes and double entries
+  @L = simplify(@L,2+4+8); // skip zeroes, doubled and entries, diff. by a constant
   list SL;
   for (j=1; j<=size(@L);j++)
@@ -989 +1036 @@
 proc canonize(list L)
 "USAGE:  canonize(L), L a list
+PURPOSE: modules in the list are canonized by computing their reduced minimal (= unique in the given ordering) Groebner bases
+RETURN:  list 
 ASSUME:  L is the output of control/autonomy procedures
-RETURN:  a canonized list, where modules are canonized by computing
-their reduced minimal (= unique in the given ordering) Groebner bases
 EXAMPLE:  example canonize; shows an example
 "
@@ -1083 +1130 @@
   }
 }
-
+//---------------------------------------------------------------
 static proc NoNon0Pol(vector v)
 // returns 1, if there is only one non-zero element in v and 0 else
@@ -1102 +1149 @@
   return(i);
 }
-
-
+//---------------------------------------------------------------
 proc smith( module M )
 "USAGE: smith(M), M a module or a matrix,
+PURPOSE: computes the Smith form of a matrix
 RETURN: a list of length 4 with the following entries:
-[1]: The Smith-Form S of M, 
-[2]: the rank of M, 
-[3]: a unimodular matrix U,
-[4]: a unimodular matrix V, 
+@*      [1]: The Smith-Form S of M, 
+@*      [2]: the rank of M, 
+@*      [3]: a unimodular matrix U,
+@*      [4]: a unimodular matrix V, 
 such that U*M*V=S. An empty list is returned when no Smith Form exists. 
 NOTE: The Smith form only exists over PIDs (principal ideal domains).
@@ -1256 +1303 @@
   print(B2);
 }
+//---------------------------------------------------------------
+proc list_tex(list L, string name, link l)
+"USAGE: control_tex(l), where l is a list
+PURPOSE:        writes the content of list L in a tex-file 'name'
+RETURN: nothing
+"
+{
+  if(size(L)==0)
+    {
+    }
+  else
+    {
+      string t;
+      for (int i=1;i<=size(L);i++)
+        {
+          while(1)
+            {
+              if(typeof(L[i])=="string")
+                {
+                  t=L[i];
+                  write(l,t,"\\par");
+                  break;
+                }
+              if(typeof(L[i])=="module")
+                {
+                  texobj(s,matrix(L[i]));
+                  break;
+                }
+              texobj(s,L[i]);
+              write(l,"\\par");
+              break;
+            }
+        }
+    }
+}
+//---------------------------------------------------------------
+proc verbatim_tex(string s, link l)
+"USAGE: verbatim_tex(s,l), where s is a string and l a link
+PURPOSE: writes the content of s in verbatim-environment in the file
+         specified by link
+RETURN: nothing
+"
+{
+  write(l,"\\begin{verbatim}");
+  write(l,s);
+  write(l,"\\end{verbatim}");
+  write(l,"\\par");
+}