Coverage for local/lib/python2.7/site-packages/sage/interfaces/polymake.py: 5%

assert i==0, "Command '{}': Couldn't return to normal prompt after polymake {}. Instead, polymake {}".format(line,_available_polymake_answers[pat],_available_polymake_answers[i])

raise SyntaxError("Incomplete polymake command '{}'".format(line))

elif pat == 2: # request for user interaction

# Return to normal prompt

warnings.warn("{} expects user interaction. We abort and return the options that {} provides.".format(self,self))

i = pat

while i:

self._expect.send(chr(3))

sleep(0.1)

i = self._expect.expect(self._prompt, timeout=0.1)

# User interaction is expected to happen when requesting help

if line.startswith('help'):

out = os.linesep.join(out.split(os.linesep)[:-1])

break

else:

RuntimeError("Polymake unexpectedly {}".format(_available_polymake_answers[pat]))

elif pat == 3: # killed by signal

i = pat

while pat != 0:

E.send(chr(3))

sleep(0.1)

i = E.expect_list(self._prompt)

RuntimeError("Polymake unexpectedly {}".format(_available_polymake_answers[pat]))

elif pat == 4: # polymake error

have_error = True

elif pat == 5: # polymake warning

have_warning = True

elif pat == 6: # apparently polymake prints a comment

have_log = True

elif pat == 7: # we have reached the end of the buffer

warnings.warn("Polymake unexpectedly {}".format(_available_polymake_answers[pat]), RuntimeWarning)

E.buffer = E.before + E.after + E.buffer

break

else: # timeout or some other problem

# Polymake would still continue with the computation. Thus, we send an interrupt

E.send(chr(3))

sleep(0.1)

while E.expect_list(self._prompt, timeout=0.1):

# ... and since a single Ctrl-c just interrupts *one* of polymake's

# rule chains, we repeat until polymake is running out of rules.

E.send(chr(3))

sleep(0.1)

raise RuntimeError("Polymake {}".format(_available_polymake_answers[pat]))

else:

out = ''

except KeyboardInterrupt:

self._keyboard_interrupt()

raise KeyboardInterrupt("Ctrl-c pressed while running %s"%self)

for w in p_warnings:

warnings.warn(w, RuntimeWarning)

for e in p_errors:

raise PolymakeError(e)

return out

def _tab_completion(self):

"""

Returns a list of polymake function names.

NOTE:

- The list of functions depends on the current application. The

result is cached, of course separately for each application.

- It is generally not the case that all the returned function names

can actually successfully be called.

TESTS::

sage: polymake.application('fan') # optional - polymake

sage: 'normal_fan' in dir(polymake) # optional - polymake # indirect doctest

True

sage: polymake.quit() # optional - polymake

sage: polymake._start() # optional - polymake

Since 'normal_fan' is not defined in the polymake application 'polytope',

we now get

sage: 'normal_fan' in dir(polymake) # optional - polymake

False

"""

if not self.is_running():

self._start()

try:

return self.__tab_completion[self._application]

except KeyError:

pass

s = self.eval("apropos '';").split(self._expect.linesep)

out = []

for name in s:

if name.startswith("/function"):

out.append(name.split("/")[-1])

self.__tab_completion[self._application] = sorted(out)

return self.__tab_completion[self._application]

# Polymake specific methods

def application(self, app):

"""

Change to a given polymake application.

INPUT:

- ``app``, a string, one of "common", "fulton", "group", "matroid", "topaz",

"fan", "graph", "ideal", "polytope", "tropical"

EXAMPLES:

We expose a computation that uses both the 'polytope' and the 'fan'

application of polymake. Let us start by defining a polytope `q` in

terms of inequalities. Polymake knows to compute the f- and h-vector

and finds that the polytope is very ample::

sage: q = polymake.new_object("Polytope", INEQUALITIES=[[5,-4,0,1],[-3,0,-4,1],[-2,1,0,0],[-4,4,4,-1],[0,0,1,0],[8,0,0,-1],[1,0,-1,0],[3,-1,0,0]]) # optional - polymake

sage: q.H_VECTOR # optional - polymake

1 5 5 1

sage: q.F_VECTOR # optional - polymake

8 14 8

sage: q.VERY_AMPLE # optional - polymake

In the application 'fan', polymake can now compute the normal fan

of `q` and its (primitive) rays::

sage: polymake.application('fan') # optional - polymake

sage: g = q.normal_fan() # optional - polymake

sage: g.RAYS # optional - polymake

-1 0 1/4

0 -1 1/4

1 0 0

1 1 -1/4

0 1 0

0 0 -1

0 -1 0

-1 0 0

sage: g.RAYS.primitive() # optional - polymake

-4 0 1

0 -4 1

1 0 0

4 4 -1

0 1 0

0 0 -1

0 -1 0

-1 0 0

Note that the list of functions available by tab completion depends

on the application.

TESTS:

Since 'tubing_of_graph' is not defined in the polymake application 'polytope'

but only in 'tropical', the following shows the effect of changing

the application. ::

sage: polymake.application('polytope') # optional - polymake

sage: 'tubing_of_graph' in dir(polymake) # optional - polymake

False

sage: polymake.application('tropical') # optional - polymake

sage: 'tubing_of_graph' in dir(polymake) # optional - polymake

True

sage: polymake.application('polytope') # optional - polymake

sage: 'tubing_of_graph' in dir(polymake) # optional - polymake

False

For completeness, we show what happens when asking for an application

that doesn't exist::

sage: polymake.application('killerapp') # optional - polymake

Traceback (most recent call last):

...

ValueError: Unknown polymake application 'killerapp'

Of course, a different error results when we send an explicit

command in polymake to change to an unknown application::

sage: polymake.eval('application "killerapp";') # optional - polymake

Traceback (most recent call last):

...

PolymakeError: Unknown application killerapp

"""

if not self.is_running():

self._start()

if app not in ["common", "fulton", "group", "matroid", "topaz", "fan", "graph", "ideal", "polytope", "tropical"]:

raise ValueError("Unknown polymake application '{}'".format(app))

self._application = app

patterns = ["{} > ".format(app), # 0: normal prompt

"{} $[0-9]+$> ".format(app), # 1: continuation prompt

"Please choose ".format(app), # 2: user input expected when requesting "help"

"killed by signal", # 3: what we are looking for when interrupting a computation

"polymake: +ERROR: +", # 4: error

"polymake: +WARNING: +", # 5: warning

"polymake: +", # 6: anything but an error or warning, thus, an information

pexpect.EOF, # 7: unexpected end of the stream

pexpect.TIMEOUT] # 8: timeout

self._change_prompt(self._expect.compile_pattern_list(patterns))

self._sendstr('application "{}";{}'.format(app, self._expect.linesep))

pat = self._expect.expect_list(self._prompt)

if pat:

raise RuntimeError("When changing the application, polymake unexpectedly {}".format(_available_polymake_answers[pat]))

def new_object(self, name, *args, **kwds):

"""

Return a new instance of a given polymake type, with given positional or named arguments.

INPUT:

- ``name`` of a polymake class (potentially templated), as string.

- further positional or named arguments, to be passed to the constructor.

EXAMPLES::

sage: q = polymake.new_object("Polytope<Rational>", INEQUALITIES=[[4,-4,0,1],[-4,0,-4,1],[-2,1,0,0],[-4,4,4,-1],[0,0,1,0],[8,0,0,-1]]) # optional - polymake

sage: q.N_VERTICES # optional - polymake

sage: q.BOUNDED # optional - polymake

sage: q.VERTICES # optional - polymake

1 2 0 4

1 3 0 8

1 2 1 8

1 3 1 8

sage: q.full_typename() # optional - polymake

'Polytope<Rational>'

"""

try:

f = self.__new[name]

except AttributeError:

self.__new = {}

f = self.__new[name] = self._function_class()(self, "new %s"%name)

except KeyError:

f = self.__new[name] = self._function_class()(self, "new %s"%name)

return f(*args, **kwds)

polymake = Polymake()

def reduce_load_Polymake():

"""

Returns the polymake interface object defined in :mod:`sage.interfaces.polymake`.

EXAMPLES::

sage: from sage.interfaces.polymake import reduce_load_Polymake

sage: reduce_load_Polymake()

Polymake

"""

return polymake

########################################

## Elements

from warnings import warn

class PolymakeElement(ExtraTabCompletion, ExpectElement):

"""

Elements in the polymake interface.

EXAMPLES:

We support all "big" polymake types, Perl arrays of length

different from one, and Perl scalars::

sage: p = polymake.rand_sphere(4, 20, seed=5) # optional - polymake

sage: p.typename() # optional - polymake

'Polytope'

sage: p # optional - polymake

Random spherical polytope of dimension 4; seed=5...

Now, one can work with that element in Python syntax, for example::

sage: p.VERTICES[2][2] # optional - polymake

-3319173990813887/4503599627370496

"""

def _repr_(self):

"""

String representation of polymake elements.

EXAMPLES:

In the case of a "big" object, if polymake provides a description

of the object that is not longer than single line, it is used for

printing::

sage: p = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: p # optional - polymake

Random spherical polytope of dimension 3; seed=15...

sage: c = polymake.cube(4) # optional - polymake

sage: c # optional - polymake

cube of dimension 4

We use the print representation of scalars to display scalars::

sage: p.N_VERTICES # optional - polymake

The items of a Perl arrays are shown separated by commas::

sage: p.get_member('list_properties') # optional - polymake # random

POINTS, CONE_AMBIENT_DIM, BOUNDED, FEASIBLE, N_POINTS, POINTED,

CONE_DIM, FULL_DIM, LINEALITY_DIM, LINEALITY_SPACE,

COMBINATORIAL_DIM, AFFINE_HULL, VERTICES, N_VERTICES

We chose to print rule chains explicitly, so that the user doesn't

need to know how to list the rules using polymake commands::

sage: r = p.get_schedule('"H_VECTOR"') # optional - polymake

sage: r # optional - polymake # random

precondition : N_RAYS | N_INPUT_RAYS ( ppl.convex_hull.primal: FACETS, LINEAR_SPAN : RAYS | INPUT_RAYS )

sensitivity check for FacetPerm

ppl.convex_hull.primal: FACETS, LINEAR_SPAN : RAYS | INPUT_RAYS

RAYS_IN_FACETS : RAYS, FACETS

SIMPLICIAL : COMBINATORIAL_DIM, RAYS_IN_FACETS

N_FACETS : FACETS

precondition : COMBINATORIAL_DIM ( F_VECTOR : N_FACETS, N_RAYS, COMBINATORIAL_DIM )

F_VECTOR : N_FACETS, N_RAYS, COMBINATORIAL_DIM

precondition : SIMPLICIAL ( H_VECTOR : F_VECTOR )

H_VECTOR : F_VECTOR

sage: r.typeof() # optional - polymake

('Polymake::Core::Scheduler::RuleChain', 'ARRAY')

Similarly, polymake matrices and vectors are explicitly listed::

sage: c.VERTICES.typename() # optional - polymake

'Matrix'

sage: c.VERTICES[0].typename() # optional - polymake

'Vector'

sage: c.VERTICES # optional - polymake # random

1 -1 -1 -1 -1

1 1 -1 -1 -1

1 -1 1 -1 -1

1 1 1 -1 -1

1 -1 -1 1 -1

1 1 -1 1 -1

1 -1 1 1 -1

1 1 1 1 -1

1 -1 -1 -1 1

1 1 -1 -1 1

1 -1 1 -1 1

1 1 1 -1 1

1 -1 -1 1 1

1 1 -1 1 1

1 -1 1 1 1

1 1 1 1 1

sage: c.VERTICES[0] # optional - polymake

1 -1 -1 -1 -1

For other types, we simply use the print representation offered

by polymake::

sage: p.TWO_FACE_SIZES.typename() # optional - polymake

'Map'

sage: p.TWO_FACE_SIZES # optional - polymake

{(3 20)}

"""

T1, T2 = self.typeof()

P = self._check_valid()

name = self._name

if T1:

Temp = self.typename()

if Temp:

T1 = Temp

if T1 in ['Matrix', 'Vector']:

out = P.get(name).strip()

elif 'RuleChain' in T1:

out = os.linesep.join(P.get('join("##",{}->list)'.format(name)).split('##'))

else:

try:

out = P.get('{}->description'.format(name)).strip()

except PolymakeError:

out = ''

if os.linesep in out:

out = ''

if not out:

if "Polytope" == T1:

out = "{}[{}]".format(P.get("{}->type->full_name".format(name)) or "PolymakeElement", _name_pattern.search(name).group())

elif T1=='' and T2=='ARRAY':

out = P.eval('print join(", ", @{});'.format(name)).strip()

elif T1=='' and T2=='HASH':

out = P.get('%{}'.format(name)).strip()

elif self._name[0] == '@':

out = P.eval('print join(", ", {});'.format(name)).strip()

else:

out = P.get(name).strip()

return out

def __cmp__(self, other):

"""

Comparison of polymake elements.

EXAMPLES:

The default for comparing equality for polytopes is *identity*::

sage: p1 = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: p2 = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: p1 == p2 # optional - polymake

False

However, other data types are compared by equality, not identity::

sage: p1.VERTICES == p2.VERTICES # optional - polymake

True

A computation applied to a polytope can change the available

properties, and thus we have

sage: p1.get_member('list_properties') == p2.get_member('list_properties') # optional - polymake

True

sage: p1.F_VECTOR # optional - polymake

12 30 20

sage: p1.get_member('list_properties') == p2.get_member('list_properties') # optional - polymake

False

"""

P = self._check_valid()

if P.eval("print %s %s %s;"%(self.name(), P._equality_symbol(), other.name())).strip() == P._true_symbol():

return 0

if P.eval("print %s %s %s;"%(self.name(), P._lessthan_symbol(), other.name())).strip() == P._true_symbol():

return -1

if P.eval("print %s %s %s;"%(self.name(), P._greaterthan_symbol(), other.name())).strip() == P._true_symbol():

return 1

return -2 # that's supposed to be an error value.

def bool(self):

"""

Return whether this polymake element is equal to ``True``.

EXAMPLES::

sage: from sage.interfaces.polymake import polymake

sage: polymake(0).bool() # optional polymake

False

sage: polymake(1).bool() # optional polymake

True

"""

P = self._check_valid()

t = P._true_symbol()

cmd = '%s %s %s;'%(self._name, P._equality_symbol(), t)

return P.get(cmd) == t

def known_properties(self):

"""

List the names of properties that have been computed so far on this element.

NOTE:

This is in many cases equivalent to use polymake's ``list_properties``,

which returns a blank separated string representation of the list of properties.

However, on some elements, ``list_properties`` would simply result in

an error.

EXAMPLES::

sage: c = polymake.cube(4) # optional - polymake

sage: c.known_properties() # optional - polymake

['AFFINE_HULL',

'BOUNDED',

'CONE_AMBIENT_DIM',

'CONE_DIM',

...

'VERTICES_IN_FACETS']

sage: c.list_properties() # optional - polymake

CONE_AMBIENT_DIM, CONE_DIM, FACETS, AFFINE_HULL, VERTICES_IN_FACETS,

BOUNDED...

A computation can change the list of known properties::

sage: c.F_VECTOR # optional - polymake

16 32 24 8

sage: c.known_properties() # optional - polymake

['AFFINE_HULL',

'BOUNDED',

'COMBINATORIAL_DIM',

'CONE_AMBIENT_DIM',

'CONE_DIM',

'DUAL_H_VECTOR',

'FACETS',

'FAR_FACE',

'FEASIBLE',

'FULL_DIM',

'F_VECTOR',

'GRAPH',

'LINEALITY_DIM',

'LINEALITY_SPACE',

'N_FACETS',

'N_VERTICES',

'POINTED',

'SIMPLE',

'SIMPLICIAL',

'VERTICES',

'VERTICES_IN_FACETS']

"""

P = self._check_valid()

try:

return sorted(P.get('join(", ", {}->list_properties)'.format(self._name)).split(', '))

except PolymakeError:

return []

@cached_method

def _member_list(self):

"""

The list of properties that polymake knows to compute for this element.

The resulting list is used for tab completion.

TESTS::

sage: c = polymake.cube(4) # optional - polymake

sage: c._member_list() # optional - polymake

['AFFINE_HULL',

'ALTSHULER_DET',

'BALANCE',

'BALANCED',

...

'WEAKLY_CENTERED',

'ZONOTOPE_INPUT_POINTS']

"""

### return the members of a "big" object.

P = self._check_valid()

try:

P.eval('$SAGETMP = typeof {+'+self._name+'};')

except (TypeError, PolymakeError): # this happens for a perl type that isn't a Polymake type

return []

cmd = 'print join(", ", sorted_uniq(sort { $a cmp $b } map { keys %{$_->properties} }$SAGETMP, @{$SAGETMP->super}));'

try:

out = P.eval(cmd).split(', ')

except PolymakeError as msg:

return []

return sorted(out)

def typename(self):

"""

The name of the underlying base type of this element in polymake.

EXAMPLES::

sage: c = polymake.cube(4) # optional - polymake

sage: c.typename() # optional - polymake

'Polytope'

sage: c.VERTICES.typename() # optional - polymake

'Matrix'

"""

P = self._check_valid()

try:

return P.eval('print {}->type->name;'.format(self._name))

except PolymakeError as msg:

return ''

def full_typename(self):

"""

The name of the specialised type of this element.

EXAMPLES::

sage: c = polymake.cube(4) # optional - polymake

sage: c.full_typename() # optional - polymake

'Polytope<Rational>'

sage: c.VERTICES.full_typename() # optional - polymake

'Matrix<Rational, NonSymmetric>'

"""

P = self._check_valid()

try:

return P.eval('print {}->type->full_name;'.format(self._name))

except PolymakeError as msg:

return ''

def qualified_typename(self):

"""

The qualified name of the type of this element.

EXAMPLES::

sage: c = polymake.cube(4) # optional - polymake

sage: c.qualified_typename() # optional - polymake

'polytope::Polytope<Rational>'

sage: c.VERTICES.qualified_typename() # optional - polymake

'common::Matrix<Rational, NonSymmetric>'

"""

P = self._check_valid()

try:

return P.eval('print {}->type->qualified_name;'.format(self._name))

except PolymakeError as msg:

return ''

def _tab_completion(self):

"""

Return a list of available function and property names.

NOTE:

This currently returns the names of functions defined in the current

application, regardless whether they can be applied to this element

or not, together with the list of properties of this element that

polymake knows how to compute. It does not contain the list of available

member functions of this element. This may change in future versions

of polymake.

EXAMPLES::

sage: c = polymake.cube(4) # optional - polymake

sage: c._tab_completion() # optional - polymake

['AFFINE_HULL',

'ALTSHULER_DET',

'BALANCE',

'BALANCED',

'BOUNDARY_LATTICE_POINTS',

...

'zero_vector',

'zonotope',

'zonotope_tiling_lattice',

'zonotope_vertices_fukuda']

"""

return sorted(self._member_list()+self.parent()._tab_completion())

def __getattr__(self, attrname):

"""

Return a property of this element, or a polymake function with this

element as first argument, or a member function of this element.

NOTE:

If the attribute name is known as the name of a property, it is

interpreted as such. Otherwise, if it is known as a function in

the current application, the function is returned with this

element inserted as first argument, and potential further arguments,

when called. Otherwise, it is assumed that it is a member function

of this element, and treated as such. Note that member functions

are currently invisible in tab completion, thus, the user has

to know the name of the member function.

EXAMPLES:

A property::

sage: c = polymake.cube(3) # optional - polymake

sage: c.H_VECTOR # optional - polymake

1 5 5 1

sage: c.N_VERTICES # optional - polymake

sage: d = polymake.cross(3) # optional - polymake

sage: d.N_VERTICES # optional - polymake

A function::

sage: c.minkowski_sum_fukuda # optional - polymake

minkowski_sum_fukuda (bound to Polymake::polytope::Polytope__Rational object)

sage: s = c.minkowski_sum_fukuda(d) # optional - polymake

sage: s.N_VERTICES # optional - polymake

sage: s # optional - polymake

Polytope<Rational>[SAGE...]

A member function::

sage: c = polymake.cube(2) # optional - polymake

sage: V = polymake.new_object('Vector', [1,0,0]) # optional - polymake

sage: V # optional - polymake

1 0 0

sage: c.contains # optional - polymake

Member function 'contains' of Polymake::polytope::Polytope__Rational object

sage: c.contains(V) # optional - polymake

"""

P = self._check_valid()

if attrname[:1] == "_":

raise AttributeError

if attrname not in P._tab_completion():

if attrname in self._member_list():

try:

return P('{}->{}'.format(self._name, attrname))

except (TypeError, PolymakeError):

raise AttributeError

else:

try:

return P._function_element_class()(self, '{}->{}'.format(self._name, attrname), memberfunction=True)

except (TypeError, PolymakeError):

raise AttributeError

return P._function_element_class()(self, attrname, memberfunction=False)

def get_member_function(self, attrname):

"""

Request a member function of this element.

NOTE:

It is not checked whether a member function with the given name

exists.

EXAMPLES::

sage: c = polymake.cube(2) # optional - polymake

sage: c.contains # optional - polymake

Member function 'contains' of Polymake::polytope::Polytope__Rational object

sage: V = polymake.new_object('Vector', [1,0,0]) # optional - polymake

sage: V # optional - polymake

1 0 0

sage: c.contains(V) # optional - polymake

Whether a member function of the given name actually exists for that

object will only be clear when calling it::

sage: c.get_member_function('foo') # optional - polymake

Member function 'foo' of Polymake::polytope::Polytope__Rational object

sage: c.get_member_function('foo')() # optional - polymake

Traceback (most recent call last):

...

TypeError: Can't locate object method "foo" via package "Polymake::polytope::Polytope__Rational" at input line 1.

"""

P = self._check_valid()

return P._function_element_class()(self, '{}->{}'.format(self._name, attrname), memberfunction=True)

def get_member(self, attrname):

"""

Get a member/property of this element.

NOTE:

Normally, it should be possible to just access the property

in the usual Python syntax for attribute access. However, if

that fails, one can request the member explicitly.

EXAMPLES::

sage: p = polymake.rand_sphere(4, 20, seed=5) # optional - polymake

Normally, a property would be accessed as follows::

sage: p.F_VECTOR # optional - polymake

20 101 162 81

However, explicit access is possible as well::

sage: p.get_member('F_VECTOR') # optional - polymake

20 101 162 81

In some cases, the explicit access works better::

sage: p.type # optional - polymake

Member function 'type' of Polymake::polytope::Polytope__Rational object

sage: p.get_member('type') # optional - polymake

Polytope<Rational>[SAGE...]

sage: p.get_member('type').get_member('name') # optional - polymake

Polytope

Note that in the last example calling the erroneously constructed

member function ``type`` still works::

sage: p.type() # optional - polymake

Polytope<Rational>[SAGE...]

"""

P = self._check_valid()

return P('%s->%s'%(self.name(), attrname))

def __getitem__(self, key):

"""

Indexing and slicing.

Slicing returns a Python list.

EXAMPLES::

sage: p = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: p.VERTICES[3] # optional - polymake

1 -6157731020575175/18014398509481984 4184896164481703/4503599627370496 -2527292586301447/18014398509481984

sage: p.list_properties()[2] # optional - polymake

BOUNDED

Slicing::

sage: p.F_VECTOR[:] # optional - polymake

[12, 30, 20]

sage: p.F_VECTOR[0:1] # optional - polymake

[12]

sage: p.F_VECTOR[0:3:2] # optional - polymake

[12, 20]

"""

P = self._check_valid()

if isinstance(key, slice):

indices = key.indices(len(self))

return [ self[i] for i in range(*indices) ]

_, T = self.typeof()

if self._name.startswith('@'):

return P('${}[{}]'.format(self._name[1:], key))

if T=='ARRAY':

return P('{}[{}]'.format(self._name, key))

if T=='HASH':

try:

if key.parent() is self.parent():

key = key._name

else:

key = str(key)

except AttributeError:

key = str(key)

return P(name+"{"+key+"}")

raise NotImplementedError("Cannot get items from Perl type {}".format(T))

def __iter__(self):

"""

Return an iterator for ``self``.

OUTPUT: iterator

EXAMPLES::

sage: p = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: [ x for x in p.VERTICES[3] ] # optional - polymake

[1, -6157731020575175/18014398509481984, 4184896164481703/4503599627370496, -2527292586301447/18014398509481984]

"""

for i in range(len(self)):

yield self[i]

def __len__(self):

"""

EXAMPLES::

sage: p = polymake.rand_sphere(3, 12, seed=15) # optional - polymake

sage: len(p.FACETS) # optional - polymake

sage: len(p.list_properties()) # optional - polymake

"""

P = self._check_valid()

T1,T2 = self.typeof()

name = self._name

if T2=='ARRAY':

return int(P.eval('print scalar @{+%s};'%name))

if T2=='HASH':

return int(P.eval('print scalar keys %{+%s};'%name))

if T1:

raise TypeError("Don't know how to compute the length of {} object".format(T1))

return int(P.eval('print scalar {};'.format(name)))

@cached_method

def typeof(self):

"""

Returns the type of a polymake "big" object, and its underlying Perl type.

NOTE:

This is mainly for internal use.

EXAMPLES::

sage: p = polymake.rand_sphere(3, 13, seed=12) # optional - polymake

sage: p.typeof() # optional - polymake

('Polymake::polytope::Polytope__Rational', 'ARRAY')

sage: p.VERTICES.typeof() # optional - polymake

('Polymake::common::Matrix_A_Rational_I_NonSymmetric_Z', 'ARRAY')

sage: p.get_schedule("F_VECTOR").typeof() # optional - polymake

('Polymake::Core::Scheduler::RuleChain', 'ARRAY')

On "small" objects, it just returns empty strings::

sage: p.N_VERTICES.typeof() # optional - polymake

('', '')

sage: p.list_properties().typeof() # optional - polymake

('', '')

"""

P = self._check_valid()

name = self._name

return P.eval('print ref({});'.format(name)), P.eval('print reftype({});'.format(name))

def _sage_(self):

"""

Convert self to a Sage object.

EXAMPLES::

sage: a = polymake(1/2); a # optional - polymake

1/2

sage: a.sage() # optional - polymake

1/2

sage: _.parent() # optional - polymake

Rational Field

Quadratic extensions::

sage: K.<sqrt5> = QuadraticField(5)

sage: polymake(K(0)).sage() # optional - polymake

sage: _.parent() # optional - polymake

Rational Field

sage: polymake(sqrt5).sage() # optional - polymake

sage: polymake(-sqrt5).sage() # optional - polymake

-a

sage: polymake(1/3-1/2*sqrt5).sage() # optional - polymake

-1/2*a + 1/3

sage: polymake(-1+sqrt5).sage() # optional - polymake

a - 1

Vectors::

sage: PP = polymake.cube(3) # optional - polymake

sage: PP.F_VECTOR.sage() # optional - polymake

(8, 12, 6)

sage: _.parent() # optional - polymake

Ambient free module of rank 3 over the principal ideal domain Integer Ring

Matrices::

sage: polymake.unit_matrix(2).sage() # optional - polymake

[1 0]

[0 1]

sage: _.parent() # optional - polymake

Full MatrixSpace of 2 by 2 dense matrices over Integer Ring

"""

T1, T2 = self.typeof()

P = self._check_valid()

if T1:

Temp = self.typename()

if Temp:

T1 = Temp

if T1 == 'QuadraticExtension':

# We can't seem to access a, b, r by method calls, so let's parse.

from re import match

m = match(r'(-?[0-9/]+)[+]?((-?[0-9/]+)r([0-9/]+))?', repr(self))

if m is None:

raise NotImplementedError("Cannot parse QuadraticExtension element: {}".format(self))

a, b, r = m.group(1), m.group(3), m.group(4)

from sage.rings.rational_field import QQ

if r is None:

# Prints like a rational, so we can't know the extension. Coerce to rational.

return QQ(a)

else:

from sage.rings.number_field.number_field import QuadraticField

K = QuadraticField(r)

return QQ(a) + QQ(b) * K.gen()

elif T1 == 'Vector' or T1 == 'SparseVector':

from sage.modules.free_module_element import vector

return vector([x.sage() for x in self])

elif T1 == 'Matrix' or T1 == 'SparseMatrix':

from sage.matrix.constructor import matrix

return matrix([x.sage() for x in self])

else:

return super(PolymakeElement, self)._sage_()

def _sage_doc_(self):

"""

EXAMPLES::

sage: c = polymake.cube(3) # optional - polymake

sage: print(c._sage_doc_()) # optional - polymake # random

objects/Polytope:

Not necessarily bounded or unbounded polyhedron.

Nonetheless, the name "Polytope" is used for two reasons:

Firstly, combinatorially we always deal with polytopes; see the description of VERTICES_IN_FACETS for details.

The second reason is historical.

We use homogeneous coordinates, which is why Polytope is derived from Cone.

Note that a pointed polyhedron is projectively equivalent to a polytope.

Scalar is the numeric data type used for the coordinates.

objects/Polytope/specializations/Polytope<Rational>:

A rational polyhedron realized in Q^d

sage: print(c.FACETS._sage_doc_()) # optional - polymake # random

property_types/Algebraic Types/SparseMatrix:

A SparseMatrix is a two-dimensional associative array with row and column indices as keys; elements equal to the default value (ElementType(), which is 0 for most numerical types) are not stored, but implicitly encoded by the gaps in the key set. Each row and column is organized as an AVL-tree.

Use dense to convert this into its dense form.

You can create a new SparseMatrix by entering its entries row by row, as a list of SparseVectors e.g.:

$A = new SparseMatrix<Int>(<< '.');

(5) (1 1)

(5) (4 2)

(5)

(5) (0 3) (1 -1)

"""

P = self._check_valid()

# according to Julian Pfeifle, the only case in which the fully qualified

# typename would not provide the doc.

Tname = self.typename()

Tqname = self.qualified_typename()

Tfname = self.full_typename()

if Tname == 'Polytope':

try:

doc = P.eval('help "Polytope";')

except PolymakeError:

doc = ''

else:

try:

doc = P.eval('help "{}";'.format(Tname))

except PolymakeError:

doc = ''

try:

doc2 = P.eval('help "{}";'.format(Tqname))

except PolymakeError:

doc2 = ''

if doc:

if doc2:

doc = doc+os.linesep+doc2

else:

doc = doc2

try:

doc3 = P.eval('help "{}";'.format(Tfname))

except PolymakeError:

doc3 = ''

if doc:

if doc3:

doc = doc+os.linesep+doc3

else:

doc = doc3

if doc:

return doc

return "Undocumented polymake type '{}'".format(self.full_typename())

class PolymakeFunctionElement(FunctionElement):

"""

A callable (function or member function) bound to a polymake element.

EXAMPLES::

sage: c = polymake.cube(2) # optional - polymake

sage: V = polymake.new_object('Vector', [1,0,0]) # optional - polymake

sage: V # optional - polymake

1 0 0

sage: c.contains # optional - polymake

Member function 'contains' of Polymake::polytope::Polytope__Rational object

sage: c.contains(V) # optional - polymake

"""

def __init__(self, obj, name, memberfunction=False):

"""

INPUT:

- Polymake object that this function is bound to

- name (string): It actually says how to call this function in polymake.

So, if it is a member function, it will look like `"$SAGE123[0]->func_name"`.

- ``memberfunction`` (bool, default False): Whether this is a member function

or a plain function applied with this element as first argument.

EXAMPLES::

sage: p = polymake.rand_sphere(3, 13, seed=12) # optional - polymake

sage: p.minkowski_sum_fukuda # optional - polymake

minkowski_sum_fukuda (bound to Polymake::polytope::Polytope__Rational object)

sage: p.get_schedule # optional - polymake

Member function 'get_schedule' of Polymake::polytope::Polytope__Rational object

"""

self._obj = obj

self._name = name

self._is_memberfunc = memberfunction

def _repr_(self):

"""

EXAMPLES::

sage: p = polymake.rand_sphere(3, 13, seed=12) # optional - polymake

sage: p.minkowski_sum_fukuda # optional - polymake

minkowski_sum_fukuda (bound to Polymake::polytope::Polytope__Rational object)

sage: p.contains # optional - polymake

Member function 'contains' of Polymake::polytope::Polytope__Rational object

"""

if self._is_memberfunc:

return "Member function '{}' of {} object".format(self._name.split("->")[-1], self._obj.typeof()[0])

return "{} (bound to {} object)".format(self._name, self._obj.typeof()[0])

def __call__(self, *args, **kwds):

"""

EXAMPLES:

We consider both member functions of an element and global functions

bound to an element::

sage: p = polymake.rand_sphere(3, 13, seed=12) # optional - polymake

sage: p.get_schedule('VERTICES') # optional - polymake # random

sensitivity check for VertexPerm

cdd.convex_hull.canon: POINTED, RAYS, LINEALITY_SPACE : INPUT_RAYS

sage: p.minkowski_sum_fukuda(p).F_VECTOR # optional - polymake

13 33 22

"""

if self._is_memberfunc:

return self._obj._check_valid().function_call(self._name, list(args), kwds)

return self._obj._check_valid().function_call(self._name, [self._obj] + list(args), kwds)

def _sage_doc_(self):

"""

Return documentation of this function.

NOTE:

For unclear reasons, accessing documentation with `?` sometimes

does not include the return value of this method.

EXAMPLES::

sage: p = polymake.rand_sphere(3, 13, seed=12) # optional - polymake

sage: print(p.get_schedule._sage_doc_()) # optional - polymake # random

objects/Core::Object/methods/get_schedule:

get_schedule(request; ... ) -> Core::RuleChain

Compose an optimal chain of production rules providing all requested properties.

The returned RuleChain object can be applied to the original object as well as to any other object

with the same initial set of properties. If no feasible rule chain exists, `undef' is returned.

To watch the rule scheduler at work, e.g. to see announcements about tried preconditions,

you may temporarily increase the verbosity levels $Verbose::rules and $Verbose::scheduler.

Arguments:

String request : name of a property with optional alternatives or a property path in dotted notation.

Several requests may be listed.

Returns Core::RuleChain

sage: print(p.minkowski_sum_fukuda._sage_doc_()) # optional - polymake # random

functions/Producing a polytope from polytopes/minkowski_sum_fukuda:

minkowski_sum_fukuda(summands) -> Polytope<Scalar>

Computes the (VERTICES of the) Minkowski sum of a list of polytopes using the algorithm by Fukuda described in

Komei Fukuda, From the zonotope construction to the Minkowski addition of convex polytopes, J. Symbolic Comput., 38(4):1261-1272, 2004.

Arguments:

Array<Polytope<Scalar>> summands

Returns Polytope<Scalar>

Example:

> $p = minkowski_sum_fukuda([cube(2),simplex(2),cross(2)]);

> print $p->VERTICES;

1 -2 -1

1 -1 -2

1 3 -1

1 3 1

1 2 -2

1 -2 2

1 -1 3

1 1 3

"""

P = self._obj._check_valid()

return P.help(self._name.split("->")[-1], pager=False)

Coverage for local/lib/python2.7/site-packages/sage/interfaces/polymake.py : 5%

553 statements 30 run 523 missing 0 excluded