Changeset d2b2a7 in git for Singular/LIB/presolve.lib


Ignore:
Timestamp:
May 5, 1998, 1:55:40 PM (26 years ago)
Author:
Kai Krüger <krueger@…>
Branches:
(u'spielwiese', '873fc1222e995d7cb33f79d8f1792ce418c8c72c')
Children:
97f92aa6d280f6022eaae47195ccc02503ccb984
Parents:
4996f5286c7671191ad22e654499fd8b752fe4f0
Message:
Modified Files:
	libparse.l utils.cc LIB/classify.lib LIB/deform.lib
	LIB/elim.lib LIB/factor.lib LIB/fastsolv.lib LIB/finvar.lib
	LIB/general.lib LIB/hnoether.lib LIB/homolog.lib LIB/inout.lib
	LIB/invar.lib LIB/makedbm.lib LIB/matrix.lib LIB/normal.lib
	LIB/poly.lib LIB/presolve.lib LIB/primdec.lib LIB/primitiv.lib
	LIB/random.lib LIB/ring.lib LIB/sing.lib LIB/standard.lib
	LIB/tex.lib LIB/tst.lib
Changed help section o procedures to have an quoted help-string between
proc-definition and proc-body.


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

Legend:

Unmodified
Added
Removed

  • Singular/LIB/presolve.lib

    r4996f52 rd2b2a7  
    1 // $Id: presolve.lib,v 1.3 1998-04-03 22:47:10 krueger Exp $
     1// $Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $
    22//system("random",787422842);
    33//(GMG), last modified 97/10/07 by GMG
    44///////////////////////////////////////////////////////////////////////////////
    55
    6 version="$Id: presolve.lib,v 1.3 1998-04-03 22:47:10 krueger Exp $";
     6version="$Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $";
    77info="
    88LIBRARY:  presolve.lib     PROCEDURES FOR PRE-SOLVING POLYNOMIAL EQUATIONS
    … …  
    3232
    3333proc degreepart (id,int d1,int d2,list #)
    34 USAGE:   degreepart(id,d1,d2[,v]);  id=ideal/module, d1,d1=integers, v=intvec
     34"USAGE:   degreepart(id,d1,d2[,v]);  id=ideal/module, d1,d1=integers, v=intvec
    3535RETURN:  generators of id of [v-weighted] total degree >= d1 and <= d2
    3636         (default: v = 1,...,1)
    3737EXAMPLE: example degreepart; shows an example
     38"
    3839{
    3940   def dpart = id;
    … …  
    6768
    6869proc elimlinearpart (ideal i,list #)
    69 USAGE:   elimlinearpart(i[,n]);  i=ideal, n=integer
     70"USAGE:   elimlinearpart(i[,n]);  i=ideal, n=integer
    7071RETURN:  list of of 5 objects:
    7172         [1]: (interreduced) ideal obtained from i by eliminating (sbstituting)
    … …  
    8283         // bei ** spaeter eventuell verbessern
    8384EXAMPLE: example elimlinearpart; shows an example
     85"
    8486{
    8587   int ii,n,fi,k;
    … …  
    171173
    172174proc elimpart (ideal i,list #)
    173 USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers
     175"USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers
    174176         consider 1-st n vars for elimination (better: substitution),
    175177         e =0: substitute from linear part of i (same as elimlinearpart)
    … …  
    191193         since it avoids internal ring change and mapping
    192194EXAMPLE: example elimpart; shows an example
     195"
    193196{
    194197   def P = basering;
    … …  
    315318
    316319proc elimpartanyr (ideal i, list #)
    317 USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated,
     320"USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated,
    318321         e=int (default: p=product of all vars, e=1)
    319322RETURN:  list of of 6 objects:
    … …  
    334337         placed correctly and then applies 'elimpart';
    335338EXAMPLE: example elimpartanyr; shows an example
     339"
    336340{
    337341   def P = basering;
    … …  
    367371 
    368372proc fastelim (ideal i, poly p, list #)
    369 USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be
     373"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be
    370374         eliminated; h,o,a,b,e integers
    371375         (options for Hilbert-std, 'valvars', elimpart, minimizing)
    … …  
    380384RETURN:  ideal obtained from i by eliminating those variables which occur in p
    381385EXAMPLE: example fastelim; shows an example.
     386"
    382387{
    383388   def P = basering;
    … …  
    455460
    456461proc faststd (@id,string @s1,string @s2, list #)
    457 USAGE:   faststd(id,s1,s2[,"hilb","sort","dec",o,"blocks"]);
     462"USAGE:   faststd(id,s1,s2[,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]);
    458463         id=ideal/module, s1,s2=strings (names for new ring and maped id)
    459          o = string (allowed ordstring:"lp","dp","Dp","ls","ds","Ds")
    460          "hilb","sort","dec","block" options for Hilbert-std, sortandmap
    461 COMPUTE: create a new ring (with "best" ordering of vars) and compute a
     464         o = string (allowed ordstring:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\")
     465         \"hilb\",\"sort\",\"dec\",\"block\" options for Hilbert-std, sortandmap
     466COMPUTE: create a new ring (with \"best\" ordering of vars) and compute a
    462467         std-basis of id (hopefully faster)
    463          - If say, s1="R" and s2="j", the new basering has name R and the
     468         - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the
    464469           std-basis of the image of id in R has name j
    465          - "hilb"  : use Hilbert-series driven std-basis computation
    466          - "sort"  : use 'sortandmap' for a best ordering of vars
    467          - "dec"   : order vars w.r.t. decreasing complexity (with "sort")
    468          - "block" : create blockordering, each block having ordstr=o, s.t.
    469                      vars of same complexity are in one block (with "sort")
     470         - \"hilb\"  : use Hilbert-series driven std-basis computation
     471         - \"sort\"  : use 'sortandmap' for a best ordering of vars
     472         - \"dec\"   : order vars w.r.t. decreasing complexity (with \"sort\")
     473         - \"block\" : create blockordering, each block having ordstr=o, s.t.
     474                     vars of same complexity are in one block (with \"sort\")
    470475         - o       : defines the basic ordering of the resulting ring
    471476         default: o = ordering of 1-st block of basering - if it is allowed,
    472                       else o="dp",
    473                   "sort", if none of the optional parameters is given
     477                      else o=\"dp\",
     478                  \"sort\", if none of the optional parameters is given
    474479RETURN:  nothing
    475480NOTE:    This proc is only useful for hard problems where other methods fail.
    476          "hilb" is useful for hard orderings (as "lp") or for characteristic 0,
    477          it is correct for "lp","dp","Dp" (and for blockorderings combining
     481         \"hilb\" is useful for hard orderings (as \"lp\") or for characteristic 0,
     482         it is correct for \"lp\",\"dp\",\"Dp\" (and for blockorderings combining
    478483         these) but not for s-orderings or if the vars have different weights.
    479          There seem to be only few cases in which "dec" is fast
     484         There seem to be only few cases in which \"dec\" is fast
    480485EXAMPLE: example faststd; shows an example.
     486"
    481487{
    482488   def @P = basering;
    … …  
    624630
    625631proc findvars(id, list #)
    626 USAGE:   findvars(id[,any]); id poly/ideal/vector/module/matrix, any=any type
     632"USAGE:   findvars(id[,any]); id poly/ideal/vector/module/matrix, any=any type
    627633RETURN:  ideal of variables occuring in id, if no second argument is present
    628634         list of 4 objects, if a second argument is given (of any type)
    … …  
    632638         -[4]: intvec of variables not occuring in id
    633639EXAMPLE: example findvars; shows an example
     640"
    634641{
    635642   int ii,n;
    … …  
    670677
    671678proc hilbvec (@id, list #)
    672 USAGE:   hilbvec(id[,c,o]); id poly/ideal/vector/module/matrix, c,o=strings
    673          c=char, o=ord in which hilb is computed (default: c="32003", o="dp")
     679"USAGE:   hilbvec(id[,c,o]); id poly/ideal/vector/module/matrix, c,o=strings
     680         c=char, o=ord in which hilb is computed (default: c=\"32003\", o=\"dp\")
    674681RETURN:  intvec of 1-st Hilbert-series of id, computed in char c and ordering o
    675682         bei ** aendern falls ringmaps vollstaendig ?
    676683NOTE:    id must be homogeneous (all vars having weight 1)
    677684EXAMPLE: example hilbvec; shows an example
     685"
    678686{
    679687   def @P = basering;
    … …  
    701709
    702710proc linearpart (id)
    703 USAGE:   linearpart(id);  id=ideal/module
     711"USAGE:   linearpart(id);  id=ideal/module
    704712RETURN:  generators of id of total degree <= 1
    705713EXAMPLE: example linearpart; shows an example
     714"
    706715{
    707716   return(degreepart(id,0,1));
    … …  
    718727
    719728proc tolessvars (id ,list #)
    720 USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix,
     729"USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix,
    721730         s1,s2=strings (names of: new ring, new ordering)
    722731CREATE:  nothing, if id contains all vars of the basering. Else, create
    … …  
    725734         new ring, which will be the basering after the proc has finished.
    726735         The name of the new ring is by default R(n), where n is the number of
    727          variables in the new ring. If, say, s1 = "newR" then the new ring has
     736         variables in the new ring. If, say, s1 = \"newR\" then the new ring has
    728737         name newR. In s2 a different ordering for the new ring may be given
    729          as an allowed ordstring (default is "dp" resp. "ds", depending whether
     738         as an allowed ordstring (default is \"dp\" resp. \"ds\", depending whether
    730739         the first block of the old ordering is a p- resp. an s-ordering).
    731740DISPLAY: If printlevel >=0, display ideal of vars which have been ommitted from
    … …  
    739748         occurs in the old ring, for the same reason.
    740749EXAMPLE: example tolessvars; shows an example
     750"
    741751{
    742752//---------------- initialisation and check occurence of vars -----------------
    … …  
    796806
    797807proc solvelinearpart (id,list #)
    798 USAGE:   solvelinearpart(id[,n]);  id=ideal/module, n=integer
     808"USAGE:   solvelinearpart(id[,n]);  id=ideal/module, n=integer
    799809RETURN:  (interreduced) generators of id of degree <=1 in reduced triangular
    800810         form  (default) or if n=0 [non-reduced triangular form if n!=0]
    … …  
    805815         char 0 instead!
    806816EXAMPLE: example solvelinearpart; shows an example
     817"
    807818{
    808819   intvec getoption = option(get);
    … …  
    855866
    856867proc sortandmap (@id,string @s1,string @s2, list #)
    857 USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);
     868"USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);
    858869         id=poly/ideal/vector/module
    859870         s1,s2=strings (names for new ring and maped id)
    860871         p1,p2,...= product of vars, n1,n2,...=integers
    861872         o1,o2,...= allowed ordstrings, m1,m2,...=integers
    862          (default: p1=product of all vars, n1=0, o1="dp",m1=0)
     873         (default: p1=product of all vars, n1=0, o1=\"dp\",m1=0)
    863874         the last pi (containing the remaining vars) may be omitted
    864875CREATE:  a new ring and map id into it, the new ring has same char as basering
    … …  
    867878           id, ni controls the sorting in i-th block (= vars occuring in pi):
    868879           ni=0 (resp.!=0) means that less (resp. more) complex vars come first
    869          - If say, s1="R" and s2="j", the new basering has name R and the image
     880         - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the image
    870881           of id in R has name j
    871882         - oi and mi define the monomial ordering of the i-th block:
    … …  
    874885           each subblock having ordstr=oi, such that vars of same complexity
    875886           are in one block
    876            default: oi="dp", mi=0
    877          - only simple ordstrings oi are allowed:"lp","dp","Dp","ls","ds","Ds"
     887           default: oi=\"dp\", mi=0
     888         - only simple ordstrings oi are allowed:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\"
    878889RETURN:  nothing
    879890NOTE:    We define a variable x to be more complex than y (with respect to id)
    … …  
    884895          # of monomials in coefficient of next smaller power of x,...)
    885896EXAMPLE: example sortandmap; shows an example
     897"
    886898{
    887899   def @P = basering;
    … …  
    948960
    949961proc sortvars (id, list #)
    950 USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
     962"USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
    951963         p1,p2,...= product of vars, n1,n2,...=integers
    952964         (default: p1=product of all vars, n1=0)
    … …  
    972984          # of monomials in coefficient of next smaller power of x,...)
    973985EXAMPLE: example sortvars; shows an example
     986"
    974987{
    975988   int ii,jj,n,s;
    … …  
    10091022
    10101023proc valvars (id, list #)
    1011 USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
     1024"USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
    10121025         p1,p2,...= product of vars, n1,n2,...=integers
    10131026         ni controls the ordering of vars occuring in pi:
    … …  
    10321045          # of monomials in coefficient of next smaller power of x,...)
    10331046EXAMPLE: example valvars; shows an example
     1047"
    10341048{
    10351049//---------------------------- initialization ---------------------------------
Note: See TracChangeset for help on using the changeset viewer.