Changeset 3a0213 in git


Ignore:
Timestamp:
May 15, 2020, 4:50:16 PM (4 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
6fcca4d81eb633c898e716b3afd040a920a4056e
Parents:
a1b40ab8675488c2a4f8e225d9d748ba70340727
Message:
spelling p3
Location:
Singular/LIB
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/methods.lib

    ra1b40a r3a0213  
    1010
    1111Methods select the function to execute by the types of the input tuple.
    12 The central function is installMethod, which takes a hashtable assocating a tuple of
     12The central function is installMethod, which takes a hashtable associating a tuple of
    1313input types to function names and creates a corresponding procedure.
    1414

  • Singular/LIB/moddiq.lib

    ra1b40a r3a0213  
    5656
    5757/* test if a prime number p is permissible for an ideal I
    58  * i.e. it does not divide the denominator of any of the coeffients
     58 * i.e. it does not divide the denominator of any of the coefficients
    5959 * or numerator of any of the leading coefficients */
    6060static proc isPermissible(int p,ideal I)
    … …  
    6363    def J = simplify(I, 2);
    6464
    65     /* clear denominators and compute the leading coeffients of
     65    /* clear denominators and compute the leading coefficients of
    6666       the cleared one and the original one*/
    6767    int n = ncols(J);

  • Singular/LIB/modnormal.lib

    ra1b40a r3a0213  
    1818Following [1], the idea is to apply the normalization algorithm given in [2]
    1919over finite fields and lift the results via Chinese remaindering and rational
    20 reconstruction as described in [3]. This approch is inherently parallel.@*
     20reconstruction as described in [3]. This approach is inherently parallel.@*
    2121The strategy is available both as a randomized and as a verified algorithm.
    2222
    … …  
    8282
    8383
    84 // Computes the normalization of I in characterisitic p.
     84// Computes the normalization of I in characteristic p.
    8585// Returns an ideal Out such that the normalization mod p is the
    8686// module 1/condu * Out
    … …  
    129129  // normalization process. (For example, if I is prime.)
    130130  if(size(l[2]) > 1){
    131     ERRROR("Original ideal is not prime (Not implemented.) or unlucky prime");
     131    ERROR("Original ideal is not prime (Not implemented.) or unlucky prime");
    132132  }
    133133

  • Singular/LIB/modstd.lib

    ra1b40a r3a0213  
    675675RETURN:  the intvec of n greatest primes <= 2147483647 (resp. n greatest primes
    676676         < L[size(L)] union with L) such that none of these primes divides any
    677          coefficient occuring in I
     677         coefficient occurring in I
    678678NOTE:    The number of cores to use can be defined by ncores, default is 1.
    679679EXAMPLE: example primeList; shows an example

  • Singular/LIB/modules.lib

    ra1b40a r3a0213  
    1515computed via the image, kernel, cokernel of a matrix or the subquotient of two matrices.
    1616The used matrices also have a free module as source and target, with graded generators if the
    17 matrix is homogenous. A matrix of this new form is created by a normal matrix, source, target and
    18 the graduatin, if the matrix is homogenous, are done automatically. With this matrices it is then
     17matrix is homogeneous. A matrix of this new form is created by a normal matrix, source, target and
     18the graduatin, if the matrix is homogeneous, are done automatically. With this matrices it is then
    1919possible to compute the new class of modules.
    2020This library also offers the opppurtunity to create R-module-homomorphisms betweens two modules.
    … …  
    3939zero(int n,int m)    return a nxm zero Matrix
    4040freeModule(ring,int,list)  creating a graded free module
    41 makeMatrix(matrix,#int)    creating a Matrix with graded target and source if the matrix is homogenous. If # is set to 1, makeMatrix ignores the grading of source & target.
     41makeMatrix(matrix,#int)    creating a Matrix with graded target and source if the matrix is homogeneous. If # is set to 1, makeMatrix ignores the grading of source & target.
    4242makeIdeal(ideal)    creates an Ideal from an given ideal, is used to compute a resolution of the ideal
    4343Target(Matrix)      return target of the Matrix
    … …  
    8383hom(Module,Module)      computes Hom(M,N)
    8484kerHom(Homomorphism)      computes the kernel of a Homomorphism
    85 interpret(Vector)      interpretes the Vector in some Module or abstract space
    86 interpretInv(def,Module)    interpretes a Vector or Homomorphism into the given Module
     85interpret(Vector)      interprets the Vector in some Module or abstract space
     86interpretInv(def,Module)    interprets a Vector or Homomorphism into the given Module
    8787reduceIntChain(Module,#int)    reduces a chain of interpretations to minimal size or # steps
    8888interpretElem(Vector,#int)    interpret a Vector with # steps or until can't interpret further
    … …  
    102102
    103103newstruct("FreeModule","int Rank,ring over,int isgraded,list grading");
    104 newstruct("Matrix","matrix hom, FreeModule source, FreeModule target, ring over,int ishomogenous");
     104newstruct("Matrix","matrix hom, FreeModule source, FreeModule target, ring over,int ishomogeneous");
    105105newstruct("Module","Matrix generators,Matrix relations,ring over,int isgraded, list grading, list interpretation");
    106106//interpretation is a list of two sublists: the first one gives the interpretation into another module M (entries are of type Vector), while the second denotes the inverse of this map (entries are of type vector, since the targetspace is clear).
    … …  
    222222  }
    223223  else{
    224   ERROR("Intput isn't a list or intvec");
     224  ERROR("Input isn't a list or intvec");
    225225  }
    226226}
    … …  
    325325static proc gradedMatrix(matrix m,list mydeg){
    326326Matrix M;
    327 M.ishomogenous=1;
     327M.ishomogeneous=1;
    328328M.over=basering;
    329329M.target = freeModule(basering,nrows(m),0);
    … …  
    340340list mydeg;
    341341Matrix M;
    342 M.ishomogenous=1;
     342M.ishomogeneous=1;
    343343M.over=basering;
    344344int a;
    … …  
    463463RETURN: Resolution, minimized resolution with graded modules
    464464NOTE: n is optional, if n ist positiv only that many steps will be computed
    465       use R.dd[i]; to return the diffrent modules as image of matrices, R Resolution i integer
     465      use R.dd[i]; to return the different modules as image of matrices, R Resolution i integer
    466466EXAMPLE. example mRes, shows an example"
    467467{
    … …  
    485485matrix a=R.reso[1];
    486486R.dd[1]=makeMatrix(a);
    487 if(!(R.dd[1].ishomogenous)){
     487if(!(R.dd[1].ishomogeneous)){
    488488  R.isgraded=0;
    489489  for(int i=2;i<=(size(R.reso)+1);i++){
    … …  
    525525RETURN: Resolution, with graded modules, computed with Schreyer's method using the function sres
    526526NOTE: n is optional, if n ist positiv only that many steps will be computed
    527       use R.dd[i]; to return the diffrent modules as image of matrices, R Resolution i integer
     527      use R.dd[i]; to return the different modules as image of matrices, R Resolution i integer
    528528EXAMPLE. example sRes, shows an example"
    529529{
    … …  
    547547matrix a=R.reso[1];
    548548R.dd[1]=makeMatrix(a);
    549 if(!(R.dd[1].ishomogenous)){
     549if(!(R.dd[1].ishomogeneous)){
    550550  R.isgraded=0;
    551551  for(int i=2;i<(size(R.reso)+1);i++){
    … …  
    587587RETURN: Resolution, resolution with graded modules
    588588NOTE: n is optional, if n ist positiv only that many steps will be computed
    589       use R.dd[i]; to return the diffrent modules as image of matrices, R Resolution i integer
     589      use R.dd[i]; to return the different modules as image of matrices, R Resolution i integer
    590590EXAMPLE. example Res, shows an example"
    591591{
    … …  
    609609matrix a=R.reso[1];
    610610R.dd[1]=makeMatrix(a);
    611 if(!(R.dd[1].ishomogenous)){
     611if(!(R.dd[1].ishomogeneous)){
    612612  R.isgraded=0;
    613613  for(int i=2;i<(size(R.reso)+1);i++){
    … …  
    648648RETURN: intmat, Bettimatrix of the resolution
    649649NOTE: for a clear overview use printBetti
    650 EXAMPLE: exaple Betti, shows an example"
     650EXAMPLE: example Betti, shows an example"
    651651{
    652652Matrix M;
    … …  
    719719proc makeMatrix(matrix m, int #)
    720720"USAGE:makeMatrix(m), m matrix
    721 RETURN Matrix, with graded source and target if the matrix is homogenous
    722 EXAMPLE: exmaple makeMatrix, shows an example"
     721RETURN Matrix, with graded source and target if the matrix is homogeneous
     722EXAMPLE: example makeMatrix, shows an example"
    723723{
    724724Matrix M;
    … …  
    744744static proc nongradedMatrix(matrix m){
    745745Matrix M;
    746 M.ishomogenous=0;
     746M.ishomogeneous=0;
    747747M.over=basering;
    748748M.target = freeModule(basering,nrows(m),-1);
    … …  
    827827setring(M.over);
    828828matrix m=M.hom;
    829 if(M.ishomogenous){
     829if(M.ishomogeneous){
    830830  string s1;
    831831  string s2;
    … …  
    921921Module S;
    922922S.isgraded=0;
    923 if(gens.ishomogenous){
     923if(gens.ishomogeneous){
    924924S.grading=gens.source.grading;
    925925S.isgraded=1;
    … …  
    10051005}
    10061006Module M;
    1007 if(rels.ishomogenous){M.isgraded=1;}
     1007if(rels.ishomogeneous){M.isgraded=1;}
    10081008else{M.isgraded=0;}
    10091009Matrix New = new;
    … …  
    22412241  if (typeof(V)=="Vector"){
    22422242    Module M = V.space;
    2243     //Check wheter there is a inverse interpretationlist:
     2243    //Check whether there is a inverse interpretationlist:
    22442244    if ((size(N.interpretation)!=0) && (size((N.interpretation)[2])!=0) && (((N.interpretation)[1][1]).space == M)) {
    22452245    // third condition checks whether the given modules are related
    … …  
    22562256      return(W);
    22572257    }
    2258     //If not, check wheter there exists an interpretationlist to N in the Module of V:
     2258    //If not, check whether there exists an interpretationlist to N in the Module of V:
    22592259    if ((size(M.interpretation)!=0) && (((M.interpretation)[1][1]).space == N)){return(interpret(V));}
    22602260    //If neither exist, can't interpretInv:
    … …  
    23962396static proc concMatrix(Matrix A,Matrix B)
    23972397"USAGE = concMatrix(A,B); A,B Matrix over the same ring
    2398 RETURN: concatinated Matrix with concatinated grading
     2398RETURN: concatenated Matrix with concatenated grading
    23992399EXAMPLE: example concMatrix; shows an example"
    24002400{

  • Singular/LIB/modwalk.lib

    ra1b40a r3a0213  
    33category = "Commutative Algebra";
    44info="
    5 LIBRARY:  modwalk.lib      Groebner basis convertion
     5LIBRARY:  modwalk.lib      Groebner basis conversion
    66
    77AUTHORS:  S. Oberfranz    oberfran@mathematik.uni-kl.de

  • Singular/LIB/mondromy.lib

    ra1b40a r3a0213  
    189189ASSUME:  U is a square matrix with non zero determinant.
    190190RETURN:  The procedure returns a list with at most 2 entries.
    191          If U is not a sqaure matrix, the list is empty.
    192          If U is a sqaure matrix, then the first entry is the determinant of U.
     191         If U is not a square matrix, the list is empty.
     192         If U is a square matrix, then the first entry is the determinant of U.
    193193         If U is a square matrix and the determinant of U not zero,
    194194         then the second entry is the adjoint matrix of U.

  • Singular/LIB/monomialideal.lib

    ra1b40a r3a0213  
    763763//  intvec exp;
    764764//  int nvar = nvars(basering);
    765 //  // intput: monomials
     765//  // input: monomials
    766766//
    767767//  intvec expf = leadexp(f);
    … …  
    36433643          - the formula of irreducible components (alg=for),
    36443644          - via the Scarf complex following Milowski (alg=mil),
    3645           - using the label algorihtm of Roune (alg=lr),
     3645          - using the label algorithm of Roune (alg=lr),
    36463646          - using the algorithm of Gao-Zhu (alg=gz).
    36473647          - using the slice algorithm of Roune (alg=sr).
    … …  
    37393739          (returns -1 if I is not a monomial ideal).
    37403740ASSUME:   I is a monomial ideal of the basering k[x(1)..x(n)].
    3741 NOTE:     This procesure returns a minimal primary decomposition of I.
     3741NOTE:     This procedure returns a minimal primary decomposition of I.
    37423742          One may call the procedure with different algorithms using
    37433743          the optional argument 'alg':
    … …  
    37553755            complex following Milowski (alg=mil),
    37563756          - from the irreducible decomposition obtained using the label
    3757             algorihtm of Roune (alg=lr),
     3757            algorithm of Roune (alg=lr),
    37583758          - from the irreducible decomposition obtained using the
    37593759            algorithm of Gao-Zhu (alg=gz),

  • Singular/LIB/mprimdec.lib

    ra1b40a r3a0213  
    1212 Shimoyama and Yokoyama (generalization of the latter
    1313 suggested by Hans-Gert Graebe, Leipzig  )
    14  using elments of primdec.lib
     14 using elements of primdec.lib
    1515
    1616REMARK:
    … …  
    3737  primTest(i[,p]);             tests whether i is prime or homogeneous
    3838  preComp(N,check[,ann]);      enhanced Version of splitting
    39   indSet(i);                   lists with varstrings of(in)dependend variables
     39  indSet(i);                   lists with varstrings of(in)dependent variables
    4040  GTZopt(N[,check[,ann]]);     a faster version of GTZmod
    4141  zeroOpt(N[,check[,ann]]);    a faster version of zeroMod
    … …  
    115115// using a generalization of the algorithm of Shimoyama/Yokoyama,
    116116// suggested by Hans-Gerd Graebe, Leipzig
    117 // [Hans-Gert Graebe, Minimal Primary Decompostion
     117// [Hans-Gert Graebe, Minimal Primary Decomposition
    118118//  and Factorized Groebner Bases, AAECC 8, 265-278 (1997)]
    119119/////////////////////////////////////////////////////////////////////////////
    … …  
    12601260
    12611261  ////////////////////////////////////////////////////////////////
    1262   // the modules which are not primary are splitted
     1262  // the modules which are not primary are split
    12631263  ////////////////////////////////////////////////////////////////
    12641264  list splitTemp;
    … …  
    16621662/////////////////////////////////////////////////////////////////////////////
    16631663// dec1var(N[,check[, ann]])
    1664 // primary decompostion for a ring with one variable
     1664// primary decomposition for a ring with one variable
    16651665/////////////////////////////////////////////////////////////////////////////
    16661666

  • Singular/LIB/mregular.lib

    ra1b40a r3a0213  
    391391//----- Now d>1 and S/i is not Cohen-Macaulay:
    392392//
    393 //----- First, determine the last variable really occuring
     393//----- First, determine the last variable really occurring
    394394   lastv=n-d;
    395395   h=n;
    … …  
    890890//----- Now d>1 and S/i is not Cohen-Macaulay:
    891891//
    892 //----- First, determine the last variable really occuring
     892//----- First, determine the last variable really occurring
    893893       lastv=n-d;
    894894       h=n;
    … …  
    12161216//----- Now d>1 and S/i is not Cohen-Macaulay:
    12171217//
    1218 //----- First, determine the last variable really occuring
     1218//----- First, determine the last variable really occurring
    12191219       lastv=n-d;
    12201220       h=n;
    … …  
    18181818       return (1);
    18191819     }
    1820 //----- Determ. of the last variable really occuring
     1820//----- Determ. of the last variable really occurring
    18211821   lastv=n-d;
    18221822   h=n;

  • Singular/LIB/multigrading.lib

    ra1b40a r3a0213  
    3333
    3434createGroup(S,L);          create a group generated by S, with relations L
    35 createQuotientGroup(L);    create a group generated by the unit matrix whith relations L
     35createQuotientGroup(L);    create a group generated by the unit matrix with relations L
    3636createTorsionFreeGroup(S); create a group generated by S which is torsionfree
    3737printGroup(G);             print a group
    3838
    3939isGroup(G);                   test whether G is a valid group
    40 isGroupHomomorphism(L1,L2,A); test wheter A defines a group homomrphism from L1 to L2
     40isGroupHomomorphism(L1,L2,A); test whether A defines a group homomrphism from L1 to L2
    4141
    4242isGradedRingHomomorphism(R,f,A);  test graded ring homomorph
    … …  
    638638  if( !isHomogeneous(Q, "checkGens") ) // easy now, but would be hard before setting ring attributes!
    639639  {
    640     "Warning: your quotient ideal is not homogenous (multigrading was set anyway)!";
     640    "Warning: your quotient ideal is not homogeneous (multigrading was set anyway)!";
    641641  }
    642642
    … …  
    23352335  if( size(exp1) != size(exp2) )
    23362336  {
    2337     ERROR("Sorry: we cannot compare exponents comming from a polynomial and a vector yet!");
     2337    ERROR("Sorry: we cannot compare exponents coming from a polynomial and a vector yet!");
    23382338  }
    23392339
    … …  
    31813181
    31823182
    3183    j=system("sh",s_name+" -q sing4ti2 >/dev/null 2>&1"); ////////// be quiet + no loggin!!!
     3183   j=system("sh",s_name+" -q sing4ti2 >/dev/null 2>&1"); ////////// be quiet + no logging!!!
    31843184
    31853185   j=system("sh", "awk \'BEGIN{ORS=\",\";}{print $0;}\' sing4ti2.hil " +
    … …  
    47754775
    47764776  // should result in a matrix whose
    4777   // colums create the same  lattice as
     4777  // columns create the same  lattice as
    47784778  // [0,1],[1,0]
    47794779  intmat D = latticeBasis(C);
    … …  
    48564856
    48574857  // should result in a matrix whose
    4858   // colums create the same  lattice as
     4858  // columns create the same  lattice as
    48594859  // [-2,-2,1,0], [0,0,0,1]
    48604860  intmat D = kernelLattice(C);
    … …  
    51935193  else
    51945194  {
    5195     // delte columns from r+1 onwards
     5195    // delete columns from r+1 onwards
    51965196    intmat Cutdel[nrows(Cut)][r];
    51975197
    … …  
    54445444
    54455445  // check whether H is a subgroup of G, i.e. whether S2 is a sublattice of S1+L1
    5446   intmat B = concatintmat(S1,L1); // check whether this gives the concatinated matrix
     5446  intmat B = concatintmat(S1,L1); // check whether this gives the concatenated matrix
    54475447  if ( !isSublattice(S2,B) )
    54485448  {
    … …  
    54505450  }
    54515451  // use first isomorphism thm to get the factor group
    5452   intmat L = concatintmat(L1,S2); // check whether this gives the concatinated matrix
     5452  intmat L = concatintmat(L1,S2); // check whether this gives the concatenated matrix
    54535453  list GmodH;
    54545454  GmodH[1]=S1;

  • Singular/LIB/ncModslimgb.lib

    ra1b40a r3a0213  
    119119
    120120  //PrimeList procedure selects suitable primes such that
    121   //these primes do not divide coefficients occuring
     121  //these primes do not divide coefficients occurring
    122122  //in the generating polynomials of input ideal and
    123123  //in the defining relations of input algebra

  • Singular/LIB/ncfactor.lib

    ra1b40a r3a0213  
    1414@* automatically in the procedure ncfactor().
    1515
    16 @* More detailled description of the algorithms and related publications can be found at
     16@* More detailed description of the algorithms and related publications can be found at
    1717@url{https://cs.uwaterloo.ca/\~aheinle/}.
    1818
    … …  
    691691  }//g was the empty list
    692692  if (nof <= 0)
    693   {//The user wants to recieve a negative number or no element as a result
     693  {//The user wants to receive a negative number or no element as a result
    694694    return(result);
    695   }//The user wants to recieve a negative number or no element as a result
     695  }//The user wants to receive a negative number or no element as a result
    696696  if (nofgl == nof)
    697697  {//There are no factors to combine
    … …  
    13611361    result = 0;
    13621362  }
    1363   //Test 3: Intvec with arbitarily many elements
     1363  //Test 3: Intvec with arbitrarily many elements
    13641364  input= intvec(6,4,7,1,24);
    13651365  expected = list(6,4,7,1,24);
    … …  
    15591559  {
    15601560    ERROR("pmax and pmin shall have the same size, and maxDegrees
    1561     shall be double the size of both. Furhtermore, it must hold that pmax>pmin. The
     1561    shall be double the size of both. Furthermore, it must hold that pmax>pmin. The
    15621562    Input was: " + string(pmax) + ", " + string(pmin) + ", " + string(maxDegrees));
    15631563  }
    … …  
    17731773  {
    17741774    ERROR("pmax and pmin shall have the same size, and maxDegrees
    1775     shall be double the size of both. Furhtermore, it must hold that pmax>pmin. The
     1775    shall be double the size of both. Furthermore, it must hold that pmax>pmin. The
    17761776    Input was: " + string(pmax) + ", " + string(pmin) + ", " + string(maxDegrees));
    17771777  }
    … …  
    49264926{//testing sortedInsert
    49274927  int result = 1;
    4928   //Test 1: empty list to insert into emtpy list
     4928  //Test 1: empty list to insert into empty list
    49294929  ring R = 0,(x,d),dp;
    49304930  def r = nc_algebra(1,1);
    … …  
    61146114      {
    61156115        if (the_vars[j]*the_vars[i]-the_vars[i]*the_vars[j]==1)
    6116         {//In this case, we matched a var x to a repective d
     6116        {//In this case, we matched a var x to a respective d
    61176117          tempVariable = the_vars[i + size(the_vars) div 2];
    61186118          the_vars[i + size(the_vars) div 2] = the_vars[j];
    61196119          the_vars[j] = tempVariable;
    61206120          break;
    6121         }//In this case, we matched a var x to a repective d
     6121        }//In this case, we matched a var x to a respective d
    61226122        if (the_vars[i]*the_vars[j]-the_vars[j]*the_vars[i]==1)
    61236123        {//In this case, x and d were wrongly positioned
    … …  
    83878387  dbprint(p,dbprintWhitespace + "Done. The Combinations are:");
    83888388  dbprint(p,coeffTuplesMin);
    8389   //Now, we will be actally dealing with the Combinations.
     8389  //Now, we will be actually dealing with the Combinations.
    83908390  //Let's start with the pqmax
    83918391  if (size(f1[1]) == 1)
    … …  
    1171111711  list listToPermute = list();
    1171211712  for (i = 1;i<=nvars(r);i++)
    11713   {//filling an inital list
     11713  {//filling an initial list
    1171411714    for(j=1; j<=expVec[i];j++)
    1171511715    {//different powers of the respective variable at position i
    1171611716      listToPermute = listToPermute + list(var(i));
    1171711717    }//different powers of the respective variable at position i
    11718   }//filling an inital list
     11718  }//filling an initial list
    1171911719  dbprint(p,dbprintWhitespace + "Initial list to permute is "+
    1172011720  string(listToPermute));
    … …  
    1251312513  list M;
    1251412514  for (i = 1; i<size(expVec); i++)
    12515   {//The set M consists of all posssible two-word-combinations of the leading monomial
     12515  {//The set M consists of all possible two-word-combinations of the leading monomial
    1251612516    M = M + list(list(intvec(expVec[1..i]), intvec(expVec[i+1..size(expVec)])));
    1251712517  }

  • Singular/LIB/ncrat.lib

    ra1b40a r3a0213  
    2121   rational functions; formal linear representations; minimal representations
    2222
    23 NOTE: an almost self-explaining introduction to the posibilities of the framework
     23NOTE: an almost self-explaining introduction to the possibilities of the framework
    2424can be achieved by running the example for the procedure ncrepGetRegularMinimal.
    2525
    … …  
    3030  ncratDefine();                Define element of type ncrat
    3131  ncratAdd();                   Addition of two ncrat's
    32   ncratSubstract();             Substraction of two ncrat's
     32  ncratSubstract();             Subtraction of two ncrat's
    3333  ncratMultiply();              Multiplication of two ncrat's
    3434  ncratInvert();                Invert an ncrat
    … …  
    4141  ncrepGet();                   Calculate representation of ncrat
    4242  ncrepAdd();                   Addition of two ncrep's
    43   ncrepSubstract();             Substraction of two ncrep's
     43  ncrepSubstract();             Subtraction of two ncrep's
    4444  ncrepMultiply();              Multiplication of two ncrep's
    4545  ncrepInvert();                Invert an ncrep
    … …  
    918918/*
    919919  list # = (x1, ..., xg) contains the nc variables
    920   occuring in g
     920  occurring in g
    921921  return list(Q0, Q1,... Qg) with scalar matrices Qi s.t.
    922922    Q = Q0 + Q1*x1 + ... + Qg*xg
    … …  
    967967  n - dimension
    968968  q - REGULAR ncrep
    969   # - contains occuring ncvariables as 'poly'
     969  # - contains occurring ncvariables as 'poly'
    970970  Returns list(B, C, l) with l = list(A1, ..., Ag) such that
    971971  -u*Q^-1*v = C * (1 - A1*x1 - ... - Ag*xg)^-1 * B.
    … …  
    11611161
    11621162// INPUT: list containing basis vectors
    1163 // OUTPUT: orthogonal matrix, whose colums span the same space
     1163// OUTPUT: orthogonal matrix, whose columns span the same space
    11641164static proc orthogonalBase(list b)
    11651165{
    … …  
    13391339        ("Var",   [string])           variable
    13401340        ("Add",   [ncrat, ncrat])     addition
    1341         ("Sub",   [ncrat, ncrat])     substraction
     1341        ("Sub",   [ncrat, ncrat])     sustraction
    13421342        ("Mult",  [ncrat, ncrat])     multiplication
    13431343        ("Inv",   [ncrat])            inverse
    … …  
    25342534RETURN:     pencil = list(vars, matrices),
    25352535  where vars = list(1, x1, ..., xg) are the variables
    2536   occuring in r and matrices = (Q0, ..., Qg) is a list of
     2536  occurring in r and matrices = (Q0, ..., Qg) is a list of
    25372537  matrices such that
    25382538    r.mat = Q0 * x0 + ... + Qg * xg
    … …  
    25402540
    25412541NOTE:       list vars = list(x1, ..., xn) has to consist
    2542   exactly of the nc variables occuring in f
     2542  exactly of the nc variables occurring in f
    25432543
    25442544EXAMPLE:    example ncrepPencilGet;
    … …  
    26162616
    26172617NOTE:       list l = list(x1, ..., xn) has to consist
    2618   exactly of the nc variables occuring in q
     2618  exactly of the nc variables occurring in q
    26192619
    26202620EXAMPLE:    example ncrepRegularZeroMinimize;
    … …  
    26962696
    26972697NOTE:       list vars = list(x1, ..., xn) has to consist
    2698   exactly of the nc variables occuring in q and
     2698  exactly of the nc variables occurring in q and
    26992699  list point = list(a1, ..., an) consists of scalars
    27002700
    … …  
    27702770
    27712771NOTE:       list vars = list(x1, ..., xn) has to consist
    2772   exactly of the nc variables occuring in f
     2772  exactly of the nc variables occurring in f
    27732773
    27742774EXAMPLE:    example ncrepGetRegularZeroMinimal;
    … …  
    28002800
    28012801NOTE:       list vars = list(x1, ..., xn) has to consist
    2802   exactly of the nc variables occuring in f and
     2802  exactly of the nc variables occurring in f and
    28032803  list point = (p1, ..., pn) of scalars such that
    28042804  f(point) is defined
Note: See TracChangeset for help on using the changeset viewer.