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> points3:=Orbit(S,v,Permuted);;
# project to reduce ambient dimension
gap> points:=points3{[1..6]}{[1,2]};;
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 occurrence 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 Reference: The gap.ini and gaprc files). 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 occurrence 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 warning 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> points3:=Orbit(S,v,Permuted);;
# project to reduce ambient dimension
gap> points:=points3{[1..6]}{[1,2]};;
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 warning 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.7/doc/manual.css 000644 000766 000024 00000015754 14507124702 016741 0 ustar 00mhorn staff 000000 000000 /* 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.7/doc/chap4.txt 000644 000766 000024 00000020470 14507124676 016513 0 ustar 00mhorn staff 000000 000000
[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 warning 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.7/doc/ragged.css 000644 000766 000024 00000000231 14507124702 016675 0 ustar 00mhorn staff 000000 000000 /* times.css Frank Lübeck */
/* Change default CSS to use Times font. */
body {
text-align: left;
}
polymaking-0.8.7/doc/chap1.html 000644 000766 000024 00000017653 14507124702 016634 0 ustar 00mhorn staff 000000 000000
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 Reference: The gap.ini and gaprc files). 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.7/doc/environment.xml 000644 000766 000024 00000007264 14507124632 020037 0 ustar 00mhorn staff 000000 000000 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.7/doc/toggless.js 000644 000766 000024 00000004205 14507124702 017124 0 ustar 00mhorn staff 000000 000000 /* 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.7/doc/chapInd_mj.html 000644 000766 000024 00000016217 14507124702 017667 0 ustar 00mhorn staff 000000 000000
GAP (polymaking) - Index
polymaking-0.8.7/lib/environment.gd 000644 000766 000024 00000002365 14507124632 017627 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W environment.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareInfoClass("InfoPolymaking");
DeclareOperation("SetPolymakeDataDirectory",[IsDirectory]);
DeclareOperation("SetPolymakeCommand",[IsString]);
##
## keep track of the last thing that caused Polymake to return fail:
##
DeclareGlobalVariable("POLYMAKE_LAST_FAIL_REASON");
DeclareOperation("UpdatePolymakeFailReason",[IsString]);
polymaking-0.8.7/lib/construct.gd 000644 000766 000024 00000004051 14507124632 017301 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W construct.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareOperation("CreateEmptyFile",[IsString]);
DeclareOperation("InitPolymakeObject",[IsPolymakeObject]);
DeclareOperation("CreatePolymakeObjectFromFile",[IsString]);
DeclareOperation("CreatePolymakeObjectFromFile",[IsDirectory,IsString]);
DeclareOperation("CreatePolymakeObject",[]);
DeclareOperation("CreatePolymakeObject",[IsDenseList]);
DeclareOperation("CreatePolymakeObject",[IsDirectory]);
DeclareOperation("CreatePolymakeObject",[IsDirectory,IsDenseList]);
DeclareOperation("CreatePolymakeObject",[IsString,IsDirectory]);
DeclareOperation("CreatePolymakeObject",[IsString,IsDirectory,IsDenseList]);
DeclareOperation("ConvertMatrixToPolymakeString",[IsString,IsDenseList]);
DeclareOperation("AppendToPolymakeObject",[IsPolymakeObject,IsString]);
DeclareOperation("AppendToPolymakeObject",[IsPolymakeObject,IsString,IsString]);
DeclareOperation("AppendPointlistToPolymakeObject",[IsPolymakeObject,IsDenseList]);
DeclareOperation("AppendVertexlistToPolymakeObject",[IsPolymakeObject,IsDenseList]);
DeclareOperation("AppendInequalitiesToPolymakeObject",[IsPolymakeObject,IsDenseList]);
DeclareOperation("Polymake",[IsPolymakeObject,IsString]);
polymaking-0.8.7/lib/pm_script_arg.pl 000644 000766 000024 00000001462 14507124632 020132 0 ustar 00mhorn staff 000000 000000 # This is a compatibility hack for polymake 4.1
# See https://polymake.org/doku.php/user_guide/tutorials/release/4.1/legacy
# Copyright Joachim Zobel .
# Licensed under the same license as GAP polymaking.
my $file = shift(@ARGV);
my $rtn = 0;
$rtn = 1 if $#ARGV > 1;
sub give_from {
my ($c, $arg) = @_;
no strict 'refs';
return $c->$arg;
}
my $c=load($file);
my @rtn = ();
foreach my $arg (@ARGV) {
my @sargs = split(/\b\s+\b/, $arg);
$rtn = 1 if $#sargs > 1;
foreach my $sarg (@sargs) {
my @ssargs = split('->', $sarg);
my $given = $c;
# We follow the arrows
foreach my $ssarg (@ssargs) {
$given = give_from($given, $ssarg);
}
# and return what the last one gave us
push(@rtn, "$sarg\n$given\n");
}
}
print join("\n", @rtn);
return $rtn;
polymaking-0.8.7/lib/application_version_type.gd 000644 000766 000024 00000001746 14507124632 022376 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W application_version_type.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareOperation("CheckAppVerTypList",[IsDenseList]); polymaking-0.8.7/lib/ObjectConverters.gi 000644 000766 000024 00000007137 14507124632 020553 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W ObjectConverters.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
InstallValue(ObjectConverters, rec(
ALTSHULER_DET:=ConvertPolymakeScalarToGAP,
AMBIENT_DIM:=ConvertPolymakeScalarToGAP,
BALANCED:=ConvertPolymakeBoolToGAP,
BALANCE:=ConvertPolymakeScalarToGAP,
BOUNDED:=ConvertPolymakeBoolToGAP,
CENTERED:=ConvertPolymakeBoolToGAP,
COCUBICAL:=ConvertPolymakeBoolToGAP,
COMPLEXITY:=ConvertPolymakeScalarToGAP,
CUBICAL:=ConvertPolymakeBoolToGAP,
COCUBICALITY:=ConvertPolymakeScalarToGAP,
COMPLEXITY:=ConvertPolymakeScalarToGAP,
DIMS:=ConvertPolymakeVectorToGAP, ## done using mapping-hack
DIM:=ConvertPolymakeScalarToGAP,
DUAL_CONNECTIVITY:=ConvertPolymakeScalarToGAP,
DUAL_DIAMETER:=ConvertPolymakeScalarToGAP,
DUAL_EVEN:=ConvertPolymakeBoolToGAP,
DUAL_GRAPH_SIGNATURE:=ConvertPolymakeScalarToGAP,
DUAL_TRIANGLE_FREE:=ConvertPolymakeBoolToGAP,
EQUATIONS:=ConvertPolymakeMatrixToGAP,
ESSENTIALLY_GENERIC:=ConvertPolymakeBoolToGAP,
EVEN:=ConvertPolymakeBoolToGAP,
F_VECTOR:=ConvertPolymakeVectorToGAP,
F2_VECTOR:=ConvertPolymakeMatrixToGAP,
FACES:=ConvertPolymakeListOfSetsToGAPPlusOne,
ADJACENCY:=ConvertPolymakeListOfSetsToGAPPlusOne,
FACET_DEGREES:=ConvertPolymakeVectorToGAP,
FACETS:=ConvertPolymakeMatrixOrListOfSetsToGAPPlusOne,
FAR_HYPERPLANE:=ConvertPolymakeVectorToGAP,
FATNESS:=ConvertPolymakeScalarToGAP,
FEASIBLE:=ConvertPolymakeBoolToGAP,
GRAPH:=ConvertPolymakeGraphToGAP,
GRAPH_SIGNATURE:=ConvertPolymakeScalarToGAP,
INEQUALITIES:=ConvertPolymakeMatrixToGAP,
LATTICE:=ConvertPolymakeBoolToGAP,
N_01POINTS:=ConvertPolymakeScalarToGAP,
N_BOUNDED_VERTICES:=ConvertPolymakeScalarToGAP,
N_FACETS:=ConvertPolymakeScalarToGAP,
N_FLAGS:=ConvertPolymakeScalarToGAP,
N_INEQUALITIES:=ConvertPolymakeScalarToGAP,
N_POINTS:=ConvertPolymakeScalarToGAP,
N_RIDGES:=ConvertPolymakeScalarToGAP,
N_VERTEX_FACET_INC:=ConvertPolymakeScalarToGAP,
N_VERTICES:=ConvertPolymakeScalarToGAP,
NEIGHBORLINESS:=ConvertPolymakeScalarToGAP,
NEIGHBORLY:=ConvertPolymakeBoolToGAP,
MINIMAL_VERTEX_ANGLE:=ConvertPolymakeScalarToGAP,
POINTED:=ConvertPolymakeBoolToGAP,
POINTS:=ConvertPolymakeMatrixToGAPKillOnes,
POSITIVE:=ConvertPolymakeBoolToGAP,
REL_INT_POINT:=ConvertPolymakeVectorToGAPKillOne,
SELF_DUAL:=ConvertPolymakeBoolToGAP,
SIMPLE:=ConvertPolymakeBoolToGAP,
SIMPLICIAL:=ConvertPolymakeBoolToGAP,
VALID_POINT:=ConvertPolymakeVectorToGAPKillOne,
VERTEX_BARYCENTER:=ConvertPolymakeVectorToGAPKillOne,
VERTEX_DEGREES:=ConvertPolymakeVectorToGAP,
VERTICES:=ConvertPolymakeMatrixToGAPKillOnes,
VERTICES_IN_FACETS:=ConvertPolymakeListOfSetsToGAPPlusOne,
VOLUME:=ConvertPolymakeScalarToGAP,
));
polymaking-0.8.7/lib/workaround_maps.gd 000644 000766 000024 00000002040 14507124632 020464 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W workaround_maps.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareOperation("MapKeyWordToPolymakeFormat",[IsString]);
DeclareOperation("MapKeyWordFromPolymakeFormat",[IsString]); polymaking-0.8.7/lib/Objects.gd 000644 000766 000024 00000003677 14507124632 016663 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W Objects.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareCategory("IsPolymakeObject",IsObject);
DeclareRepresentation("IsPolymakeObjectRep",
IsComponentObjectRep,
["dir",
"filename",
"knownProperties"]
);
#
#Extracting Information:
#####################
DeclareOperation("DirectoryOfPolymakeObject",[IsPolymakeObject]);
DeclareOperation("FilenameOfPolymakeObject",[IsPolymakeObject]);
DeclareOperation("FullFilenameOfPolymakeObject",[IsPolymakeObject]);
DeclareOperation("KnownPropertiesOfPolymakeObject",[IsPolymakeObject]);
DeclareOperation("NamesKnownPropertiesOfPolymakeObject",[IsPolymakeObject]);
DeclareOperation("PropertyOfPolymakeObject",[IsPolymakeObject,IsString]);
#
#Manipulating contents of a polygon:
###############################
DeclareOperation("ClearPolymakeObject",[IsPolymakeObject]);
DeclareOperation("ClearPolymakeObject",[IsPolymakeObject,IsDenseList]);
DeclareOperation("UnbindKnownPropertyOfPolymakeObject",[IsPolymakeObject,IsString]);
DeclareOperation("WriteKnownPropertyToPolymakeObject",[IsPolymakeObject,IsString,IsObject]); polymaking-0.8.7/lib/convert.gi 000644 000766 000024 00000031507 14507124632 016750 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W convert.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
InstallMethod(ConvertPolymakeOutputToGapNotation,[IsString],
function(string)
local split, blockpositions, splitblocks, returnlist,
splitblock, name, rest, object;
splitblocks:=SplitPolymakeOutputStringIntoBlocks(string);
returnlist:=[];
for splitblock in splitblocks
do
name:=NormalizedWhitespace(splitblock[1]);
if Size(splitblock) < 2
then
Info(InfoPolymaking,2,"No data for ", name,". Record not updated for this block");
UpdatePolymakeFailReason(Concatenation("polymake returned ",name," empty"));
Add(returnlist, rec(name:=name,object:=fail));
continue;
fi;
rest:=splitblock{[2..Maximum(Size(splitblock),2)]};
if rest[Size(rest)]=""
then
Unbind(rest[Size(rest)]);
fi;
# Apply(rest,NormalizedWhitespace);
if rest=["==UNDEF=="]
then
Info(InfoPolymaking,1,Concatenation("polymake declares object ",name," undefined"));
UpdatePolymakeFailReason(Concatenation("polymake declares ",name," undefined"));
Add(returnlist,rec(name:=name,object:=fail));
elif IsBound(ObjectConverters.(name))
then
object:=ObjectConverters.(name)(rest);
if object<>fail
then
Add(returnlist,rec(name:=name,object:=object));
else
Info(InfoPolymaking,1,"Conversion failed. Maybe invalid output from polymake. Record not updated for this block");
Add(returnlist, rec(name:=name,object:=fail));
fi;
else
Info(InfoPolymaking,1,"No Method to convert ", name,". Record not updated for this block");
UpdatePolymakeFailReason(Concatenation("polymaking doesn't know how to convert ",name," to GAP"));
Add(returnlist, rec(name:=name,object:=fail));
fi;
od;
return returnlist;
end);
#
#First the method to split polymake's output into different blocks by
# recognizing lines which may be keyword-lines
###############
InstallMethod(SplitPolymakeOutputStringIntoBlocks,[IsString],
function(string)
local blocks, newblock, lines, line;
blocks:=[];
newblock:=[];
lines:=SplitString(string,"\n");
while lines<>[]
do
line:=Remove(lines,1);
if not IsEmptyString(line)
then
if IsUpperAlphaChar(line[1])
and ForAll(line,c->IsUpperAlphaChar(c) or c in ['_','-','>'] or IsDigitChar(c))
then
if blocks=[] and newblock=[]
then
newblock:=[MapKeyWordFromPolymakeFormat(line)];
else
Add(blocks,ShallowCopy(newblock));
newblock:=[MapKeyWordFromPolymakeFormat(line)];
fi;
else
Add(newblock,line);
fi;
fi;
od;
if newblock<>[]
then
Add(blocks,newblock);
fi;
return blocks;
end);
#############################################################################
##
## update the fail reason in case of syntax errors:
##
InstallMethod(ConverterSyntaxError,[IsString],
function(methname)
UpdatePolymakeFailReason(
Concatenation("input for converter method ",methname, " syntactically incorrect (cast an error and went into break loop)")
);
Error("incorrect input");
end);
#############################################################################
# Now the different conversion methods:
#############################################################################
##
## Basics, numbers and bools:
##
InstallMethod(ConvertPolymakeNumber,[IsString],
function(string)
local sstring, denom, enum;
if '.' in string
then
Info(InfoPolymaking,1,"Warning!converting a floating point number");
sstring:=SplitString(string,".");
denom:=10^(Length(sstring[2]));
enum:=Int(Concatenation(sstring));
return enum/denom;
elif string=""
then
ConverterSyntaxError("ConvertPolymakeNumber");
return fail;
else
return Rat(string);
fi;
end);
InstallMethod(ConvertPolymakeScalarToGAP,[IsDenseList],
function(stringlist)
if Size(stringlist)<>1
then
ConverterSyntaxError("ConvertPolymakeScalarToGAP");
return fail;
else
return ConvertPolymakeNumber(stringlist[1]);
fi;
end);
InstallMethod(ConvertPolymakeBoolToGAP,[IsDenseList],
function(stringlist)
if Size(stringlist)<>1
then
ConverterSyntaxError("ConvertPolymakeBoolToGAP");
return fail;
elif stringlist[1]="1" or stringlist[1]="true"
then
return true;
elif stringlist[1]="0" or stringlist[1]="false"
then
return false;
else
UpdatePolymakeFailReason("Boolean conversion failed, the returned value wasn't 0, 1, true, or false. Error cast");
Error("Conversion failed");
fi;
end);
InstallMethod(ConvertPolymakeDescriptionToGAP,[IsDenseList],
function(stringlist)
return JoinStringsWithSeparator(stringlist," ");
end);
#############################################################################
##
## MATRICES AND LISTS OF SETS:
##
## Unfortunately some of the keywords that return matrices
## might also return lists of sets (this is a polytope/topaz problem).
## So we try to guess the type if necessary.
##
InstallMethod(ConvertPolymakeMatrixOrListOfSetsToGAP,[IsDenseList],
function(stringlist)
if ForAll(stringlist,i->i[1]='{')
then
return ConvertPolymakeListOfSetsToGAP(stringlist);
elif ForAll(stringlist,i->not ('{' in i or '}' in i))
then
return ConvertPolymakeMatrixToGAP(stringlist);
else
UpdatePolymakeFailReason("ConvertPolymakeMatrixOrListOfSetsToGAP couldn't decide what to do. Error cast");
Error("don't know if this is a matrix or a list of sets ");
return fail;
fi;
end);
InstallMethod(ConvertPolymakeMatrixOrListOfSetsToGAPPlusOne,[IsDenseList],
function(stringlist)
if ForAll(stringlist,i->i[1]='{')
then
return ConvertPolymakeListOfSetsToGAPPlusOne(stringlist);
elif ForAll(stringlist,i->not ('{' in i or '}' in i))
then
return ConvertPolymakeMatrixToGAP(stringlist);
else
UpdatePolymakeFailReason("ConvertPolymakeMatrixOrListOfSetsToGAP couldn't decide what to do. Error cast");
Error("don't know if this is a matrix or a list of sets ");
return fail;
fi;
end);
InstallMethod(ConvertPolymakeMatrixToGAP,[IsDenseList],
function(stringlist)
local returnmatrix, string, vector;
returnmatrix:=[];
for string in stringlist
do
vector:=SplitString(string," ");
Apply(vector,ConvertPolymakeNumber);
Add(returnmatrix,vector);
od;
return returnmatrix;
end);
InstallMethod(ConvertPolymakeMatrixToGAPKillOnes,[IsDenseList],
function(stringlist)
local returnmatrix;
returnmatrix:=ConvertPolymakeMatrixToGAP(stringlist);
if not IsMatrix(returnmatrix)
or Size(returnmatrix[1])<2
or not ForAll(returnmatrix,i->i[1]=1)
then
Error("returnmatrix is not a matrix or too small");
UpdatePolymakeFailReason("Error in ConvertPolymakeMatrixToGAPKillOnes. The returned object is either not a matrix, has fewer than 2 columns or doesn't have all ones in the first column. (Error cast)");
return fail;
fi;
if returnmatrix<>fail
then
return List(returnmatrix,i->i{[2..Size(i)]}); #kill leading ones
else
return fail;
fi;
end);
#############################################################################
##
## Vectors
##
InstallMethod(ConvertPolymakeVectorToGAP,[IsDenseList],
function(stringlist)
local vector;
if Size(stringlist)<>1
then
ConverterSyntaxError("ConvertPolymakeVectorToGAP");
return fail;
else
vector:=SplitString(stringlist[1]," ");
Apply(vector,ConvertPolymakeNumber);
return vector;
fi;
end);
InstallMethod(ConvertPolymakeVectorToGAPKillOne,[IsDenseList],
function(stringlist)
local vector;
vector:=ConvertPolymakeVectorToGAP(stringlist);
if not IsVector(vector) or Size(vector)<2
or vector[1]<>1
then
Error("vector is not a vector or too small");
UpdatePolymakeFailReason("Error in ConvertPolymakeVectorToGAPKillOne. The returned object is either not a vector or has fewer than 2 columns or doesn't start with 1. (Error cast)");
return fail;
fi;
return vector{[2..Size(vector)]};
end);
InstallMethod(ConvertPolymakeIntVectorToGAPPlusOne,[IsDenseList],
function(stringlist)
local vec;
vec:=ConvertPolymakeVectorToGAP(stringlist);
if not ForAll(vec,IsInt)
then
Error("Vector is not a vector of integers as expected");
UpdatePolymakeFailReason("Error in ConvertPolymakeIntVectorToGAPPlusOne. The returned vector did not consist of integers. Error cast");
return fail;
else
return vec+1;
fi;
end);
#############################################################################
##
## Sets, Sets of Sets, Lists of Sets
##
InstallMethod(ConvertPolymakeSetToGAP,[IsDenseList],
function(stringlist)
local entries;
if not Size(stringlist)=1 and IsString(stringlist[1])
then
ConverterSyntaxError("ConvertPolymakeSetToGAP");
return fail;
else
entries:=ReplacedString(ReplacedString(stringlist[1],"{",""),"}","");
entries:=Set(SplitString(entries," "));
RemoveSet(entries,"");
return Set(entries,ConvertPolymakeNumber);
fi;
end);
InstallMethod(ConvertPolymakeSetOfSetsToGAP,[IsDenseList],
function(stringlist)
local returnlist, line, newlist, entry;
returnlist:=[];
if Size(stringlist)<> 1 or not IsString(stringlist[1])
then
ConverterSyntaxError("ConvertPolymakeSetOfSetsToGAP");
return fail;
fi;
line:=stringlist[1];
newlist:=ReplacedString(line{[2..Size(line)-1]},"} {","},{");
newlist:=SplitString(newlist,",");
for entry in newlist
do
Add(returnlist,ConvertPolymakeSetToGAP([entry]));
od;
return returnlist;
end);
InstallMethod(ConvertPolymakeListOfSetsToGAP,[IsDenseList],
function(stringlist)
return List(stringlist,s->ConvertPolymakeSetToGAP([s]));
end);
InstallMethod(ConvertPolymakeListOfSetsToGAPPlusOne,[IsDenseList],
function(stringlist)
return List(stringlist,s->ConvertPolymakeSetToGAP([s])+1);
end);
#############################################################################
##
## More complex stuff:
##
#############################################################################
##
## Graphs:
##
InstallMethod(ConvertPolymakeGraphToGAP,[IsDenseList],
function(stringlist)
local edgelist, edge, vertices;
edgelist:=[];
for edge in stringlist
do
# verts:=ReplacedString(ReplacedString(edge,"{",""),"}","");
# verts:=SplitString(verts," ");
Add(edgelist,ConvertPolymakeSetToGAP(edge));
od;
vertices:=Set(Flat(edgelist));
return rec(vertices:=vertices,edges:=Set(edgelist));
end);
#############################################################################
##
## Face Lattices:
##
InstallMethod(ConvertPolymakeFaceLatticeToGAP,[IsDenseList],
function(stringlist)
local returnlist, line, faces;
returnlist:=[];
for line in stringlist
do
if line<>"" and line[1]='{'
then
faces:=Set(ConvertPolymakeSetOfSetsToGAP([line]));
Apply(faces,i->i+1);
Add(returnlist,faces);
fi;
od;
return returnlist;
end);
#############################################################################
##
#E END of file convert.gi
##
polymaking-0.8.7/lib/construct.gi 000644 000766 000024 00000025344 14507124632 017316 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W construct.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
# just create an empty file:
InstallMethod(CreateEmptyFile,[IsString],
function(name)
PrintTo(name,"");
end);
InstallMethod(InitPolymakeObject,[IsPolymakeObject],
function(poly)
local appstring;
# In polymake 4.1 this is required.
appstring:=Concatenation(
"_application polytope\n",
"_type Polytope\n\n"
);
AppendToPolymakeObject(poly, appstring);
return poly;
end);
# create a (possibly empty) polygon.
# That is, a record just containing the name of a file to use with polymake.
# If the file does not exist, it is created.
####################
InstallMethod(CreatePolymakeObjectFromFile,[IsString],
function(name)
return CreatePolymakeObjectFromFile(POLYMAKE_DATA_DIR, name);
end);
InstallMethod(CreatePolymakeObjectFromFile,[IsDirectory,IsString],
function(dir,name)
local filename, rtn, polygon;
rtn:=Objectify(PolymakeObject,rec(filename:=name,dir:=dir));
filename:=Filename(dir,name);
if not IsExistingFile(filename)
then
CreateEmptyFile(filename);
InitPolymakeObject(rtn);
fi;
return rtn;
end);
InstallMethod(CreatePolymakeObject,[IsString,IsDirectory],
function(prefix,dir)
local name, i, newname;
name:=Concatenation(prefix,String(Runtime()));
if IsExistingFile(Filename(dir,name))
then
i:=1;
repeat
newname:=Concatenation([name,".",String(i)]);
i:=i+1;
until not IsExistingFile(Filename(dir,newname));
else
newname:=name;
fi;
return CreatePolymakeObjectFromFile(dir,newname);
end);
InstallMethod(CreatePolymakeObject,[IsString,IsDirectory,IsDenseList],
function(prefix,dir,appvertyp)
local poly;
poly:=CreatePolymakeObject(prefix,dir);
ClearPolymakeObject(poly,appvertyp);
return poly;
end);
InstallMethod(CreatePolymakeObject,[IsDirectory],
function(dir)
local name, i, newname;
return CreatePolymakeObject("poly",dir);
end);
InstallMethod(CreatePolymakeObject,[IsDirectory,IsDenseList],
function(dir,appvertyp)
local poly;
poly:=CreatePolymakeObject(dir);
ClearPolymakeObject(poly,appvertyp);
return poly;
end);
InstallMethod(CreatePolymakeObject,[],
function()
local dir, name;
return CreatePolymakeObject(POLYMAKE_DATA_DIR);
end);
InstallMethod(CreatePolymakeObject,[IsDenseList],
function(appvertyp)
local poly;
poly:=CreatePolymakeObject();
ClearPolymakeObject(poly,appvertyp);
return poly;
end);
InstallMethod(AppendToPolymakeObject,[IsPolymakeObject,IsString,IsString],
function(poly,keyword,data)
local string;
string:=ShallowCopy(keyword);
while string[Size(string)] in ['\n','\r','\c']
do
Unbind(string[Size(string)]);
od;
string:=Concatenation(keyword,"\n",data);
while string[Size(string)] in ['\n','\r','\c']
do
Unbind(string[Size(string)]);
od;
Add(string,'\n');
AppendToPolymakeObject(poly,string);
end);
InstallMethod(AppendToPolymakeObject,[IsPolymakeObject,IsString],
function(poly,string)
local file, retval;
#file:=IO_File(record.filename,"w");
#retval:=IO_WriteFlush(file,string);
file:=OutputTextFile(FullFilenameOfPolymakeObject(poly),true);
#SetPrintFormattingStatus(file,false);
retval:=WriteAll(file,string);
if not retval
then
Error("Error writing file");
fi;
CloseStream(file);
end);
InstallMethod(ConvertMatrixToPolymakeString,[IsString,IsDenseList],
function(name,matrix)
local dim, string, point, stringpoint;
dim:=Size(matrix[1]);
if not ForAll(matrix,point->Size(point)=dim)
then
Error("not all rows have the same dimension");
elif not ForAll(Concatenation(matrix),IsRat)
then
Error("matrix contains non-rational entries.");
fi;
string:=ShallowCopy(name);
Append(string,"\n");
for point in matrix
do
stringpoint:=JoinStringsWithSeparator(List(point,String)," ");
Append(string,stringpoint);
Append(string,"\n");
od;
Append(string,"\n");
return string;
end);
# Now a few functions for convenience:
InstallMethod(AppendPointlistToPolymakeObject,[IsPolymakeObject,IsDenseList],
function(polygon,pointlist)
local list, point,string;
list:=[];
for point in pointlist
do
Add(list,Concatenation([1],point));
od;
string:=ConvertMatrixToPolymakeString("POINTS",list);
AppendToPolymakeObject(polygon,string);
end);
InstallMethod(AppendVertexlistToPolymakeObject,[IsPolymakeObject,IsDenseList],
function(polygon,pointlist)
local list, point,string;
list:=[];
for point in pointlist
do
Add(list,Concatenation([1],point));
od;
string:= ConvertMatrixToPolymakeString("VERTICES",list);
AppendToPolymakeObject(polygon,string);
end);
InstallMethod(AppendInequalitiesToPolymakeObject,[IsPolymakeObject,IsDenseList],
function(polygon,ineqlist)
AppendToPolymakeObject(polygon,ConvertMatrixToPolymakeString("INEQUALITIES",ineqlist));
end);
##############################
# Call polymake. If the option "PolymakeNolookup" is true,
# it is not checked, whether Polymake has already been called
# with this option (however, the polymake program will check
# this by looking at the file associated to ).
#
InstallMethod(Polymake,"for PolymakeObject",[IsPolymakeObject,IsString],
function(polygon,option)
local callPolymake, gapobject, splitoption, knownProperties,
returnval, returnedstring, block;
callPolymake:=function(object,splitoption)
local returnedstring, pkgdir, scriptarg, stdout, stdin, dir, exitstatus;
returnedstring:=[];
scriptarg:=["--config-path","", "--script",
Filename(DirectoriesPackageLibrary("polymaking"), "pm_script_arg.pl")];
stdout:=OutputTextString(returnedstring,false);
stdin:=InputTextNone();;
dir:=DirectoryOfPolymakeObject(object);
if dir=fail
then
dir:=DirectoryCurrent();
fi;
exitstatus:=Process( dir, POLYMAKE_COMMAND, stdin, stdout,
Concatenation(scriptarg, [FullFilenameOfPolymakeObject(object)],
splitoption)
);;
CloseStream(stdout);
CloseStream(stdin);
return rec(status:=exitstatus,string:=returnedstring);
end;
gapobject:=[];
option:=NormalizedWhitespace(option);
splitoption:=SplitString(option," ");
knownProperties:=NamesKnownPropertiesOfPolymakeObject(polygon);
returnval:=[];
Info(InfoPolymaking,2,"option=",option);
Info(InfoPolymaking,2,"Size(splitoption)=",Size(splitoption));
if Size(splitoption)=0
then
Error("you must pass an option to polymake");
elif Size(splitoption)=1
then
if ValueOption("PolymakeNolookup") in [fail,false]
and knownProperties<>fail
and splitoption[1] in knownProperties
then
returnval:=PropertyOfPolymakeObject(polygon,splitoption[1]);
else
Apply(splitoption, MapKeyWordToPolymakeFormat);
returnedstring:=callPolymake(polygon,splitoption);
Info(InfoPolymaking,2,String(returnedstring));
if returnedstring.status <>0
then
Error("polymake returned an error (error code ", returnedstring.status, ")");
UpdatePolymakeFailReason(Concatenation("polymake terminated with exit status ",String(returnedstring.status)));
returnval:=fail;
elif returnedstring.string<>[]
then
Info(InfoPolymaking,2,returnedstring.string);
gapobject:=ConvertPolymakeOutputToGapNotation(returnedstring.string);
if gapobject[1].object<>fail
then
WriteKnownPropertyToPolymakeObject(polygon,gapobject[1].name,gapobject[1].object);
returnval:=gapobject[1].object;
else
returnval:=fail;
fi;
else
UpdatePolymakeFailReason("polymake did not return anything");
returnval:=fail;
fi;
fi;
else
# we return fail, whatever happens.
## only the reason may change...
###
returnval:=fail;
UpdatePolymakeFailReason("polymake called with multiple keywords");
if ValueOption("PolymakeNolookup") in [fail,false]
and knownProperties<>fail
then
splitoption:=Filtered(splitoption,i->not i in knownProperties);
fi;
if Size(splitoption)>0
then
Apply(splitoption, MapKeyWordToPolymakeFormat);
returnedstring:=callPolymake(polygon,splitoption);
if returnedstring.status <>0
then
Error("polymake returned an error");
UpdatePolymakeFailReason(Concatenation("polymake terminated with exit status ",String(returnedstring.status)));
elif returnedstring<>[]
then
Info(InfoPolymaking,2,returnedstring.string);
gapobject:=ConvertPolymakeOutputToGapNotation(returnedstring.string);
for block in Filtered(gapobject,i->i.object<>fail)
do
WriteKnownPropertyToPolymakeObject(polygon,block.name,block.object);
od;
else
UpdatePolymakeFailReason("polymake didn't return anything. All keywords that would have triggered output were looked up.");
fi;
fi;
fi;
return returnval;
end);
polymaking-0.8.7/lib/environment.gi 000644 000766 000024 00000004722 14507124632 017633 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W environment.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
SetInfoLevel(InfoPolymaking,1);
# give the command which calls polymake. You may need to include the full path
####
if not IsBound(POLYMAKE_COMMAND)
then
POLYMAKE_COMMAND:=Filename( DirectoriesSystemPrograms( ), "polymake" );
fi;
if POLYMAKE_COMMAND=fail
or not IsExecutableFile(POLYMAKE_COMMAND)
then
Info(InfoWarning,1,"polymake command not found. Please set POLYMAKE_COMMAND by hand");
else
MakeReadOnlyGlobal("POLYMAKE_COMMAND");
fi;
InstallMethod(SetPolymakeCommand,[IsString],
function(command)
if not IsExecutableFile(command)
then
Error("polymake command must exist and be executable.");
else
MakeReadWriteGlobal("POLYMAKE_COMMAND");
POLYMAKE_COMMAND:=command;
MakeReadOnlyGlobal("POLYMAKE_COMMAND");
fi;
end);
#
# This directory will hold the files generated for polymake
# It can be changed using "SetPolymakeDataDirectory"
###
if not IsBound(POLYMAKE_DATA_DIR)
then
POLYMAKE_DATA_DIR:=DirectoryTemporary();
fi;
MakeReadOnlyGlobal("POLYMAKE_DATA_DIR");
InstallMethod(SetPolymakeDataDirectory,[IsDirectory],
function(dir)
MakeReadWriteGlobal("POLYMAKE_DATA_DIR");
POLYMAKE_DATA_DIR:=dir;
MakeReadOnlyGlobal("POLYMAKE_DATA_DIR");
end);
####
###
## Handling of last fail reason:
#
InstallValue(POLYMAKE_LAST_FAIL_REASON,"");
InstallMethod(UpdatePolymakeFailReason,[IsString],
function(reason)
MakeReadWriteGlobal("POLYMAKE_LAST_FAIL_REASON");
POLYMAKE_LAST_FAIL_REASON:=reason;
MakeReadOnlyGlobal("POLYMAKE_LAST_FAIL_REASON");
end);
polymaking-0.8.7/lib/application_version_type.gi 000644 000766 000024 00000003701 14507124632 022374 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W application_version_type.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
InstallMethod(CheckAppVerTypList,[IsDenseList],
function(appvertyp)
local app, type;
if Size(appvertyp)<>3
or not ForAll(appvertyp,IsString)
then
return false;
fi;
## test applicateion and possible data types:
app:=NormalizedWhitespace(appvertyp[1]);
type:=NormalizedWhitespace(appvertyp[3]);
if app = "polytope"
then
if not type in ["Polytope",
"RationalPolytope",
"FloatPolytope",
"SchlegelDiagram",
"VoronoiDiagram",
"TightSpan",
"PropagatedPolytope",
"Framework"
]
then
return false;
fi;
elif app="surface"
then
if not type="Surface"
then
return false;
fi;
elif app="topaz"
then
if not type="SimplicialComplex"
then
return false;
fi;
fi;
return true;
end); polymaking-0.8.7/lib/ObjectConverters.gd 000644 000766 000024 00000002031 14507124632 020532 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W ObjectConverters.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareGlobalVariable("ObjectConverters","Functions to convert polymake output to gap");
polymaking-0.8.7/lib/workaround_maps.gi 000644 000766 000024 00000004346 14507124632 020504 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W workaround_maps.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
###########
# This is a workaround for the next-generation polymake
# there we need to call keywords of the form "HASSE_DIAGRAM->FACES"
# and that does not work as an entry of a record. So we have do do
# some extra mapping (yes, it is a hack).
##
# direction of the mapping: GAP keyword mapped to polymake keyword
#######
InstallMethod(MapKeyWordToPolymakeFormat,"for PolymakeObject",[IsString],
function(option)
if option = "FACES" then
return "HASSE_DIAGRAM->FACES";
elif option = "DIMS" then
return "HASSE_DIAGRAM->DIMS";
elif option = "ADJACENCY" then
return "HASSE_DIAGRAM->ADJACENCY";
else
return option;
fi;
end);
##########
# This is a workaround for the next-generation polymake
# there we need to call keywords of the form "HASSE_DIAGRAM->FACES"
# and that does not work as an entry of a record. So we have do do
# some extra mapping (yes, it is a hack).
##
# direction: Polymake output mapped to GAP keywords
#######
InstallMethod(MapKeyWordFromPolymakeFormat,"for PolymakeObject",[IsString],
function(option)
if option = "HASSE_DIAGRAM->FACES" then
return "FACES";
elif option = "HASSE_DIAGRAM->DIMS" then
return "DIMS";
elif option = "HASSE_DIAGRAM->ADJACENCY" then
return "ADJACENCY";
else
return option;
fi;
end);
polymaking-0.8.7/lib/convert.gd 000644 000766 000024 00000004407 14507124632 016742 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W convert.gd polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
DeclareOperation("ConvertPolymakeOutputToGapNotation",[IsString]);
DeclareOperation("SplitPolymakeOutputStringIntoBlocks",[IsString]);
DeclareOperation("ConvertedObject",[IsString,IsDenseList]);
DeclareOperation("ConverterSyntaxError",[IsString]);
DeclareOperation("ConvertPolymakeNumber",[IsString]);
DeclareOperation("ConvertPolymakeScalarToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeBoolToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeDescriptionToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeMatrixOrListOfSetsToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeMatrixOrListOfSetsToGAPPlusOne",[IsDenseList]);
DeclareOperation("ConvertPolymakeMatrixToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeMatrixToGAPKillOnes",[IsDenseList]);
DeclareOperation("ConvertPolymakeVectorToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeVectorToGAPKillOne",[IsDenseList]);
DeclareOperation("ConvertPolymakeIntVectorToGAPPlusOne",[IsDenseList]);
DeclareOperation("ConvertPolymakeSetToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeListOfSetsToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeListOfSetsToGAPPlusOne",[IsDenseList]);
DeclareOperation("ConvertPolymakeSetOfSetsToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeGraphToGAP",[IsDenseList]);
DeclareOperation("ConvertPolymakeFaceLatticeToGAP",[IsDenseList]);
polymaking-0.8.7/lib/Objects.gi 000644 000766 000024 00000014053 14507124632 016656 0 ustar 00mhorn staff 000000 000000 #############################################################################
##
#W Objects.gi polymaking Package Marc Roeder
##
##
##
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
PolymakeObjectFamily:=NewFamily("PolymakeObjectFamily",IsPolymakeObject);
PolymakeObject:=NewType(PolymakeObjectFamily,IsPolymakeObjectRep);
######################################################################
# The following methods are the only ones which manipulate the contents
# of a PolymakeObject.
# There are no other functions containing things like
#
######################################################################
# Printing Polymake Objects nicely:
#
InstallMethod(ViewObj,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
local compnames;
compnames:=NamesOfComponents(poly);
if "knownProperties" in compnames
and "DESCRIPTION" in NamesKnownPropertiesOfPolymakeObject(poly)
then
Print("<",PropertyOfPolymakeObject(poly,"DESCRIPTION"));
else
Print("");
end);
InstallMethod(PrintObj,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
local compnames;
compnames:=NamesOfComponents(poly);
if "knownProperties" in compnames
and "DESCRIPTION" in NamesKnownPropertiesOfPolymakeObject(poly)
then
Print("<",PropertyOfPolymakeObject(poly,"DESCRIPTION"));
else
Print("\n");
end);
######################################################################
#
# Extracting data from objects:
#
# the DIRECTORY:
InstallMethod(DirectoryOfPolymakeObject,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
return poly!.dir;
end);
# the FILENAME:
InstallMethod(FilenameOfPolymakeObject,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
return poly!.filename;
end);
#the FILENAME with full path:
InstallMethod(FullFilenameOfPolymakeObject,
[IsPolymakeObject],
function(poly)
return Filename(DirectoryOfPolymakeObject(poly),FilenameOfPolymakeObject(poly));
end);
# the KNOWN PROPERTIES:
InstallMethod(KnownPropertiesOfPolymakeObject,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
if not "knownProperties" in NamesOfComponents(poly)
then
return fail;
elif Size(RecNames(poly!.knownProperties))=0
then
return fail;
else
return poly!.knownProperties;
fi;
end);
# just the names of the KNOWN PROPERTIES:
InstallMethod(NamesKnownPropertiesOfPolymakeObject,
"for PolymakeObject",
[IsPolymakeObject],
function(poly)
if not "knownProperties" in NamesOfComponents(poly)
then
return fail;
elif Size(RecNames(poly!.knownProperties))=0
then
return fail;
else
return RecNames(poly!.knownProperties);
fi;
end);
# individual properties from KNOWN PROPERTIES:
InstallMethod(PropertyOfPolymakeObject,
[IsPolymakeObject,IsString],
function(poly,name)
local known;
known:=NamesKnownPropertiesOfPolymakeObject(poly);
if known=fail or not name in known
then
return fail;
else
return poly!.knownProperties.(name);
fi;
end);
######################################################################
# Changing the things we know about a object:
#
# Deleting files and clearing known data
#
InstallMethod(ClearPolymakeObject,
[IsPolymakeObject],
function(poly)
CreateEmptyFile(FullFilenameOfPolymakeObject(poly));
Unbind(poly!.knownProperties);
end);
# clear known data. Clear file and then set application, version,type
# information
InstallMethod(ClearPolymakeObject,
[IsPolymakeObject,IsDenseList],
function(poly,appvertyp)
local appendstring;
if not CheckAppVerTypList(appvertyp)
then
Error("application, version, type not well-formed");
fi;
CreateEmptyFile(FullFilenameOfPolymakeObject(poly));
Unbind(poly!.knownProperties);
appendstring:=Concatenation(["_application ",appvertyp[1],"\n",
"_version ",appvertyp[2],"\n",
"_type ",appvertyp[3],"\n"]
);
AppendToPolymakeObject(poly,appendstring);
end);
# Deleting a something known:
#
InstallMethod(UnbindKnownPropertyOfPolymakeObject,
[IsPolymakeObject,IsString],
function(poly,name)
local knownProperties;
knownProperties:=KnownPropertiesOfPolymakeObject(poly);
if knownProperties=fail or not name in knownProperties
then
return fail;
else
Unbind(poly!.knownProperties.(name));
fi;
end);
# Write a property:
#
InstallMethod(WriteKnownPropertyToPolymakeObject,
[IsPolymakeObject,IsString,IsObject],
function(poly,name,data)
if not "knownProperties" in NamesOfComponents(poly)
then
poly!.knownProperties:=rec();
fi;
poly!.knownProperties.(name):=data;
end);