This package provides a very basic interface to the polymake program by Ewgenij Gawrilow, Michael Joswig et al. [GJ]. The polymake program itself is not included.
This package is distributed under the terms of the GNU General Public License version 2 or later (at your convenience). See the file "LICENSE" or https://www.gnu.org/copyleft/gpl.html
Acknowledgements
This work has been supported by Marie Curie Grant No. MTKD-CT-2006-042685
The interaction with the polymake program is done via files. A PolymakeObject is mainly a pointer to a file and a list of known properties of the object. These properties need not be stored in the file. Whenever polymake is called, the returned value is read from standard output and stored in the PolymakeObject corresponding to the file for which polymake is called. The files for polymake are written in the old (non-xml) format. The first run of polymake converts them into the new (xml) format. This means that changes to the file by means of the methods outlined below after the first run of polymake will probably lead to corrupted files.
2.1-1 CreateEmptyFile
‣ CreateEmptyFile( filename )
( method )
Returns: nothing
Creates an empty file with name filename. Note that filename has to include the full path and the directory for the file must exist.
2.1-2 CreatePolymakeObject
‣ CreatePolymakeObject( )
( method )
‣ CreatePolymakeObject( appvertyp )
( method )
‣ CreatePolymakeObject( dir )
( method )
‣ CreatePolymakeObject( dir, appvertyp )
( method )
‣ CreatePolymakeObject( prefix, dir )
( method )
‣ CreatePolymakeObject( prefix, dir, appvertyp )
( method )
Returns: PolymakeObject
If called without arguments, this method generates an empty file in the directory defined by POLYMAKE_DATA_DIR (3.2-2). If a directory dir is given (this directory must exist), an empty file is generated in this directory. If prefix is not given, the file is called polyN where N is the current runtime. If a file of this name already exists, a number is appended separated by a dot (example: "poly1340" and "poly1340.1"). If prefix is given, the filename starts with this prefix. Optionally, the file can be generated with a header specifying application, version and type of the object. This is done by passing the triple of strings appvertyp to CreatePolymakeObject. A valid triple is ["polytope","2.3","RationalPolytope"]. Validity is checked by CheckAppVerTypList (2.1-3).
2.1-3 CheckAppVerTypList
‣ CheckAppVerTypList( appvertyp )
( method )
Returns: bool
Checks if the triple arppvertyp of strings specifies an application and type of polymake version 2.3. More specifically, the first entry has to be an application from ["polytope","surface","topaz"] and the third entry has to be a type corresponding to the application given in the first entry. The second entry is not checked.
2.1-4 CreatePolymakeObjectFromFile
‣ CreatePolymakeObjectFromFile( filename )
( method )
‣ CreatePolymakeObjectFromFile( dir, filename )
( method )
Returns: PolymakeObject
This method generates a PolymakeObject corresponding to the file filename in the directory dir. If dir is not given, the POLYMAKE_DATA_DIR is used.If no file with name filename exists in dir (or POLYMAKE_DATA_DIR, respectively), an empty file is created. Note that the contents of the file do not matter for the generation of the object. In particular, the object does not know any of the properties that might be encoded in the file. The only way to transfer information from files to PolymakeObjects is via Polymake (2.5-1).
2.2 Accessing Properties of Polymake Objects
A PolymakeObject contains information about the directory of its file, the name of its file and about properties calculated by calling Polymake (2.5-1). The properties returned by the polymake program are stored under the name polymake assigns to them (that is, the name of the data block in the corresponding file). The following methods can be used to access the information stored in a PolymakeObject. But be careful! All functions return the actual object. No copies are made. So if you change one of the returned objects, you change the PolymakeObject itself.
2.2-1 DirectoryOfPolymakeObject
‣ DirectoryOfPolymakeObject( poly )
( method )
Returns: Directory
Returns the directory of the file associated with poly.
2.2-2 FilenameOfPolymakeObject
‣ FilenameOfPolymakeObject( poly )
( method )
Returns: String
Returns the name of the file associated with poly. This does only mean the name of the file, not the full path. For the full path and file name see FullFilenameOfPolymakeObject (2.2-3)
2.2-3 FullFilenameOfPolymakeObject
‣ FullFilenameOfPolymakeObject( poly )
( method )
Returns: String
Returns the file associated with the PolymakeObjectpoly with its complete path.
2.2-4 NamesKnownPropertiesOfPolymakeObject
‣ NamesKnownPropertiesOfPolymakeObject( poly )
( method )
Returns: List of Strings
Returns a list of the names of all known properties. This does only include the properties returned by Polymake (2.5-1), "dir" and "filename" are not included. If no properties are known, fail is returned.
2.2-5 KnownPropertiesOfPolymakeObject
‣ KnownPropertiesOfPolymakeObject( poly )
( method )
Returns: Record
Returns the record of all known properties. If no properties are known, fail is returned.
2.2-6 PropertyOfPolymakeObject
‣ PropertyOfPolymakeObject( poly, name )
( method )
Returns the value of the property name if it is known. If the value is not known, fail is returned. name must be a String.
2.3 Example: Creating and Accessing Polymake Objects
Suppose the file /tmp/threecube.poly contains the three dimensional cube in polymake form. Now generate a PolymakeObject from this file and call Polymake (2.5-1) to make the vertices of the cube known to the object.
To transfer data from GAP to polymake, the following methods can be used. But bear in mind that none of these functions test if the resulting polymake file is still consistent.
2.4-1 AppendToPolymakeObject
‣ AppendToPolymakeObject( poly, string )
( method )
Returns: nothing
This appends the string string to the file associated to the PolymakeObjectpoly. It is not tested if the string is syntactically correct as a part of a polymake file. It is also not tested if the string is compatible with the data already contained in the file.
INEQUALITIES, POINTS and VERTICES can be appended to a polymake object using the following functions:
Takes a list pointlist of vectors and converts it into a string which represents a polymake block labeled "POINTS". This string is then added to the file associated with poly. The "POINTS" block of the file associated with poly then contains points with leading ones, as polymake uses affine notation.
Just appends the inequalities given in ineqlist to the polymake object poly (with caption "INEQUALITIES"). Note that this does not check if an "INEQUALITIES" section does already exist in the file associated with poly.
2.4-5 ConvertMatrixToPolymakeString
‣ ConvertMatrixToPolymakeString( name, matrix )
( method )
Returns: String
This function takes a matrix matrix and converts it to a string. This string can then be appended to a polymake file via AppendToPolymakeObject (2.4-1) to form a block of data labeled name. This may be used to write blocks like INEQUALITIES or FACETS.
2.4-6 ClearPolymakeObject
‣ ClearPolymakeObject( poly )
( method )
‣ ClearPolymakeObject( poly, appvertyp )
( method )
Returns: nothing
Deletes all known properties of the PolymakeObjectpoly and replaces its file with an empty one. If the triple of strings appvertyp specifying application, version and type (see CheckAppVerTypList (2.1-3)) is given, the file is replaced with a file that contains only a header specifying application, version and type of the polymake object.
There are also methods to manipulate the known values without touching the file of the PolymakeObject:
2.4-7 WriteKnownPropertyToPolymakeObject
‣ WriteKnownPropertyToPolymakeObject( poly, name, data )
( method )
Takes the object data and writes it to the known properties section of the PolymakeObjectpoly. The string name is used as the name of the property. If a property with that name already exists, it is overwritten. Again, there is no check if data is consistent, correct or meaningful.
2.4-8 UnbindKnownPropertyOfPolymakeObject
‣ UnbindKnownPropertyOfPolymakeObject( poly, name )
( method )
If the PolymakeObjectpoly has a property with name name, that property is unbound. If there is no such property, fail is returned.
2.5 Calling Polymake and converting its output
2.5-1 Polymake
‣ Polymake( poly, option:PolymakeNolookup )
( method )
This method calls the polymake program (see POLYMAKE_COMMAND (3.2-1)) with the option option. You may use several keywords such as "FACETS VERTICES" as an option. The returned value is cut into blocks starting with keywords (which are taken from output and not looked up in option). Each block is then interpreted and translated into GAP readable form. This translation is done using the functions given in ObjectConverters (4.1-4). The first line of each block of polymake output is taken as a keyword and the according entry in ObjectConverters (4.1-4) is called to convert the block into GAP readable form. If no conversion function is known, an info string is printed and fail is returned. If only one keyword has been given as option, Polymake returns the result of the conversion operation. If more than one keyword has been given or the output consists of more than one block, Polymake returns fail. In any case, the calculated values for each block are stored as known properties of the PolymakeObjectpoly as long as they are not fail. If Polymake is called with an option that corresponds to a name of a known property of poly, the known property is returned. In this case, there is no call of the external program. (see below for suppression of this feature).
Note that the command Polymake returns fail if nothing is returned by the program polymake or more than one block of data is returned. For example, the returned value of Polymake(poly,"VISUAL") is always fail. Likewise, Polymake(poly,"POINTS VERTICES") will return fail (but may add new known properties to poly). For a description of the conversion functions, see chapter 4.
If the option PolymakeNolookup is set to anything else than false, the polymake program is called even if poly already has a known property with name option.
Note that whenever Polymake returns fail, a description of the problem is stored in POLYMAKE_LAST_FAIL_REASON (3.1-2). If you call Polymake with more than one keyword, POLYMAKE_LAST_FAIL_REASON (3.1-2) is changed before polymake is called. So any further reason to return fail will overwrite it.
2.6 An Example
Let's generate a three dimensional permutahedron.
gap> S:=SymmetricGroup(3);
Sym( [ 1 .. 3 ] )
gap> v:=[1,2,3];
[ 1, 2, 3 ]
gap> points:=Orbit(S,v,Permuted);;
gap> permutahedron:=CreatePolymakeObject();
<polymake object. No properties known>
gap> AppendPointlistToPolymakeObject(permutahedron,points);
gap> Polymake(permutahedron,"VOLUME");
3
gap> Polymake(permutahedron,"N_VERTICES");
6
#Now <permutahedron> knows its number of vertices, but not the vertices:
gap> PropertyOfPolymakeObject(permutahedron,"VERTICES");
fail
gap> NamesKnownPropertiesOfPolymakeObject(permutahedron);
[ "VOLUME", "N_VERTICES" ]
#Let's look at the object!
gap> Polymake(permutahedron,"VISUAL");
#I There was no or wrong polymake output
fail
gap> Polymake(permutahedron,"DIM");
2
If set to at least 2, the output of polymake is shown. At level 1, warnings are shown. This is the default. And at level 0, the polymake package remains silent.
3.1-2 POLYMAKE_LAST_FAIL_REASON
‣ POLYMAKE_LAST_FAIL_REASON
( global variable )
Contains a string that explains the last occurence of fail as a return value of Polymake (2.5-1).
3.2 Variables for system interaction
The variables for interaction with the system are contained in the file environment.gi. Each of these variables has a function to set it, see 1.2. If POLYMAKE_COMMAND or POLYMAKE_DATA_DIR are set at startup, they are not overwritten. So if you don't want (or don't have the rights) to modify environment.gi, you can set the variables in your .gaprc file.
3.2-1 POLYMAKE_COMMAND
‣ POLYMAKE_COMMAND
( global variable )
This variable should contain the name of the polymake program in the form as returned by Filename So a probable value is Filename(Directory("/usr/local/bin"),"polymake").
3.2-2 POLYMAKE_DATA_DIR
‣ POLYMAKE_DATA_DIR
( global variable )
In this directory the files for polymake will be created. By default, this generates a temporary directory using DirectoryTemporary
To install the package, just unpack it in your packages directory (usually ~/gap/pkg for local installation). To use polymaking, you need a working installation of the program polymake https://polymake.org. The package has been tested on linux and Mac OS X (10.4, 10.5 and 10.6). But it should be as platform independent as GAP and polymake.
The interaction with polymake is restricted to writing files and carrying out simple operations. These looked like polymake file KEYWORD1 KEYWORD2 KEYWORD3 on the command line for polymake versions before 4. The keywords are polymake methods without arguments. Since polymake no longer supports this interface the polymaking package provides the script lib/pm_script_arg.pl to emulate this. polymake ––script lib/pm_script_arg.pl KEYWORD1 KEYWORD2 KEYWORD3 Using custom scripts is not supported. Every call to polymake will re-start the program anew. This causes considerable overhead. The number of calls to polymake is reduced by caching the results in the so-called PolymakeObject in GAP. As of polymaking version 0.8.0, old versions of polymake (i.e. versions before 2.7.9) are not supported anymore.
1.1 A few words about the installation of polymake
polymaking will try to guess the location of polymake. If this fails, a warning is issued at load time (InfoWarning level 1). Note that the guessing procedure is suppressed when POLYMAKE_COMMAND (3.2-1) is set manually (see 1.2-3). setenv PATH ${PATH}:<your polymakepath> The general rule is: If polymaking finds polymake by itself, there is nothing to worry about.
1.2 Setting variables for external programs
As polymaking uses the program polymake, it needs to know where this program lives. The communication with polymake is done by writing files for polymake and reading its output (as returned to standard output "the prompt"). Note that the interface does not read any polymake file.
1.2-1 SetPolymakeDataDirectory
‣ SetPolymakeDataDirectory( dir )
( method )
Sets the directory in which all polymake files are created to dir. The standard place for these files is a temporary directory generated when the package is loaded. This manipulates POLYMAKE_DATA_DIR (3.2-2).
1.2-2 SetPolymakeCommand
‣ SetPolymakeCommand( command )
( method )
Sets the name for the polymake program to command. This manipulates POLYMAKE_COMMAND (3.2-1).
1.2-3 Setting variables permanently
To permanently set the values of POLYMAKE_COMMAND (3.2-1), and POLYMAKE_DATA_DIR (3.2-2), add the lines
to your .gaprc file (see ???). Note that these have to be before the LoadPackage("polymaking"); line. Or you can change the values of the above variables by editing lib/environment.gi
If set to at least \(2\), the output of polymake is shown. At level \(1\), warnings are shown. This is the default. And at level \(0\), the polymake package remains silent.
3.1-2 POLYMAKE_LAST_FAIL_REASON
‣ POLYMAKE_LAST_FAIL_REASON
( global variable )
Contains a string that explains the last occurence of fail as a return value of Polymake (2.5-1).
3.2 Variables for system interaction
The variables for interaction with the system are contained in the file environment.gi. Each of these variables has a function to set it, see 1.2. If POLYMAKE_COMMAND or POLYMAKE_DATA_DIR are set at startup, they are not overwritten. So if you don't want (or don't have the rights) to modify environment.gi, you can set the variables in your .gaprc file.
3.2-1 POLYMAKE_COMMAND
‣ POLYMAKE_COMMAND
( global variable )
This variable should contain the name of the polymake program in the form as returned by Filename So a probable value is Filename(Directory("/usr/local/bin"),"polymake").
3.2-2 POLYMAKE_DATA_DIR
‣ POLYMAKE_DATA_DIR
( global variable )
In this directory the files for polymake will be created. By default, this generates a temporary directory using DirectoryTemporary
When polymake is called, its output is read as a string and then processed as follows:
the lines containing upper case letters are found. These are treated as lines containing the keywords. Each of those lines marks the beginning of a block of data.
The string is then cut into a list of blocks (also strings). Each block starts with a line containing the keyword and continues with some lines of data.
for each of the blocks, the appropriate function of ObjectConverters is called. Here "appropriate" just means, that the keyword of the block coincides with the name of the function.
The output of the conversion function is then added to the known properties of the PolymakeObject for which Polymake was called.
4.1-1 Converter- Philosopy
The converter functions should take meaningful polymake data into meaningful GAP data. This sometimes means that the (mathematical) representation is changed. Here is an example: polymake writes vectors as augmented affine vectors of the form 1 a1 a2 a3... which does not go very well with the usual GAP conventions of column vectors and multiplying matrices from the right. So polymaking converts such a vector to [a1,a2,a3,...] and the user is left with the problem of augmentation and left or right multiplication.
Another area where the GAP object isn't a literal translation from the polymake world is combinatorics. In Polymake, list elements are enumerated starting from 0. GAP enumerates lists starting at 1. So the conversion process adds 1 to the numbers corresponding to vertices in facet lists, for example.
The conversion process is done by the following methods:
4.1-2 ConvertPolymakeOutputToGapNotation
‣ ConvertPolymakeOutputToGapNotation( string )
( method )
Returns: Record having polymake keywords as entry names and the respective converted polymake output as entries.
Given a the output of the polymake program as a string string, this method first calls SplitPolymakeOutputStringIntoBlocks (4.1-3). For each of the returned blocks, the name (=first line) of the block is read and the record ObjectConverters (4.1-4) is looked up for an entry with that name. If such an entry exists, it (being a function!) is called and passed the block. The returned value is then given the name of the block and added to the record returned by ConvertPolymakeOutputToGapNotation.
4.1-3 SplitPolymakeOutputStringIntoBlocks
‣ SplitPolymakeOutputStringIntoBlocks( string )
( method )
Returns: List of strings -- "blocks"--
The string string is cut at the lines starting with an upper case character and consisting only of upper case letters, numbers and underscore (_) characters. The parts are returned as a list of strings. The initial string string remains unchanged.
4.1-4 ObjectConverters
‣ ObjectConverters
( global variable )
The entries of this record are labeled by polymake keywords. Each of the entries is a function which converts a string returned by polymake to GAP format. So far, only a few converters are implemented. To see which, try RecNames(ObjectConverters);
You can define new converters using the basic functions described in section 4.2.
4.2 Conversion Functions
The following functions are used for the functions in ObjectConverters (4.1-4).
4.2-1 ConvertPolymakeNumber
‣ ConvertPolymakeNumber( string )
( method )
The string string is converted to a rational number. Unlike Rat, it tests, if the number represented by string is a floating point number an converts it correctly. If this is the case, a waring is issued.
4.2-2 ConvertPolymakeScalarToGAP
‣ ConvertPolymakeScalarToGAP( list )
( method )
If list contains a single string, this string is converted into a number using ConvertPolymakeNumber (4.2-1).
4.2-3 ConvertPolymakeMatrixOrListOfSetsToGAP
‣ ConvertPolymakeMatrixOrListOfSetsToGAP( list )
( method )
‣ ConvertPolymakeMatrixOrListOfSetsToGAPPlusOne( list )
( method )
Tries to decide if the list list of strings represents a matrix or a list of sets by testing if they start with "{". It then calls either ConvertPolymakeMatrixToGAP (4.2-4) or ConvertPolymakeListOfSetsToGAP (4.2-8). The "PlusOne" version calls ConvertPolymakeListOfSetsToGAPPlusOne (4.2-8) if list represents a list of sets.
4.2-4 ConvertPolymakeMatrixToGAP
‣ ConvertPolymakeMatrixToGAP( list )
( method )
‣ ConvertPolymakeMatrixToGAPKillOnes( list )
( method )
The list list of strings is interpreted as a list of row vectors and converted into a matrix. The "KillOnes" version removes the leading ones.
4.2-5 ConvertPolymakeVectorToGAP
‣ ConvertPolymakeVectorToGAP( list )
( method )
‣ ConvertPolymakeVectorToGAPKillOne( list )
( method )
‣ ConvertPolymakeIntVectorToGAPPlusOne( list )
( method )
As the corresponding "Matrix" version. Just for vectors. ConvertPolymakeIntVectorToGAPPlusOne requires the vector to contain integers. It also adds 1 to every entry.
4.2-6 ConvertPolymakeBoolToGAP
‣ ConvertPolymakeBoolToGAP( list )
( method )
If list contains a single string, which is either 0,false,1, or true this function returns false or true, respectively.
4.2-7 ConvertPolymakeSetToGAP
‣ ConvertPolymakeSetToGAP( list )
( method )
Let list be a list containing a single string, which is a list of numbers separated by whitespaces and enclosed by { and } . The returned value is then a set of rational numbers (in the GAP sense).
4.2-8 ConvertPolymakeListOfSetsToGAP
‣ ConvertPolymakeListOfSetsToGAP( list )
( method )
‣ ConvertPolymakeListOfSetsToGAPPlusOne( list )
( method )
Let list be a list containing several strings representing sets. Then each of these strings is converted to a set of rational numbers and the returned value is the list of all those sets. The "PlusOne" version adds 1 to every entry.
4.2-9 ConvertPolymakeGraphToGAP
‣ ConvertPolymakeGraphToGAP( list )
( method )
Let list be a list of strings representing sets (that is, a list of integers enclosed by { and }). Then a record is returned containing two sets named .vertices and .edges.
The interaction with the polymake program is done via files. A PolymakeObject is mainly a pointer to a file and a list of known properties of the object. These properties need not be stored in the file. Whenever polymake is called, the returned value is read from standard output and stored in the PolymakeObject corresponding to the file for which polymake is called. The files for polymake are written in the old (non-xml) format. The first run of polymake converts them into the new (xml) format. This means that changes to the file by means of the methods outlined below after the first run of polymake will probably lead to corrupted files.
2.1-1 CreateEmptyFile
‣ CreateEmptyFile( filename )
( method )
Returns: nothing
Creates an empty file with name filename. Note that filename has to include the full path and the directory for the file must exist.
2.1-2 CreatePolymakeObject
‣ CreatePolymakeObject( )
( method )
‣ CreatePolymakeObject( appvertyp )
( method )
‣ CreatePolymakeObject( dir )
( method )
‣ CreatePolymakeObject( dir, appvertyp )
( method )
‣ CreatePolymakeObject( prefix, dir )
( method )
‣ CreatePolymakeObject( prefix, dir, appvertyp )
( method )
Returns: PolymakeObject
If called without arguments, this method generates an empty file in the directory defined by POLYMAKE_DATA_DIR (3.2-2). If a directory dir is given (this directory must exist), an empty file is generated in this directory. If prefix is not given, the file is called polyN where N is the current runtime. If a file of this name already exists, a number is appended separated by a dot (example: "poly1340" and "poly1340.1"). If prefix is given, the filename starts with this prefix. Optionally, the file can be generated with a header specifying application, version and type of the object. This is done by passing the triple of strings appvertyp to CreatePolymakeObject. A valid triple is ["polytope","2.3","RationalPolytope"]. Validity is checked by CheckAppVerTypList (2.1-3).
2.1-3 CheckAppVerTypList
‣ CheckAppVerTypList( appvertyp )
( method )
Returns: bool
Checks if the triple arppvertyp of strings specifies an application and type of polymake version 2.3. More specifically, the first entry has to be an application from ["polytope","surface","topaz"] and the third entry has to be a type corresponding to the application given in the first entry. The second entry is not checked.
2.1-4 CreatePolymakeObjectFromFile
‣ CreatePolymakeObjectFromFile( filename )
( method )
‣ CreatePolymakeObjectFromFile( dir, filename )
( method )
Returns: PolymakeObject
This method generates a PolymakeObject corresponding to the file filename in the directory dir. If dir is not given, the POLYMAKE_DATA_DIR is used.If no file with name filename exists in dir (or POLYMAKE_DATA_DIR, respectively), an empty file is created. Note that the contents of the file do not matter for the generation of the object. In particular, the object does not know any of the properties that might be encoded in the file. The only way to transfer information from files to PolymakeObjects is via Polymake (2.5-1).
2.2 Accessing Properties of Polymake Objects
A PolymakeObject contains information about the directory of its file, the name of its file and about properties calculated by calling Polymake (2.5-1). The properties returned by the polymake program are stored under the name polymake assigns to them (that is, the name of the data block in the corresponding file). The following methods can be used to access the information stored in a PolymakeObject. But be careful! All functions return the actual object. No copies are made. So if you change one of the returned objects, you change the PolymakeObject itself.
2.2-1 DirectoryOfPolymakeObject
‣ DirectoryOfPolymakeObject( poly )
( method )
Returns: Directory
Returns the directory of the file associated with poly.
2.2-2 FilenameOfPolymakeObject
‣ FilenameOfPolymakeObject( poly )
( method )
Returns: String
Returns the name of the file associated with poly. This does only mean the name of the file, not the full path. For the full path and file name see FullFilenameOfPolymakeObject (2.2-3)
2.2-3 FullFilenameOfPolymakeObject
‣ FullFilenameOfPolymakeObject( poly )
( method )
Returns: String
Returns the file associated with the PolymakeObjectpoly with its complete path.
2.2-4 NamesKnownPropertiesOfPolymakeObject
‣ NamesKnownPropertiesOfPolymakeObject( poly )
( method )
Returns: List of Strings
Returns a list of the names of all known properties. This does only include the properties returned by Polymake (2.5-1), "dir" and "filename" are not included. If no properties are known, fail is returned.
2.2-5 KnownPropertiesOfPolymakeObject
‣ KnownPropertiesOfPolymakeObject( poly )
( method )
Returns: Record
Returns the record of all known properties. If no properties are known, fail is returned.
2.2-6 PropertyOfPolymakeObject
‣ PropertyOfPolymakeObject( poly, name )
( method )
Returns the value of the property name if it is known. If the value is not known, fail is returned. name must be a String.
2.3 Example: Creating and Accessing Polymake Objects
Suppose the file /tmp/threecube.poly contains the three dimensional cube in polymake form. Now generate a PolymakeObject from this file and call Polymake (2.5-1) to make the vertices of the cube known to the object.
To transfer data from GAP to polymake, the following methods can be used. But bear in mind that none of these functions test if the resulting polymake file is still consistent.
2.4-1 AppendToPolymakeObject
‣ AppendToPolymakeObject( poly, string )
( method )
Returns: nothing
This appends the string string to the file associated to the PolymakeObjectpoly. It is not tested if the string is syntactically correct as a part of a polymake file. It is also not tested if the string is compatible with the data already contained in the file.
INEQUALITIES, POINTS and VERTICES can be appended to a polymake object using the following functions:
Takes a list pointlist of vectors and converts it into a string which represents a polymake block labeled "POINTS". This string is then added to the file associated with poly. The "POINTS" block of the file associated with poly then contains points with leading ones, as polymake uses affine notation.
Just appends the inequalities given in ineqlist to the polymake object poly (with caption "INEQUALITIES"). Note that this does not check if an "INEQUALITIES" section does already exist in the file associated with poly.
2.4-5 ConvertMatrixToPolymakeString
‣ ConvertMatrixToPolymakeString( name, matrix )
( method )
Returns: String
This function takes a matrix matrix and converts it to a string. This string can then be appended to a polymake file via AppendToPolymakeObject (2.4-1) to form a block of data labeled name. This may be used to write blocks like INEQUALITIES or FACETS.
2.4-6 ClearPolymakeObject
‣ ClearPolymakeObject( poly )
( method )
‣ ClearPolymakeObject( poly, appvertyp )
( method )
Returns: nothing
Deletes all known properties of the PolymakeObjectpoly and replaces its file with an empty one. If the triple of strings appvertyp specifying application, version and type (see CheckAppVerTypList (2.1-3)) is given, the file is replaced with a file that contains only a header specifying application, version and type of the polymake object.
There are also methods to manipulate the known values without touching the file of the PolymakeObject:
2.4-7 WriteKnownPropertyToPolymakeObject
‣ WriteKnownPropertyToPolymakeObject( poly, name, data )
( method )
Takes the object data and writes it to the known properties section of the PolymakeObjectpoly. The string name is used as the name of the property. If a property with that name already exists, it is overwritten. Again, there is no check if data is consistent, correct or meaningful.
2.4-8 UnbindKnownPropertyOfPolymakeObject
‣ UnbindKnownPropertyOfPolymakeObject( poly, name )
( method )
If the PolymakeObjectpoly has a property with name name, that property is unbound. If there is no such property, fail is returned.
2.5 Calling Polymake and converting its output
2.5-1 Polymake
‣ Polymake( poly, option:PolymakeNolookup )
( method )
This method calls the polymake program (see POLYMAKE_COMMAND (3.2-1)) with the option option. You may use several keywords such as "FACETS VERTICES" as an option. The returned value is cut into blocks starting with keywords (which are taken from output and not looked up in option). Each block is then interpreted and translated into GAP readable form. This translation is done using the functions given in ObjectConverters (4.1-4). The first line of each block of polymake output is taken as a keyword and the according entry in ObjectConverters (4.1-4) is called to convert the block into GAP readable form. If no conversion function is known, an info string is printed and fail is returned. If only one keyword has been given as option, Polymake returns the result of the conversion operation. If more than one keyword has been given or the output consists of more than one block, Polymake returns fail. In any case, the calculated values for each block are stored as known properties of the PolymakeObjectpoly as long as they are not fail. If Polymake is called with an option that corresponds to a name of a known property of poly, the known property is returned. In this case, there is no call of the external program. (see below for suppression of this feature).
Note that the command Polymake returns fail if nothing is returned by the program polymake or more than one block of data is returned. For example, the returned value of Polymake(poly,"VISUAL") is always fail. Likewise, Polymake(poly,"POINTS VERTICES") will return fail (but may add new known properties to poly). For a description of the conversion functions, see chapter 4.
If the option PolymakeNolookup is set to anything else than false, the polymake program is called even if poly already has a known property with name option.
Note that whenever Polymake returns fail, a description of the problem is stored in POLYMAKE_LAST_FAIL_REASON (3.1-2). If you call Polymake with more than one keyword, POLYMAKE_LAST_FAIL_REASON (3.1-2) is changed before polymake is called. So any further reason to return fail will overwrite it.
2.6 An Example
Let's generate a three dimensional permutahedron.
gap> S:=SymmetricGroup(3);
Sym( [ 1 .. 3 ] )
gap> v:=[1,2,3];
[ 1, 2, 3 ]
gap> points:=Orbit(S,v,Permuted);;
gap> permutahedron:=CreatePolymakeObject();
<polymake object. No properties known>
gap> AppendPointlistToPolymakeObject(permutahedron,points);
gap> Polymake(permutahedron,"VOLUME");
3
gap> Polymake(permutahedron,"N_VERTICES");
6
#Now <permutahedron> knows its number of vertices, but not the vertices:
gap> PropertyOfPolymakeObject(permutahedron,"VERTICES");
fail
gap> NamesKnownPropertiesOfPolymakeObject(permutahedron);
[ "VOLUME", "N_VERTICES" ]
#Let's look at the object!
gap> Polymake(permutahedron,"VISUAL");
#I There was no or wrong polymake output
fail
gap> Polymake(permutahedron,"DIM");
2
This package provides a very basic interface to the polymake program by Ewgenij Gawrilow, Michael Joswig et al. [GJ]. The polymake program itself is not included.
This package is distributed under the terms of the GNU General Public License version 2 or later (at your convenience). See the file "LICENSE" or https://www.gnu.org/copyleft/gpl.html
Acknowledgements
This work has been supported by Marie Curie Grant No. MTKD-CT-2006-042685
When polymake is called, its output is read as a string and then processed as follows:
the lines containing upper case letters are found. These are treated as lines containing the keywords. Each of those lines marks the beginning of a block of data.
The string is then cut into a list of blocks (also strings). Each block starts with a line containing the keyword and continues with some lines of data.
for each of the blocks, the appropriate function of ObjectConverters is called. Here "appropriate" just means, that the keyword of the block coincides with the name of the function.
The output of the conversion function is then added to the known properties of the PolymakeObject for which Polymake was called.
4.1-1 Converter- Philosopy
The converter functions should take meaningful polymake data into meaningful GAP data. This sometimes means that the (mathematical) representation is changed. Here is an example: polymake writes vectors as augmented affine vectors of the form 1 a1 a2 a3... which does not go very well with the usual GAP conventions of column vectors and multiplying matrices from the right. So polymaking converts such a vector to [a1,a2,a3,...] and the user is left with the problem of augmentation and left or right multiplication.
Another area where the GAP object isn't a literal translation from the polymake world is combinatorics. In Polymake, list elements are enumerated starting from 0. GAP enumerates lists starting at 1. So the conversion process adds 1 to the numbers corresponding to vertices in facet lists, for example.
The conversion process is done by the following methods:
4.1-2 ConvertPolymakeOutputToGapNotation
‣ ConvertPolymakeOutputToGapNotation( string )
( method )
Returns: Record having polymake keywords as entry names and the respective converted polymake output as entries.
Given a the output of the polymake program as a string string, this method first calls SplitPolymakeOutputStringIntoBlocks (4.1-3). For each of the returned blocks, the name (=first line) of the block is read and the record ObjectConverters (4.1-4) is looked up for an entry with that name. If such an entry exists, it (being a function!) is called and passed the block. The returned value is then given the name of the block and added to the record returned by ConvertPolymakeOutputToGapNotation.
4.1-3 SplitPolymakeOutputStringIntoBlocks
‣ SplitPolymakeOutputStringIntoBlocks( string )
( method )
Returns: List of strings -- "blocks"--
The string string is cut at the lines starting with an upper case character and consisting only of upper case letters, numbers and underscore (_) characters. The parts are returned as a list of strings. The initial string string remains unchanged.
4.1-4 ObjectConverters
‣ ObjectConverters
( global variable )
The entries of this record are labeled by polymake keywords. Each of the entries is a function which converts a string returned by polymake to GAP format. So far, only a few converters are implemented. To see which, try RecNames(ObjectConverters);
You can define new converters using the basic functions described in section 4.2.
4.2 Conversion Functions
The following functions are used for the functions in ObjectConverters (4.1-4).
4.2-1 ConvertPolymakeNumber
‣ ConvertPolymakeNumber( string )
( method )
The string string is converted to a rational number. Unlike Rat, it tests, if the number represented by string is a floating point number an converts it correctly. If this is the case, a waring is issued.
4.2-2 ConvertPolymakeScalarToGAP
‣ ConvertPolymakeScalarToGAP( list )
( method )
If list contains a single string, this string is converted into a number using ConvertPolymakeNumber (4.2-1).
4.2-3 ConvertPolymakeMatrixOrListOfSetsToGAP
‣ ConvertPolymakeMatrixOrListOfSetsToGAP( list )
( method )
‣ ConvertPolymakeMatrixOrListOfSetsToGAPPlusOne( list )
( method )
Tries to decide if the list list of strings represents a matrix or a list of sets by testing if they start with "{". It then calls either ConvertPolymakeMatrixToGAP (4.2-4) or ConvertPolymakeListOfSetsToGAP (4.2-8). The "PlusOne" version calls ConvertPolymakeListOfSetsToGAPPlusOne (4.2-8) if list represents a list of sets.
4.2-4 ConvertPolymakeMatrixToGAP
‣ ConvertPolymakeMatrixToGAP( list )
( method )
‣ ConvertPolymakeMatrixToGAPKillOnes( list )
( method )
The list list of strings is interpreted as a list of row vectors and converted into a matrix. The "KillOnes" version removes the leading ones.
4.2-5 ConvertPolymakeVectorToGAP
‣ ConvertPolymakeVectorToGAP( list )
( method )
‣ ConvertPolymakeVectorToGAPKillOne( list )
( method )
‣ ConvertPolymakeIntVectorToGAPPlusOne( list )
( method )
As the corresponding "Matrix" version. Just for vectors. ConvertPolymakeIntVectorToGAPPlusOne requires the vector to contain integers. It also adds 1 to every entry.
4.2-6 ConvertPolymakeBoolToGAP
‣ ConvertPolymakeBoolToGAP( list )
( method )
If list contains a single string, which is either 0,false,1, or true this function returns false or true, respectively.
4.2-7 ConvertPolymakeSetToGAP
‣ ConvertPolymakeSetToGAP( list )
( method )
Let list be a list containing a single string, which is a list of numbers separated by whitespaces and enclosed by { and } . The returned value is then a set of rational numbers (in the GAP sense).
4.2-8 ConvertPolymakeListOfSetsToGAP
‣ ConvertPolymakeListOfSetsToGAP( list )
( method )
‣ ConvertPolymakeListOfSetsToGAPPlusOne( list )
( method )
Let list be a list containing several strings representing sets. Then each of these strings is converted to a set of rational numbers and the returned value is the list of all those sets. The "PlusOne" version adds 1 to every entry.
4.2-9 ConvertPolymakeGraphToGAP
‣ ConvertPolymakeGraphToGAP( list )
( method )
Let list be a list of strings representing sets (that is, a list of integers enclosed by { and }). Then a record is returned containing two sets named .vertices and .edges.
polymaking-0.8.6/doc/manual.css 0000644 0000766 0000024 00000015754 14071427117 015462 0 ustar mhorn staff /* manual.css Frank Lübeck */
/* This is the default CSS style sheet for GAPDoc HTML manuals. */
/* basic settings, fonts, sizes, colors, ... */
body {
position: relative;
background: #ffffff;
color: #000000;
width: 70%;
margin: 0pt;
padding: 15pt;
font-family: Helvetica,Verdana,Arial,sans-serif;
text-align: justify;
}
/* no side toc on title page, bib and index */
body.chap0 {
width: 95%;
}
body.chapBib {
width: 95%;
}
body.chapInd {
width: 95%;
}
h1 { font-size: 200%; }
h2 { font-size: 160%; }
h3 { font-size: 160%; }
h4 { font-size: 130%; }
h5 { font-size: 100%; }
p.foot {
font-size: 60%;
font-style: normal;
}
a:link {
color: #00008e;
text-decoration: none;
}
a:visited {
color: #00008e;
text-decoration: none;
}
a:active {
color: #000000;
text-decoration: none;
}
a:hover {
background: #eeeeee;
}
pre {
font-family: "Courier New",Courier,monospace;
font-size: 100%;
color:#111111;
}
tt,code {
font-family: "Courier New",Courier,monospace;
font-size: 110%;
color: #000000; }
var {
}
/* general alignment classes */
.pcenter {
text-align: center;
}
.pleft {
text-align: left;
}
.pright {
text-align: right;
}
/* layout for the definitions of functions, variables, ... */
div.func {
background: #e0e0e0;
margin: 0pt 0pt;
}
/* general and special table settings */
table {
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
}
td, th {
border-style: none;
}
table.func {
padding: 0pt 1ex;
margin-left: 1ex;
margin-right: 1ex;
background: transparent;
/* line-height: 1.1; */
width: 100%;
}
table.func td.tdright {
padding-right: 2ex;
}
/* Example elements (for old converted manuals, now in div+pre */
table.example {
background: #efefef;
border-style: none;
border-width: 0pt;
padding: 0px;
width: 100%
}
table.example td {
border-style: none;
border-width: 0pt;
padding: 0ex 1ex;
}
/* becomes ... */
div.example {
background: #efefef;
padding: 0ex 1ex;
/* overflow-x: auto; */
overflow: auto;
}
/* Links to chapters in all files at top and bottom. */
/* If there are too many chapters then use 'display: none' here. */
div.chlinktop {
background: #dddddd;
border-style: solid;
border-width: thin;
margin: 2px;
text-align: center;
}
div.chlinktop a {
margin: 3px;
}
div.chlinktop a:hover {
background: #ffffff;
}
div.chlinkbot {
background: #dddddd;
border-style: solid;
border-width: thin;
margin: 2px;
text-align: center;
/* width: 100%; */
}
div.chlinkbot a {
margin: 3px;
}
span.chlink1 {
}
/* and this is for the "Top", "Prev", "Next" links */
div.chlinkprevnexttop {
background: #dddddd;
border-style: solid;
border-width: thin;
text-align: center;
margin: 2px;
}
div.chlinkprevnexttop a:hover {
background: #ffffff;
}
div.chlinkprevnextbot {
background: #dddddd;
border-style: solid;
border-width: thin;
text-align: center;
margin: 2px;
}
div.chlinkprevnextbot a:hover {
background: #ffffff;
}
/* table of contents, initially don't display subsections */
div.ContSSBlock {
display: none;
}
div.ContSSBlock br {
display: none;
}
/* format in separate lines */
span.tocline {
display: block;
width: 100%;
}
div.ContSSBlock a {
display: block;
}
/* this is for the main table of contents */
div.ContChap {
}
div.ContChap div.ContSect:hover div.ContSSBlock {
display: block;
position: absolute;
background: #eeeeee;
border-style: solid;
border-width: 1px 4px 4px 1px;
border-color: #666666;
padding-left: 0.5ex;
color: #000000;
left: 20%;
width: 40%;
z-index: 10000;
}
div.ContSSBlock a:hover {
background: #ffffff;
}
/* and here for the side menu of contents in the chapter files */
div.ChapSects {
}
div.ChapSects a:hover {
background: #eeeeee;
}
div.ChapSects a:hover {
display: block;
width: 100%;
background: #eeeeee;
color: #000000;
}
div.ChapSects div.ContSect:hover div.ContSSBlock {
display: block;
position: fixed;
background: #eeeeee;
border-style: solid;
border-width: 1px 2px 2px 1px;
border-color: #666666;
padding-left: 0ex;
padding-right: 0.5ex;
color: #000000;
left: 54%;
width: 25%;
z-index: 10000;
}
div.ChapSects div.ContSect:hover div.ContSSBlock a {
display: block;
margin-left: 3px;
}
div.ChapSects div.ContSect:hover div.ContSSBlock a:hover {
display: block;
background: #ffffff;
}
div.ContSect {
text-align: left;
margin-left: 1em;
}
div.ChapSects {
position: fixed;
left: 75%;
font-size: 90%;
overflow: auto;
top: 10px;
bottom: 0px;
}
/* Table elements */
table.GAPDocTable {
border-collapse: collapse;
border-style: none;
border-color: black;
}
table.GAPDocTable td, table.GAPDocTable th {
padding: 3pt;
border-width: thin;
border-style: solid;
border-color: #555555;
}
caption.GAPDocTable {
caption-side: bottom;
width: 70%;
margin-top: 1em;
margin-left: auto;
margin-right: auto;
}
td.tdleft {
text-align: left;
}
table.GAPDocTablenoborder {
border-collapse: collapse;
border-style: none;
border-color: black;
}
table.GAPDocTablenoborder td, table.GAPDocTable th {
padding: 3pt;
border-width: 0pt;
border-style: solid;
border-color: #555555;
}
caption.GAPDocTablenoborder {
caption-side: bottom;
width: 70%;
margin-top: 1em;
margin-left: auto;
margin-right: auto;
}
td.tdleft {
text-align: left;
}
td.tdright {
text-align: right;
}
td.tdcenter {
text-align: center;
}
/* Colors and fonts can be overwritten for some types of elements. */
/* Verb elements */
pre.normal {
color: #000000;
}
/* Func-like elements and Ref to Func-like */
code.func {
color: #000000;
}
/* K elements */
code.keyw {
color: #770000;
}
/* F elements */
code.file {
color: #8e4510;
}
/* C elements */
code.code {
}
/* Item elements */
code.i {
}
/* Button elements */
strong.button {
}
/* Headings */
span.Heading {
}
/* Arg elements */
var.Arg {
color: #006600;
}
/* Example elements, is in tables, see above */
div.Example {
}
/* Package elements */
strong.pkg {
}
/* URL-like elements */
span.URL {
}
/* Mark elements */
strong.Mark {
}
/* Ref elements */
b.Ref {
}
span.Ref {
}
/* this contains the contents page */
div.contents {
}
/* this contains the index page */
div.index {
}
/* ignore some text for non-css layout */
span.nocss {
display: none;
}
/* colors for ColorPrompt like examples */
span.GAPprompt {
color: #000097;
font-weight: normal;
}
span.GAPbrkprompt {
color: #970000;
font-weight: normal;
}
span.GAPinput {
color: #970000;
}
/* Bib entries */
p.BibEntry {
}
span.BibKey {
color: #005522;
}
span.BibKeyLink {
}
b.BibAuthor {
}
i.BibTitle {
}
i.BibBookTitle {
}
span.BibEditor {
}
span.BibJournal {
}
span.BibType {
}
span.BibPublisher {
}
span.BibSchool {
}
span.BibEdition {
}
span.BibVolume {
}
span.BibSeries {
}
span.BibNumber {
}
span.BibPages {
}
span.BibOrganization {
}
span.BibAddress {
}
span.BibYear {
}
span.BibPublisher {
}
span.BibNote {
}
span.BibHowpublished {
}
polymaking-0.8.6/doc/chap4.txt 0000644 0000766 0000024 00000020467 14071427114 015225 0 ustar mhorn staff
[1X4 [33X[0;0YConverting Polymake Output[133X[101X
[1X4.1 [33X[0;0YThe General Method[133X[101X
[33X[0;0YWhen polymake is called, its output is read as a string and then processed
as follows:[133X
[31X1[131X [33X[0;6Ythe lines containing upper case letters are found. These are treated
as lines containing the keywords. Each of those lines marks the
beginning of a block of data.[133X
[31X2[131X [33X[0;6YThe string is then cut into a list of blocks (also strings). Each
block starts with a line containing the keyword and continues with
some lines of data.[133X
[31X3[131X [33X[0;6Yfor each of the blocks, the appropriate function of [10XObjectConverters[110X
is called. Here "appropriate" just means, that the keyword of the
block coincides with the name of the function.[133X
[31X4[131X [33X[0;6YThe output of the conversion function is then added to the known
properties of the [10XPolymakeObject[110X for which [10XPolymake[110X was called.[133X
[1X4.1-1 [33X[0;0YConverter- Philosopy[133X[101X
[33X[0;0YThe converter functions should take meaningful polymake data into meaningful
[5XGAP[105X data. This sometimes means that the (mathematical) representation is
changed. Here is an example: polymake writes vectors as augmented affine
vectors of the form [10X1 a1 a2 a3...[110X which does not go very well with the usual
[5XGAP[105X conventions of column vectors and multiplying matrices from the right.
So [5Xpolymaking[105X converts such a vector to [10X[a1,a2,a3,...][110X and the user is left
with the problem of augmentation and left or right multiplication.[133X
[33X[0;0YAnother area where the [5XGAP[105X object isn't a literal translation from the
polymake world is combinatorics. In Polymake, list elements are enumerated
starting from 0. [5XGAP[105X enumerates lists starting at 1. So the conversion
process adds 1 to the numbers corresponding to vertices in facet lists, for
example.[133X
[33X[0;0YThe conversion process is done by the following methods:[133X
[1X4.1-2 ConvertPolymakeOutputToGapNotation[101X
[33X[1;0Y[29X[2XConvertPolymakeOutputToGapNotation[102X( [3Xstring[103X ) [32X method[133X
[6XReturns:[106X [33X[0;10YRecord having polymake keywords as entry names and the respective
converted polymake output as entries.[133X
[33X[0;0YGiven a the output of the polymake program as a string [3Xstring[103X, this method
first calls [2XSplitPolymakeOutputStringIntoBlocks[102X ([14X4.1-3[114X). For each of the
returned blocks, the name (=first line) of the block is read and the record
[2XObjectConverters[102X ([14X4.1-4[114X) is looked up for an entry with that name. If such
an entry exists, it (being a function!) is called and passed the block. The
returned value is then given the name of the block and added to the record
returned by [10XConvertPolymakeOutputToGapNotation[110X.[133X
[1X4.1-3 SplitPolymakeOutputStringIntoBlocks[101X
[33X[1;0Y[29X[2XSplitPolymakeOutputStringIntoBlocks[102X( [3Xstring[103X ) [32X method[133X
[6XReturns:[106X [33X[0;10YList of strings -- "blocks"--[133X
[33X[0;0YThe string [3Xstring[103X is cut at the lines starting with an upper case character
and consisting only of upper case letters, numbers and underscore (_)
characters. The parts are returned as a list of strings. The initial string
[3Xstring[103X remains unchanged.[133X
[1X4.1-4 ObjectConverters[101X
[33X[1;0Y[29X[2XObjectConverters[102X [32X global variable[133X
[33X[0;0YThe entries of this record are labeled by polymake keywords. Each of the
entries is a function which converts a string returned by polymake to [5XGAP[105X
format. So far, only a few converters are implemented. To see which, try
[10XRecNames(ObjectConverters);[110X[133X
[33X[0;0YYou can define new converters using the basic functions described in section
[14X4.2[114X.[133X
[1X4.2 [33X[0;0YConversion Functions[133X[101X
[33X[0;0YThe following functions are used for the functions in [2XObjectConverters[102X
([14X4.1-4[114X).[133X
[1X4.2-1 ConvertPolymakeNumber[101X
[33X[1;0Y[29X[2XConvertPolymakeNumber[102X( [3Xstring[103X ) [32X method[133X
[33X[0;0YThe string [3Xstring[103X is converted to a rational number. Unlike [10XRat[110X, it tests,
if the number represented by [3Xstring[103X is a floating point number an converts
it correctly. If this is the case, a waring is issued.[133X
[1X4.2-2 ConvertPolymakeScalarToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeScalarToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YIf [3Xlist[103X contains a single string, this string is converted into a number
using [2XConvertPolymakeNumber[102X ([14X4.2-1[114X).[133X
[1X4.2-3 ConvertPolymakeMatrixOrListOfSetsToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeMatrixOrListOfSetsToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[1;0Y[29X[2XConvertPolymakeMatrixOrListOfSetsToGAPPlusOne[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YTries to decide if the list [3Xlist[103X of strings represents a matrix or a list of
sets by testing if they start with "{". It then calls either
[2XConvertPolymakeMatrixToGAP[102X ([14X4.2-4[114X) or [2XConvertPolymakeListOfSetsToGAP[102X
([14X4.2-8[114X). The "PlusOne" version calls [2XConvertPolymakeListOfSetsToGAPPlusOne[102X
([14X4.2-8[114X) if [3Xlist[103X represents a list of sets.[133X
[1X4.2-4 ConvertPolymakeMatrixToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeMatrixToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[1;0Y[29X[2XConvertPolymakeMatrixToGAPKillOnes[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YThe list [3Xlist[103X of strings is interpreted as a list of row vectors and
converted into a matrix. The "KillOnes" version removes the leading ones.[133X
[1X4.2-5 ConvertPolymakeVectorToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeVectorToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[1;0Y[29X[2XConvertPolymakeVectorToGAPKillOne[102X( [3Xlist[103X ) [32X method[133X
[33X[1;0Y[29X[2XConvertPolymakeIntVectorToGAPPlusOne[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YAs the corresponding "Matrix" version. Just for vectors.
[9XConvertPolymakeIntVectorToGAPPlusOne[109X requires the vector to contain
integers. It also adds 1 to every entry.[133X
[1X4.2-6 ConvertPolymakeBoolToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeBoolToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YIf [3Xlist[103X contains a single string, which is either 0,false,1, or true this
function returns [9Xfalse[109X or [9Xtrue[109X, respectively.[133X
[1X4.2-7 ConvertPolymakeSetToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeSetToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YLet [3Xlist[103X be a list containing a single string, which is a list of numbers
separated by whitespaces and enclosed by { and } . The returned value is
then a set of rational numbers (in the GAP sense).[133X
[1X4.2-8 ConvertPolymakeListOfSetsToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeListOfSetsToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[1;0Y[29X[2XConvertPolymakeListOfSetsToGAPPlusOne[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YLet [3Xlist[103X be a list containing several strings representing sets. Then each
of these strings is converted to a set of rational numbers and the returned
value is the list of all those sets. The "PlusOne" version adds 1 to every
entry.[133X
[1X4.2-9 ConvertPolymakeGraphToGAP[101X
[33X[1;0Y[29X[2XConvertPolymakeGraphToGAP[102X( [3Xlist[103X ) [32X method[133X
[33X[0;0YLet [3Xlist[103X be a list of strings representing sets (that is, a list of integers
enclosed by { and }). Then a record is returned containing two sets named
[10X.vertices[110X and [10X.edges[110X.[133X
polymaking-0.8.6/doc/ragged.css 0000644 0000766 0000024 00000000231 14071427117 015416 0 ustar mhorn staff /* times.css Frank Lübeck */
/* Change default CSS to use Times font. */
body {
text-align: left;
}
polymaking-0.8.6/doc/chap1.html 0000644 0000766 0000024 00000017511 14071427117 015346 0 ustar mhorn staff
GAP (polymaking) - Chapter 1: Installation and Preface
To install the package, just unpack it in your packages directory (usually ~/gap/pkg for local installation). To use polymaking, you need a working installation of the program polymake https://polymake.org. The package has been tested on linux and Mac OS X (10.4, 10.5 and 10.6). But it should be as platform independent as GAP and polymake.
The interaction with polymake is restricted to writing files and carrying out simple operations. These looked like polymake file KEYWORD1 KEYWORD2 KEYWORD3 on the command line for polymake versions before 4. The keywords are polymake methods without arguments. Since polymake no longer supports this interface the polymaking package provides the script lib/pm_script_arg.pl to emulate this. polymake ––script lib/pm_script_arg.pl KEYWORD1 KEYWORD2 KEYWORD3 Using custom scripts is not supported. Every call to polymake will re-start the program anew. This causes considerable overhead. The number of calls to polymake is reduced by caching the results in the so-called PolymakeObject in GAP. As of polymaking version 0.8.0, old versions of polymake (i.e. versions before 2.7.9) are not supported anymore.
1.1 A few words about the installation of polymake
polymaking will try to guess the location of polymake. If this fails, a warning is issued at load time (InfoWarning level 1). Note that the guessing procedure is suppressed when POLYMAKE_COMMAND (3.2-1) is set manually (see 1.2-3). setenv PATH ${PATH}:<your polymakepath> The general rule is: If polymaking finds polymake by itself, there is nothing to worry about.
1.2 Setting variables for external programs
As polymaking uses the program polymake, it needs to know where this program lives. The communication with polymake is done by writing files for polymake and reading its output (as returned to standard output "the prompt"). Note that the interface does not read any polymake file.
1.2-1 SetPolymakeDataDirectory
‣ SetPolymakeDataDirectory( dir )
( method )
Sets the directory in which all polymake files are created to dir. The standard place for these files is a temporary directory generated when the package is loaded. This manipulates POLYMAKE_DATA_DIR (3.2-2).
1.2-2 SetPolymakeCommand
‣ SetPolymakeCommand( command )
( method )
Sets the name for the polymake program to command. This manipulates POLYMAKE_COMMAND (3.2-1).
1.2-3 Setting variables permanently
To permanently set the values of POLYMAKE_COMMAND (3.2-1), and POLYMAKE_DATA_DIR (3.2-2), add the lines
to your .gaprc file (see ???). Note that these have to be before the LoadPackage("polymaking"); line. Or you can change the values of the above variables by editing lib/environment.gi
polymaking-0.8.6/doc/environment.xml 0000644 0000766 0000024 00000007250 14071427055 016552 0 ustar mhorn staff Installation and Preface
To install the package, just unpack it in your packages directory
(usually ~/gap/pkg for local installation).
To use polymaking, you need a working installation of the program
polymake https://polymake.org. The
package has been tested on linux and Mac OS X (10.4, 10.5 and 10.6).
But it should be as platform independent as &GAP; and polymake.
The interaction with polymake is restricted to writing files and
carrying out simple operations. These looked like
polymake file KEYWORD1 KEYWORD2 KEYWORD3
on the command line for polymake versions before 4. The keywords are polymake methods without arguments.
Since polymake no longer supports this interface the polymaking package
provides the script lib/pm_script_arg.pl to emulate this.
polymake ––script lib/pm_script_arg.pl KEYWORD1 KEYWORD2 KEYWORD3
Using custom scripts is not supported.
Every call to polymake will re-start the program anew. This causes considerable overhead.
The number of calls to polymake is reduced by caching the results in the so-called
PolymakeObject in GAP.
As of polymaking version 0.8.0, old versions of polymake (i.e. versions before 2.7.9) are not
supported anymore.
A few words about the installation of polymakepolymaking will try to guess the location of polymake. If
this fails, a warning is issued at load time (InfoWarning level 1). Note
that the guessing procedure is suppressed when
is set manually (see ).
]]>
The general rule is: If polymaking finds polymake by itself,
there is nothing to worry about.
Setting variables for external programs
As polymaking uses the program polymake, it needs to
know
where this program lives. The communication with polymake is done
by writing files for polymake and reading its output (as returned to
standard output "the prompt"). Note that the interface does not read any
polymake file.
Sets the directory in which all polymake files are created to
dir. The standard place for these files is a temporary
directory generated when the package is loaded. This
manipulates .
Sets the name for the polymake program to command. This
manipulates .
Setting variables permanently
To permanently set the values of , and
, add the lines
POLYMAKE_DATA_DIR:=Directory("/home/mypolymakedatadir");
POLYMAKE_COMMAND:=Filename(Directory("/home/mypolymakebindir/"),"polymake");
to your .gaprc file (see ). Note that these have to be
before the LoadPackage("polymaking"); line.
Or you can change the values of the above variables by editing
lib/environment.gi
polymaking-0.8.6/doc/toggless.js 0000644 0000766 0000024 00000004205 14071427117 015645 0 ustar mhorn staff /* toggless.js Frank Lübeck */
/* this file contains two functions:
mergeSideTOCHooks: this changes div.ContSect elements to the class
ContSectClosed and includes a hook to toggle between
ContSectClosed and ContSectOpen.
openclosetoc: this function does the toggling, the rest is done by
CSS
*/
closedTOCMarker = "▶ ";
openTOCMarker = "▼ ";
noTOCMarker = " ";
/* merge hooks into side toc for opening/closing subsections
with openclosetoc */
function mergeSideTOCHooks() {
var hlist = document.getElementsByTagName("div");
for (var i = 0; i < hlist.length; i++) {
if (hlist[i].className == "ContSect") {
var chlds = hlist[i].childNodes;
var el = document.createElement("span");
var oncl = document.createAttribute("class");
oncl.nodeValue = "toctoggle";
el.setAttributeNode(oncl);
var cont;
if (chlds.length > 2) {
var oncl = document.createAttribute("onclick");
oncl.nodeValue = "openclosetoc(event)";
el.setAttributeNode(oncl);
cont = document.createTextNode(closedTOCMarker);
} else {
cont = document.createTextNode(noTOCMarker);
}
el.appendChild(cont);
hlist[i].firstChild.insertBefore(el, hlist[i].firstChild.firstChild);
hlist[i].className = "ContSectClosed";
}
}
}
function openclosetoc (event) {
/* first two steps to make it work in most browsers */
var evt=window.event || event;
if (!evt.target)
evt.target=evt.srcElement;
var markClosed = document.createTextNode(closedTOCMarker);
var markOpen = document.createTextNode(openTOCMarker);
var par = evt.target.parentNode.parentNode;
if (par.className == "ContSectOpen") {
par.className = "ContSectClosed";
evt.target.replaceChild(markClosed, evt.target.firstChild);
}
else if (par.className == "ContSectClosed") {
par.className = "ContSectOpen";
evt.target.replaceChild(markOpen, evt.target.firstChild);
}
}
/* adjust jscontent which is called onload */
jscontentfuncs.push(mergeSideTOCHooks);
polymaking-0.8.6/doc/chapInd_mj.html 0000644 0000766 0000024 00000016217 14071427117 016410 0 ustar mhorn staff
GAP (polymaking) - Index